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 eATTRIBUTE:
04856 return TRUE;
04857 case eMACRO_EXPR:
04858 return Arg<CNode*>(1)->IsWidthConstant();
04859 default:
04860 MASSERT( FALSE );
04861 return 0;
04862 }
04863 }
04864
04865
04866
04867
04868
04869
04870 int CNode::IsWidthVolatile( )
04871 {
04872 switch( GetOp() ) {
04873 case eERROR:
04874 return FALSE;
04875 case eVCONSTANT:
04876 return Arg<CVector*>(0)->IsWidthVolatile();
04877 case eRCONSTANT:
04878 return FALSE;
04879 case eELIST:
04880 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04881 case eWIDTH:
04882 return Arg<CNode*>(0)->IsVolatile();
04883 case eSUB:
04884 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04885 case eMUL:
04886 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04887 case eDIV:
04888 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04889 case ePOW:
04890 return Arg<CNode*>(0)->IsWidthVolatile();
04891 case eADD:
04892 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04893 case eLSH:
04894 return Arg<CNode*>(0)->IsWidthVolatile();
04895 case eRSH:
04896 return Arg<CNode*>(0)->IsWidthVolatile();
04897 case eLSHA:
04898 return Arg<CNode*>(0)->IsWidthVolatile();
04899 case eRSHA:
04900 return Arg<CNode*>(0)->IsWidthVolatile();
04901 case eMOD:
04902 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04903 case eOR:
04904 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04905 case eAND:
04906 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04907 case eANDANDAND:
04908 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04909 case eXOR:
04910 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04911 case eXNOR:
04912 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04913 case eSYSTASK_CALL:
04914 return Systask::WidthVolatile(Arg<CSymbol*>(0),Arg<CNode*>(1));
04915 case eFUNCTION_CALL:
04916 return CFunction::WidthVolatile(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
04917 case eARRAY:
04918 return Array::WidthVolatile(Arg<CNode*>(0),Arg<CNode*>(1));
04919 case eNET_REF:
04920 return Arg<CNet*>(0)->IsWidthVolatile();
04921 case eREG_REF:
04922 return Arg<CReg*>(0)->IsWidthVolatile();
04923 case eREAL_REF:
04924 return Arg<CReal*>(0)->IsWidthVolatile();
04925 case ePARAM_REF:
04926 return Arg<CParam*>(0)->IsWidthVolatile();
04927 case ePORT_REF:
04928 return Arg<CPortDir*>(0)->IsWidthVolatile();
04929 case eFWD_REF:
04930 return Arg<CFref*>(0)->IsWidthVolatile();
04931 case eGENVAR_REF:
04932 return Arg<CGenvar*>(0)->IsWidthVolatile();
04933 case eRANGE:
04934 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04935 case eSLICE:
04936 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsVolatile();
04937 case ePSLICE:
04938 return Arg<CNode*>(1)->IsVolatile();
04939 case eMSLICE:
04940 return Arg<CNode*>(1)->IsVolatile();
04941 case eCVRI:
04942 return FALSE;
04943 case eCVIR:
04944 return FALSE;
04945 case eREP:
04946 return Arg<CNode*>(0)->IsVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04947 case eCAT:
04948 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile();
04949 case eUCAT:
04950 return Arg<CNode*>(0)->IsWidthVolatile();
04951 case eCOM:
04952 return Arg<CNode*>(0)->IsWidthVolatile();
04953 case eNEG:
04954 return Arg<CNode*>(0)->IsWidthVolatile();
04955 case eNOT:
04956 return FALSE;
04957 case eGT:
04958 return FALSE;
04959 case eGE:
04960 return FALSE;
04961 case eLT:
04962 return FALSE;
04963 case eLE:
04964 return FALSE;
04965 case eLAND:
04966 return FALSE;
04967 case eLOR:
04968 return FALSE;
04969 case eCEQ:
04970 return FALSE;
04971 case eCNE:
04972 return FALSE;
04973 case eEQ:
04974 return FALSE;
04975 case eNE:
04976 return FALSE;
04977 case eRAND:
04978 return FALSE;
04979 case eRNAND:
04980 return FALSE;
04981 case eROR:
04982 return FALSE;
04983 case eRNOR:
04984 return FALSE;
04985 case eRXOR:
04986 return FALSE;
04987 case eRXNOR:
04988 return FALSE;
04989 case eHOOK:
04990 return Arg<CNode*>(1)->IsWidthVolatile() || Arg<CNode*>(2)->IsWidthVolatile();
04991 case eMTM:
04992 return Arg<CNode*>(0)->IsWidthVolatile() || Arg<CNode*>(1)->IsWidthVolatile() || Arg<CNode*>(2)->IsWidthVolatile();
04993 case eEXTERNAL_REF:
04994 return External::WidthVolatile(Arg<CSymbol*>(0));
04995 case eATTRIBUTE:
04996 return FALSE;
04997 case eMACRO_EXPR:
04998 return Arg<CNode*>(1)->IsWidthVolatile();
04999 default:
05000 MASSERT( FALSE );
05001 return 0;
05002 }
05003
05004 }
05005
05006
05007
05008
05009
05010
05011
05012 CNode* CNode::GetWidthExp()
05013 {
05014 switch( GetOp() ) {
05015 case eERROR:
05016 return NULL;
05017 case eVCONSTANT:
05018 return Arg<CVector*>(0)->GetWidthExp();
05019 case eRCONSTANT:
05020 return NULL;
05021 case eELIST:
05022 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cADD_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05023 case eWIDTH:
05024 return cINT32(Arg<CNode*>(0)->EvalINT32());
05025 case eSUB:
05026 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05027 case eMUL:
05028 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05029 case eDIV:
05030 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05031 case ePOW:
05032 return Arg<CNode*>(0)->GetWidthExp();
05033 case eADD:
05034 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05035 case eLSH:
05036 return Arg<CNode*>(0)->GetWidthExp();
05037 case eRSH:
05038 return Arg<CNode*>(0)->GetWidthExp();
05039 case eLSHA:
05040 return Arg<CNode*>(0)->GetWidthExp();
05041 case eRSHA:
05042 return Arg<CNode*>(0)->GetWidthExp();
05043 case eMOD:
05044 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05045 case eOR:
05046 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05047 case eAND:
05048 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05049 case eANDANDAND:
05050 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05051 case eXOR:
05052 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05053 case eXNOR:
05054 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05055 case eSYSTASK_CALL:
05056 return Systask::WidthExp(Arg<CSymbol*>(0),Arg<CNode*>(1));
05057 case eFUNCTION_CALL:
05058 return CFunction::WidthExp(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
05059 case eARRAY:
05060 return Array::WidthExp(Arg<CNode*>(0),Arg<CNode*>(1));
05061 case eNET_REF:
05062 return Arg<CNet*>(0)->GetWidthExp();
05063 case eREG_REF:
05064 return Arg<CReg*>(0)->GetWidthExp();
05065 case eREAL_REF:
05066 return Arg<CReal*>(0)->GetWidthExp();
05067 case ePARAM_REF:
05068 return Arg<CParam*>(0)->GetWidthExp();
05069 case ePORT_REF:
05070 return Arg<CPortDir*>(0)->GetWidthExp();
05071 case eFWD_REF:
05072 return Arg<CFref*>(0)->GetWidthExp();
05073 case eGENVAR_REF:
05074 return Arg<CGenvar*>(0)->GetWidthExp();
05075 case eRANGE:
05076 return (1 && 1) ? cABSDIFFPLUS1_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->Clone(),NULL) : NULL;
05077 case eSLICE:
05078 return (1 && 1) ? cABSDIFFPLUS1_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->Clone(),NULL) : NULL;
05079 case ePSLICE:
05080 return cINT32(Arg<CNode*>(1)->EvalINT32());
05081 case eMSLICE:
05082 return cINT32(Arg<CNode*>(1)->EvalINT32());
05083 case eCVRI:
05084 return cINT32(32);
05085 case eCVIR:
05086 return NULL;
05087 case eREP:
05088 return (1 && Arg<CNode*>(1)->GetWidthExp()) ? cMUL_N(Arg<CNode*>(0)->Clone(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05089 case eCAT:
05090 return (Arg<CNode*>(0)->GetWidthExp() && Arg<CNode*>(1)->GetWidthExp()) ? cADD_N(Arg<CNode*>(0)->GetWidthExp(),Arg<CNode*>(1)->GetWidthExp(),NULL) : NULL;
05091 case eUCAT:
05092 return Arg<CNode*>(0)->GetWidthExp();
05093 case eCOM:
05094 return Arg<CNode*>(0)->GetWidthExp();
05095 case eNEG:
05096 return Arg<CNode*>(0)->GetWidthExp();
05097 case eNOT:
05098 return cINT32(1);
05099 case eGT:
05100 return cINT32(1);
05101 case eGE:
05102 return cINT32(1);
05103 case eLT:
05104 return cINT32(1);
05105 case eLE:
05106 return cINT32(1);
05107 case eLAND:
05108 return cINT32(1);
05109 case eLOR:
05110 return cINT32(1);
05111 case eCEQ:
05112 return cINT32(1);
05113 case eCNE:
05114 return cINT32(1);
05115 case eEQ:
05116 return cINT32(1);
05117 case eNE:
05118 return cINT32(1);
05119 case eRAND:
05120 return cINT32(1);
05121 case eRNAND:
05122 return cINT32(1);
05123 case eROR:
05124 return cINT32(1);
05125 case eRNOR:
05126 return cINT32(1);
05127 case eRXOR:
05128 return cINT32(1);
05129 case eRXNOR:
05130 return cINT32(1);
05131 case eHOOK:
05132 return (Arg<CNode*>(1)->GetWidthExp() && Arg<CNode*>(2)->GetWidthExp()) ? cMAX_N(Arg<CNode*>(1)->GetWidthExp(),Arg<CNode*>(2)->GetWidthExp(),NULL) : NULL;
05133 case eMTM:
05134 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;
05135 case eEXTERNAL_REF:
05136 return External::WidthExp(Arg<CSymbol*>(0));
05137 case eATTRIBUTE:
05138 return cINT32(0);
05139 case eMACRO_EXPR:
05140 return Arg<CNode*>(1)->GetWidthExp();
05141 default:
05142 MASSERT( FALSE );
05143 return NULL;
05144 }
05145 }
05146
05147
05148
05149
05150
05151
05152 int CNode::IsWidthEvaluateable( )
05153 {
05154 switch( GetOp() ) {
05155 case eERROR:
05156 return FALSE;
05157 case eVCONSTANT:
05158 return Arg<CVector*>(0)->IsWidthEvaluateable();
05159 case eRCONSTANT:
05160 return FALSE;
05161 case eELIST:
05162 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05163 case eWIDTH:
05164 return Arg<CNode*>(0)->IsEvaluateable();
05165 case eSUB:
05166 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05167 case eMUL:
05168 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05169 case eDIV:
05170 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05171 case ePOW:
05172 return Arg<CNode*>(0)->IsWidthEvaluateable();
05173 case eADD:
05174 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05175 case eLSH:
05176 return Arg<CNode*>(0)->IsWidthEvaluateable();
05177 case eRSH:
05178 return Arg<CNode*>(0)->IsWidthEvaluateable();
05179 case eLSHA:
05180 return Arg<CNode*>(0)->IsWidthEvaluateable();
05181 case eRSHA:
05182 return Arg<CNode*>(0)->IsWidthEvaluateable();
05183 case eMOD:
05184 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05185 case eOR:
05186 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05187 case eAND:
05188 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05189 case eANDANDAND:
05190 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05191 case eXOR:
05192 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05193 case eXNOR:
05194 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05195 case eSYSTASK_CALL:
05196 return Systask::WidthEvaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1));
05197 case eFUNCTION_CALL:
05198 return CFunction::WidthEvaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CScope*>(2));
05199 case eARRAY:
05200 return Array::WidthEvaluateable(Arg<CNode*>(0),Arg<CNode*>(1));
05201 case eNET_REF:
05202 return Arg<CNet*>(0)->IsWidthEvaluateable();
05203 case eREG_REF:
05204 return Arg<CReg*>(0)->IsWidthEvaluateable();
05205 case eREAL_REF:
05206 return Arg<CReal*>(0)->IsWidthEvaluateable();
05207 case ePARAM_REF:
05208 return Arg<CParam*>(0)->IsWidthEvaluateable();
05209 case ePORT_REF:
05210 return Arg<CPortDir*>(0)->IsWidthEvaluateable();
05211 case eFWD_REF:
05212 return Arg<CFref*>(0)->IsWidthEvaluateable();
05213 case eGENVAR_REF:
05214 return Arg<CGenvar*>(0)->IsWidthEvaluateable();
05215 case eRANGE:
05216 return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsEvaluateable();
05217 case eSLICE:
05218 return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsEvaluateable();
05219 case ePSLICE:
05220 return Arg<CNode*>(1)->IsEvaluateable();
05221 case eMSLICE:
05222 return Arg<CNode*>(1)->IsEvaluateable();
05223 case eCVRI:
05224 return TRUE;
05225 case eCVIR:
05226 return FALSE;
05227 case eREP:
05228 return Arg<CNode*>(0)->IsEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05229 case eCAT:
05230 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable();
05231 case eUCAT:
05232 return Arg<CNode*>(0)->IsWidthEvaluateable();
05233 case eCOM:
05234 return Arg<CNode*>(0)->IsWidthEvaluateable();
05235 case eNEG:
05236 return Arg<CNode*>(0)->IsWidthEvaluateable();
05237 case eNOT:
05238 return TRUE;
05239 case eGT:
05240 return TRUE;
05241 case eGE:
05242 return TRUE;
05243 case eLT:
05244 return TRUE;
05245 case eLE:
05246 return TRUE;
05247 case eLAND:
05248 return TRUE;
05249 case eLOR:
05250 return TRUE;
05251 case eCEQ:
05252 return TRUE;
05253 case eCNE:
05254 return TRUE;
05255 case eEQ:
05256 return TRUE;
05257 case eNE:
05258 return TRUE;
05259 case eRAND:
05260 return TRUE;
05261 case eRNAND:
05262 return TRUE;
05263 case eROR:
05264 return TRUE;
05265 case eRNOR:
05266 return TRUE;
05267 case eRXOR:
05268 return TRUE;
05269 case eRXNOR:
05270 return TRUE;
05271 case eHOOK:
05272 return Arg<CNode*>(1)->IsWidthEvaluateable() && Arg<CNode*>(2)->IsWidthEvaluateable();
05273 case eMTM:
05274 return Arg<CNode*>(0)->IsWidthEvaluateable() && Arg<CNode*>(1)->IsWidthEvaluateable() && Arg<CNode*>(2)->IsWidthEvaluateable();
05275 case eEXTERNAL_REF:
05276 return External::WidthEvaluateable(Arg<CSymbol*>(0));
05277 case eATTRIBUTE:
05278 return TRUE;
05279 case eMACRO_EXPR:
05280 return Arg<CNode*>(1)->IsWidthEvaluateable();
05281 default:
05282 MASSERT( FALSE );
05283 return 0;
05284 }
05285 }
05286
05287
05288
05289
05290
05291
05292
05293
05294 int CNode::IsNonX( int integerIsNonX, char* exclude )
05295 {
05296 switch( GetOp() ) {
05297 case eERROR:
05298 return FALSE;
05299 case eVCONSTANT:
05300 return !Arg<CVector*>(0)->HasXZ();
05301 case eRCONSTANT:
05302 return TRUE;
05303 case eELIST:
05304 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05305 case eWIDTH:
05306 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05307 case eSUB:
05308 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05309 case eMUL:
05310 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05311 case eDIV:
05312 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05313 case ePOW:
05314 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05315 case eADD:
05316 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05317 case eLSH:
05318 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05319 case eRSH:
05320 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05321 case eLSHA:
05322 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05323 case eRSHA:
05324 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05325 case eMOD:
05326 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05327 case eOR:
05328 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05329 case eAND:
05330 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05331 case eANDANDAND:
05332 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05333 case eXOR:
05334 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05335 case eXNOR:
05336 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05337 case eSYSTASK_CALL:
05338 return FALSE;
05339 case eFUNCTION_CALL:
05340 return FALSE;
05341 case eARRAY:
05342 return FALSE;
05343 case eNET_REF:
05344 return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
05345
05346 (integerIsNonX && Arg<CDecl*>(0)->GetType() == eINT);
05347 case eREG_REF:
05348 return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
05349
05350 (integerIsNonX && Arg<CDecl*>(0)->GetType() == eINT);
05351 case eREAL_REF:
05352 return TRUE;
05353 case ePARAM_REF:
05354 return TRUE;
05355 case ePORT_REF:
05356 return Arg<CDecl*>(0)->HasAttribute( exclude ) ||
05357
05358 (integerIsNonX && Arg<CDecl*>(0)->GetType() == eINT);
05359 case eFWD_REF:
05360 return FALSE;
05361 case eGENVAR_REF:
05362 return TRUE;
05363 case eRANGE:
05364 return FALSE;
05365 case eSLICE:
05366 return FALSE;
05367 case ePSLICE:
05368 return FALSE;
05369 case eMSLICE:
05370 return FALSE;
05371 case eCVRI:
05372 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05373 case eCVIR:
05374 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05375 case eREP:
05376 return Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05377 case eCAT:
05378 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05379 case eUCAT:
05380 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05381 case eCOM:
05382 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05383 case eNEG:
05384 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05385 case eNOT:
05386 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05387 case eGT:
05388 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05389 case eGE:
05390 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05391 case eLT:
05392 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05393 case eLE:
05394 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05395 case eLAND:
05396 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05397 case eLOR:
05398 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05399 case eCEQ:
05400 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05401 case eCNE:
05402 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05403 case eEQ:
05404 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05405 case eNE:
05406 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude );
05407 case eRAND:
05408 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05409 case eRNAND:
05410 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05411 case eROR:
05412 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05413 case eRNOR:
05414 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05415 case eRXOR:
05416 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05417 case eRXNOR:
05418 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude );
05419 case eHOOK:
05420 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(2)->IsNonX( integerIsNonX, exclude );
05421 case eMTM:
05422 return Arg<CNode*>(0)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(1)->IsNonX( integerIsNonX, exclude ) && Arg<CNode*>(2)->IsNonX( integerIsNonX, exclude );
05423 case eEXTERNAL_REF:
05424 return FALSE;
05425 case eMACRO_EXPR:
05426 return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsNonX(integerIsNonX, exclude) : FALSE;
05427 default:
05428 MASSERT( FALSE );
05429 return 0;
05430 }
05431 }
05432
05433
05434
05435
05436
05437
05438
05439 CNode* CNode::Clone()
05440 {
05441 int nodeMask = 0;
05442 switch( GetOp() ) {
05443 case eERROR:
05444 nodeMask = 0;
05445 break;
05446 case eVCONSTANT:
05447 nodeMask = 0;
05448 break;
05449 case eRCONSTANT:
05450 nodeMask = 0;
05451 break;
05452 case eCOMMENT:
05453 nodeMask = 0;
05454 break;
05455 case eVRQ:
05456 nodeMask = 0;
05457 break;
05458 case ePRAGMA:
05459 nodeMask = 0;
05460 break;
05461 case eELIST:
05462 nodeMask = 3;
05463 break;
05464 case eWIDTH:
05465 nodeMask = 3;
05466 break;
05467 case eNOP:
05468 nodeMask = 0;
05469 break;
05470 case eSUB:
05471 nodeMask = 3;
05472 break;
05473 case eMUL:
05474 nodeMask = 3;
05475 break;
05476 case eDIV:
05477 nodeMask = 3;
05478 break;
05479 case ePOW:
05480 nodeMask = 3;
05481 break;
05482 case eADD:
05483 nodeMask = 3;
05484 break;
05485 case eLSH:
05486 nodeMask = 3;
05487 break;
05488 case eRSH:
05489 nodeMask = 3;
05490 break;
05491 case eLSHA:
05492 nodeMask = 3;
05493 break;
05494 case eRSHA:
05495 nodeMask = 3;
05496 break;
05497 case eMOD:
05498 nodeMask = 3;
05499 break;
05500 case eOR:
05501 nodeMask = 3;
05502 break;
05503 case eAND:
05504 nodeMask = 3;
05505 break;
05506 case eANDANDAND:
05507 nodeMask = 3;
05508 break;
05509 case eXOR:
05510 nodeMask = 3;
05511 break;
05512 case eXNOR:
05513 nodeMask = 3;
05514 break;
05515 case eINSTANCE_REF:
05516 nodeMask = 0;
05517 break;
05518 case eGATE_REF:
05519 nodeMask = 0;
05520 break;
05521 case eTASK_ENABLE:
05522 nodeMask = 2;
05523 break;
05524 case eSYSTASK_CALL:
05525 nodeMask = 2;
05526 break;
05527 case eTIMING_CALL:
05528 nodeMask = 2;
05529 break;
05530 case eFUNCTION_CALL:
05531 nodeMask = 2;
05532 break;
05533 case eARRAY:
05534 nodeMask = 3;
05535 break;
05536 case eNET_REF:
05537 nodeMask = 0;
05538 break;
05539 case eREG_REF:
05540 nodeMask = 0;
05541 break;
05542 case eREAL_REF:
05543 nodeMask = 0;
05544 break;
05545 case ePARAM_REF:
05546 nodeMask = 0;
05547 break;
05548 case ePORT_REF:
05549 nodeMask = 0;
05550 break;
05551 case eFWD_REF:
05552 nodeMask = 0;
05553 break;
05554 case eEVENT_REF:
05555 nodeMask = 0;
05556 break;
05557 case eGENVAR_REF:
05558 nodeMask = 0;
05559 break;
05560 case eNET_DECL:
05561 nodeMask = 2;
05562 break;
05563 case eREG_DECL:
05564 nodeMask = 2;
05565 break;
05566 case eREAL_DECL:
05567 nodeMask = 2;
05568 break;
05569 case ePARAM_DECL:
05570 nodeMask = 0;
05571 break;
05572 case eSPECPARAM_DECL:
05573 nodeMask = 0;
05574 break;
05575 case ePORT_DECL:
05576 nodeMask = 0;
05577 break;
05578 case eEVENT_DECL:
05579 nodeMask = 0;
05580 break;
05581 case eGENVAR_DECL:
05582 nodeMask = 0;
05583 break;
05584 case eLIST:
05585 nodeMask = 3;
05586 break;
05587 case eRANGE:
05588 nodeMask = 3;
05589 break;
05590 case eSLICE:
05591 nodeMask = 3;
05592 break;
05593 case ePSLICE:
05594 nodeMask = 3;
05595 break;
05596 case eMSLICE:
05597 nodeMask = 3;
05598 break;
05599 case eCVRI:
05600 nodeMask = 1;
05601 break;
05602 case eCVIR:
05603 nodeMask = 1;
05604 break;
05605 case eREP:
05606 nodeMask = 3;
05607 break;
05608 case eCAT:
05609 nodeMask = 3;
05610 break;
05611 case eUCAT:
05612 nodeMask = 1;
05613 break;
05614 case eCOM:
05615 nodeMask = 1;
05616 break;
05617 case eNEG:
05618 nodeMask = 1;
05619 break;
05620 case eNOT:
05621 nodeMask = 1;
05622 break;
05623 case eGT:
05624 nodeMask = 3;
05625 break;
05626 case eGE:
05627 nodeMask = 3;
05628 break;
05629 case eLT:
05630 nodeMask = 3;
05631 break;
05632 case eLE:
05633 nodeMask = 3;
05634 break;
05635 case eLAND:
05636 nodeMask = 3;
05637 break;
05638 case eLOR:
05639 nodeMask = 3;
05640 break;
05641 case eCEQ:
05642 nodeMask = 3;
05643 break;
05644 case eCNE:
05645 nodeMask = 3;
05646 break;
05647 case eEQ:
05648 nodeMask = 3;
05649 break;
05650 case eNE:
05651 nodeMask = 3;
05652 break;
05653 case eRAND:
05654 nodeMask = 1;
05655 break;
05656 case eRNAND:
05657 nodeMask = 1;
05658 break;
05659 case eROR:
05660 nodeMask = 1;
05661 break;
05662 case eRNOR:
05663 nodeMask = 1;
05664 break;
05665 case eRXOR:
05666 nodeMask = 1;
05667 break;
05668 case eRXNOR:
05669 nodeMask = 1;
05670 break;
05671 case eHOOK:
05672 nodeMask = 7;
05673 break;
05674 case eINIT:
05675 nodeMask = 1;
05676 break;
05677 case eALWAYS:
05678 nodeMask = 1;
05679 break;
05680 case eEVENT:
05681 nodeMask = 3;
05682 break;
05683 case eBLOCK_REF:
05684 nodeMask = 2;
05685 break;
05686 case eSPECIFY_REF:
05687 nodeMask = 2;
05688 break;
05689 case eASSIGN:
05690 nodeMask = 7;
05691 break;
05692 case eFORCE:
05693 nodeMask = 3;
05694 break;
05695 case eRELEASE:
05696 nodeMask = 1;
05697 break;
05698 case eNBASSIGN:
05699 nodeMask = 7;
05700 break;
05701 case ePOSEDGE:
05702 nodeMask = 1;
05703 break;
05704 case eNEGEDGE:
05705 nodeMask = 1;
05706 break;
05707 case eEDGE:
05708 nodeMask = 1;
05709 break;
05710 case eEVOR:
05711 nodeMask = 3;
05712 break;
05713 case eDELAY:
05714 nodeMask = 3;
05715 break;
05716 case eMTM:
05717 nodeMask = 7;
05718 break;
05719 case eIF:
05720 nodeMask = 7;
05721 break;
05722 case eFOREVER:
05723 nodeMask = 1;
05724 break;
05725 case eREPEAT:
05726 nodeMask = 3;
05727 break;
05728 case eWHILE:
05729 nodeMask = 3;
05730 break;
05731 case eWAIT:
05732 nodeMask = 3;
05733 break;
05734 case eFOR:
05735 nodeMask = 15;
05736 break;
05737 case eCASE:
05738 nodeMask = 3;
05739 break;
05740 case eCASEX:
05741 nodeMask = 3;
05742 break;
05743 case eCASEZ:
05744 nodeMask = 3;
05745 break;
05746 case eCASEITEM:
05747 nodeMask = 3;
05748 break;
05749 case eCASSIGN:
05750 nodeMask = 14;
05751 break;
05752 case eARG:
05753 nodeMask = 2;
05754 break;
05755 case eFUNCTION_DEF:
05756 nodeMask = 0;
05757 break;
05758 case eMODULE_DEF:
05759 nodeMask = 0;
05760 break;
05761 case eREPEAT_CONTROL:
05762 nodeMask = 3;
05763 break;
05764 case eDELAY_CONTROL:
05765 nodeMask = 1;
05766 break;
05767 case eEVENT_CONTROL:
05768 nodeMask = 1;
05769 break;
05770 case eEXTERNAL_REF:
05771 nodeMask = 0;
05772 break;
05773 case ePORT_DEF:
05774 nodeMask = 0;
05775 break;
05776 case eDEFPARAM:
05777 nodeMask = 3;
05778 break;
05779 case ePATH:
05780 nodeMask = 82;
05781 break;
05782 case ePATH_ASSIGN:
05783 nodeMask = 7;
05784 break;
05785 case eIFNONE_PATH_ASSIGN:
05786 nodeMask = 3;
05787 break;
05788 case eTRIGGER:
05789 nodeMask = 1;
05790 break;
05791 case ePASSIGN:
05792 nodeMask = 3;
05793 break;
05794 case eDEASSIGN:
05795 nodeMask = 1;
05796 break;
05797 case eDISABLE:
05798 nodeMask = 0;
05799 break;
05800 case eATTRIBUTE:
05801 nodeMask = 0;
05802 break;
05803 case eGIF:
05804 nodeMask = 7;
05805 break;
05806 case eGFOR:
05807 nodeMask = 15;
05808 break;
05809 case eGCASE:
05810 nodeMask = 3;
05811 break;
05812 case eTABLE:
05813 nodeMask = 1;
05814 break;
05815 case eTABLE_ENTRY:
05816 nodeMask = 1;
05817 break;
05818 case eTABLE_SYMBOL:
05819 nodeMask = 0;
05820 break;
05821 case ePORTLIST_END:
05822 nodeMask = 0;
05823 break;
05824 case eMACRO_EXPR:
05825 nodeMask = 2;
05826 break;
05827 default:
05828 MASSERT( FALSE );
05829 }
05830
05831 CNode* n = new(stack) CNode( &loc, op );
05832 n->width = width;
05833 n->type = type;
05834 n->fixedWidth = fixedWidth;
05835 if( attributes ) {
05836 n->attributes = attributes->Clone();;
05837 }
05838 for( int i = 0; i < ArgCount(); i++ ) {
05839 if( ((nodeMask>>i)&1) && Arg<CNode*>(i) ) {
05840 n->Arg<CNode*>(i) = Arg<CNode*>(i)->Clone();
05841 } else {
05842 void* tmp = Arg<void*>(i);
05843 n->Arg<void*>(i) = tmp;
05844 }
05845 }
05846 return n;
05847 }
05848
05849
05850
05851
05852
05853
05854
05855
05856
05857 void CNode::PreVisit1( int (*func)(CNode*, void*), void* data )
05858 {
05859 if( !(*func)( this, data ) ) {
05860 return;
05861 }
05862
05863 if( GetAttributes() ) {
05864 GetAttributes()->PreVisit1( func, data );
05865 }
05866
05867 int nodeMask = 0;
05868 switch( GetOp() ) {
05869 case eERROR:
05870 nodeMask = 0;
05871 break;
05872 case eVCONSTANT:
05873 nodeMask = 1;
05874 break;
05875 case eRCONSTANT:
05876 nodeMask = 1;
05877 break;
05878 case eCOMMENT:
05879 nodeMask = 1;
05880 break;
05881 case eVRQ:
05882 nodeMask = 1;
05883 break;
05884 case ePRAGMA:
05885 nodeMask = 1;
05886 break;
05887 case eELIST:
05888 nodeMask = 0;
05889 break;
05890 case eWIDTH:
05891 nodeMask = 0;
05892 break;
05893 case eNOP:
05894 nodeMask = 0;
05895 break;
05896 case eSUB:
05897 nodeMask = 0;
05898 break;
05899 case eMUL:
05900 nodeMask = 0;
05901 break;
05902 case eDIV:
05903 nodeMask = 0;
05904 break;
05905 case ePOW:
05906 nodeMask = 0;
05907 break;
05908 case eADD:
05909 nodeMask = 0;
05910 break;
05911 case eLSH:
05912 nodeMask = 0;
05913 break;
05914 case eRSH:
05915 nodeMask = 0;
05916 break;
05917 case eLSHA:
05918 nodeMask = 0;
05919 break;
05920 case eRSHA:
05921 nodeMask = 0;
05922 break;
05923 case eMOD:
05924 nodeMask = 0;
05925 break;
05926 case eOR:
05927 nodeMask = 0;
05928 break;
05929 case eAND:
05930 nodeMask = 0;
05931 break;
05932 case eANDANDAND:
05933 nodeMask = 0;
05934 break;
05935 case eXOR:
05936 nodeMask = 0;
05937 break;
05938 case eXNOR:
05939 nodeMask = 0;
05940 break;
05941 case eINSTANCE_REF:
05942 nodeMask = 1;
05943 if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PreVisit1( func, data );
05944 break;
05945 case eGATE_REF:
05946 nodeMask = 1;
05947 if(Arg<CGate*>(0)) Arg<CGate*>(0)->PreVisit1( func, data );
05948 break;
05949 case eTASK_ENABLE:
05950 nodeMask = 1;
05951 break;
05952 case eSYSTASK_CALL:
05953 nodeMask = 1;
05954 break;
05955 case eTIMING_CALL:
05956 nodeMask = 1;
05957 break;
05958 case eFUNCTION_CALL:
05959 nodeMask = 5;
05960 break;
05961 case eARRAY:
05962 nodeMask = 0;
05963 break;
05964 case eNET_REF:
05965 return;
05966 case eREG_REF:
05967 return;
05968 case eREAL_REF:
05969 return;
05970 case ePARAM_REF:
05971 return;
05972 case ePORT_REF:
05973 return;
05974 case eFWD_REF:
05975 return;
05976 case eEVENT_REF:
05977 return;
05978 case eGENVAR_REF:
05979 return;
05980 case eNET_DECL:
05981 nodeMask = 1;
05982 if(Arg<CNet*>(0)) Arg<CNet*>(0)->PreVisit1( func, data );
05983 break;
05984 case eREG_DECL:
05985 nodeMask = 1;
05986 if(Arg<CReg*>(0)) Arg<CReg*>(0)->PreVisit1( func, data );
05987 break;
05988 case eREAL_DECL:
05989 nodeMask = 1;
05990 if(Arg<CReal*>(0)) Arg<CReal*>(0)->PreVisit1( func, data );
05991 break;
05992 case ePARAM_DECL:
05993 nodeMask = 1;
05994 if(Arg<CParam*>(0)) Arg<CParam*>(0)->PreVisit1( func, data );
05995 break;
05996 case eSPECPARAM_DECL:
05997 nodeMask = 1;
05998 if(Arg<CParam*>(0)) Arg<CParam*>(0)->PreVisit1( func, data );
05999 break;
06000 case ePORT_DECL:
06001 nodeMask = 1;
06002 if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PreVisit1( func, data );
06003 break;
06004 case eEVENT_DECL:
06005 nodeMask = 1;
06006 if(Arg<CEvent*>(0)) Arg<CEvent*>(0)->PreVisit1( func, data );
06007 break;
06008 case eGENVAR_DECL:
06009 nodeMask = 1;
06010 if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PreVisit1( func, data );
06011 break;
06012 case eLIST:
06013 nodeMask = 0;
06014 break;
06015 case eRANGE:
06016 nodeMask = 0;
06017 break;
06018 case eSLICE:
06019 nodeMask = 0;
06020 break;
06021 case ePSLICE:
06022 nodeMask = 0;
06023 break;
06024 case eMSLICE:
06025 nodeMask = 0;
06026 break;
06027 case eCVRI:
06028 nodeMask = 0;
06029 break;
06030 case eCVIR:
06031 nodeMask = 0;
06032 break;
06033 case eREP:
06034 nodeMask = 0;
06035 break;
06036 case eCAT:
06037 nodeMask = 0;
06038 break;
06039 case eUCAT:
06040 nodeMask = 0;
06041 break;
06042 case eCOM:
06043 nodeMask = 0;
06044 break;
06045 case eNEG:
06046 nodeMask = 0;
06047 break;
06048 case eNOT:
06049 nodeMask = 0;
06050 break;
06051 case eGT:
06052 nodeMask = 0;
06053 break;
06054 case eGE:
06055 nodeMask = 0;
06056 break;
06057 case eLT:
06058 nodeMask = 0;
06059 break;
06060 case eLE:
06061 nodeMask = 0;
06062 break;
06063 case eLAND:
06064 nodeMask = 0;
06065 break;
06066 case eLOR:
06067 nodeMask = 0;
06068 break;
06069 case eCEQ:
06070 nodeMask = 0;
06071 break;
06072 case eCNE:
06073 nodeMask = 0;
06074 break;
06075 case eEQ:
06076 nodeMask = 0;
06077 break;
06078 case eNE:
06079 nodeMask = 0;
06080 break;
06081 case eRAND:
06082 nodeMask = 0;
06083 break;
06084 case eRNAND:
06085 nodeMask = 0;
06086 break;
06087 case eROR:
06088 nodeMask = 0;
06089 break;
06090 case eRNOR:
06091 nodeMask = 0;
06092 break;
06093 case eRXOR:
06094 nodeMask = 0;
06095 break;
06096 case eRXNOR:
06097 nodeMask = 0;
06098 break;
06099 case eHOOK:
06100 nodeMask = 0;
06101 break;
06102 case eINIT:
06103 nodeMask = 0;
06104 break;
06105 case eALWAYS:
06106 nodeMask = 0;
06107 break;
06108 case eEVENT:
06109 nodeMask = 0;
06110 break;
06111 case eBLOCK_REF:
06112 nodeMask = 1;
06113 if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PreVisit1( func, data );
06114 break;
06115 case eSPECIFY_REF:
06116 nodeMask = 1;
06117 if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PreVisit1( func, data );
06118 break;
06119 case eASSIGN:
06120 nodeMask = 0;
06121 break;
06122 case eFORCE:
06123 nodeMask = 0;
06124 break;
06125 case eRELEASE:
06126 nodeMask = 0;
06127 break;
06128 case eNBASSIGN:
06129 nodeMask = 0;
06130 break;
06131 case ePOSEDGE:
06132 nodeMask = 0;
06133 break;
06134 case eNEGEDGE:
06135 nodeMask = 0;
06136 break;
06137 case eEDGE:
06138 nodeMask = 2;
06139 break;
06140 case eEVOR:
06141 nodeMask = 0;
06142 break;
06143 case eDELAY:
06144 nodeMask = 0;
06145 break;
06146 case eMTM:
06147 nodeMask = 0;
06148 break;
06149 case eIF:
06150 nodeMask = 0;
06151 break;
06152 case eFOREVER:
06153 nodeMask = 0;
06154 break;
06155 case eREPEAT:
06156 nodeMask = 0;
06157 break;
06158 case eWHILE:
06159 nodeMask = 0;
06160 break;
06161 case eWAIT:
06162 nodeMask = 0;
06163 break;
06164 case eFOR:
06165 nodeMask = 0;
06166 break;
06167 case eCASE:
06168 nodeMask = 0;
06169 break;
06170 case eCASEX:
06171 nodeMask = 0;
06172 break;
06173 case eCASEZ:
06174 nodeMask = 0;
06175 break;
06176 case eCASEITEM:
06177 nodeMask = 0;
06178 break;
06179 case eCASSIGN:
06180 nodeMask = 1;
06181 break;
06182 case eARG:
06183 nodeMask = 1;
06184 break;
06185 case eFUNCTION_DEF:
06186 nodeMask = 1;
06187 if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PreVisit1( func, data );
06188 break;
06189 case eMODULE_DEF:
06190 nodeMask = 1;
06191 if(Arg<CModule*>(0)) Arg<CModule*>(0)->PreVisit1( func, data );
06192 break;
06193 case eREPEAT_CONTROL:
06194 nodeMask = 0;
06195 break;
06196 case eDELAY_CONTROL:
06197 nodeMask = 0;
06198 break;
06199 case eEVENT_CONTROL:
06200 nodeMask = 0;
06201 break;
06202 case eEXTERNAL_REF:
06203 nodeMask = 1;
06204 break;
06205 case ePORT_DEF:
06206 nodeMask = 1;
06207 if(Arg<CPort*>(0)) Arg<CPort*>(0)->PreVisit1( func, data );
06208 break;
06209 case eDEFPARAM:
06210 nodeMask = 0;
06211 break;
06212 case ePATH:
06213 nodeMask = 45;
06214 break;
06215 case ePATH_ASSIGN:
06216 nodeMask = 0;
06217 break;
06218 case eIFNONE_PATH_ASSIGN:
06219 nodeMask = 0;
06220 break;
06221 case eTRIGGER:
06222 nodeMask = 0;
06223 break;
06224 case ePASSIGN:
06225 nodeMask = 0;
06226 break;
06227 case eDEASSIGN:
06228 nodeMask = 0;
06229 break;
06230 case eDISABLE:
06231 nodeMask = 1;
06232 break;
06233 case eATTRIBUTE:
06234 nodeMask = 1;
06235 if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PreVisit1( func, data );
06236 break;
06237 case eGIF:
06238 nodeMask = 0;
06239 break;
06240 case eGFOR:
06241 nodeMask = 0;
06242 break;
06243 case eGCASE:
06244 nodeMask = 0;
06245 break;
06246 case eTABLE:
06247 nodeMask = 0;
06248 break;
06249 case eTABLE_ENTRY:
06250 nodeMask = 0;
06251 break;
06252 case eTABLE_SYMBOL:
06253 nodeMask = 1;
06254 break;
06255 case ePORTLIST_END:
06256 nodeMask = 0;
06257 break;
06258 case eMACRO_EXPR:
06259 nodeMask = 1;
06260 break;
06261 }
06262
06263
06264
06265
06266 if( GetOp() != eLIST ) {
06267 for( int i = 0; i < ArgCount(); i++ ) {
06268 if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i)->PreVisit1( func, data );
06269 }
06270 } else {
06271 CNode* n = this;
06272 while( 1 ) {
06273 if( n->Arg<CNode*>(0) ) {
06274 n->Arg<CNode*>(0)->PreVisit1( func, data );
06275 }
06276 if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
06277 break;
06278 }
06279 n = n->Arg<CNode*>(1);
06280 if( !(*func)( n, data ) ) {
06281 return;
06282 }
06283 if( n->GetAttributes() ) {
06284 n->GetAttributes()->PreVisit1( func, data );
06285 }
06286 }
06287 if( n->Arg<CNode*>(1) ) {
06288 n->Arg<CNode*>(1)->PreVisit1( func, data );
06289 }
06290 }
06291 }
06292
06293
06294
06295
06296
06297
06298
06299 void CNode::PostVisit1( void (*func)(CNode*, void*), void* data )
06300 {
06301 if( GetAttributes() ) {
06302 GetAttributes()->PostVisit1( func, data );
06303 }
06304
06305 int nodeMask = 0;
06306 switch( GetOp() ) {
06307 case eERROR:
06308 nodeMask = 0;
06309 break;
06310 case eVCONSTANT:
06311 nodeMask = 1;
06312 break;
06313 case eRCONSTANT:
06314 nodeMask = 1;
06315 break;
06316 case eCOMMENT:
06317 nodeMask = 1;
06318 break;
06319 case eVRQ:
06320 nodeMask = 1;
06321 break;
06322 case ePRAGMA:
06323 nodeMask = 1;
06324 break;
06325 case eELIST:
06326 nodeMask = 0;
06327 break;
06328 case eWIDTH:
06329 nodeMask = 0;
06330 break;
06331 case eNOP:
06332 nodeMask = 0;
06333 break;
06334 case eSUB:
06335 nodeMask = 0;
06336 break;
06337 case eMUL:
06338 nodeMask = 0;
06339 break;
06340 case eDIV:
06341 nodeMask = 0;
06342 break;
06343 case ePOW:
06344 nodeMask = 0;
06345 break;
06346 case eADD:
06347 nodeMask = 0;
06348 break;
06349 case eLSH:
06350 nodeMask = 0;
06351 break;
06352 case eRSH:
06353 nodeMask = 0;
06354 break;
06355 case eLSHA:
06356 nodeMask = 0;
06357 break;
06358 case eRSHA:
06359 nodeMask = 0;
06360 break;
06361 case eMOD:
06362 nodeMask = 0;
06363 break;
06364 case eOR:
06365 nodeMask = 0;
06366 break;
06367 case eAND:
06368 nodeMask = 0;
06369 break;
06370 case eANDANDAND:
06371 nodeMask = 0;
06372 break;
06373 case eXOR:
06374 nodeMask = 0;
06375 break;
06376 case eXNOR:
06377 nodeMask = 0;
06378 break;
06379 case eINSTANCE_REF:
06380 nodeMask = 1;
06381 if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PostVisit1( func, data );
06382 break;
06383 case eGATE_REF:
06384 nodeMask = 1;
06385 if(Arg<CGate*>(0)) Arg<CGate*>(0)->PostVisit1( func, data );
06386 break;
06387 case eTASK_ENABLE:
06388 nodeMask = 1;
06389 break;
06390 case eSYSTASK_CALL:
06391 nodeMask = 1;
06392 break;
06393 case eTIMING_CALL:
06394 nodeMask = 1;
06395 break;
06396 case eFUNCTION_CALL:
06397 nodeMask = 5;
06398 break;
06399 case eARRAY:
06400 nodeMask = 0;
06401 break;
06402 case eNET_REF:
06403 nodeMask = ~0;
06404 break;
06405 case eREG_REF:
06406 nodeMask = ~0;
06407 break;
06408 case eREAL_REF:
06409 nodeMask = ~0;
06410 break;
06411 case ePARAM_REF:
06412 nodeMask = ~0;
06413 break;
06414 case ePORT_REF:
06415 nodeMask = ~0;
06416 break;
06417 case eFWD_REF:
06418 nodeMask = ~0;
06419 break;
06420 case eEVENT_REF:
06421 nodeMask = ~0;
06422 break;
06423 case eGENVAR_REF:
06424 nodeMask = ~0;
06425 break;
06426 case eNET_DECL:
06427 nodeMask = 1;
06428 if(Arg<CNet*>(0)) Arg<CNet*>(0)->PostVisit1( func, data );
06429 break;
06430 case eREG_DECL:
06431 nodeMask = 1;
06432 if(Arg<CReg*>(0)) Arg<CReg*>(0)->PostVisit1( func, data );
06433 break;
06434 case eREAL_DECL:
06435 nodeMask = 1;
06436 if(Arg<CReal*>(0)) Arg<CReal*>(0)->PostVisit1( func, data );
06437 break;
06438 case ePARAM_DECL:
06439 nodeMask = 1;
06440 if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostVisit1( func, data );
06441 break;
06442 case eSPECPARAM_DECL:
06443 nodeMask = 1;
06444 if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostVisit1( func, data );
06445 break;
06446 case ePORT_DECL:
06447 nodeMask = 1;
06448 if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PostVisit1( func, data );
06449 break;
06450 case eEVENT_DECL:
06451 nodeMask = 1;
06452 if(Arg<CEvent*>(0)) Arg<CEvent*>(0)->PostVisit1( func, data );
06453 break;
06454 case eGENVAR_DECL:
06455 nodeMask = 1;
06456 if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PostVisit1( func, data );
06457 break;
06458 case eLIST:
06459 nodeMask = 0;
06460 break;
06461 case eRANGE:
06462 nodeMask = 0;
06463 break;
06464 case eSLICE:
06465 nodeMask = 0;
06466 break;
06467 case ePSLICE:
06468 nodeMask = 0;
06469 break;
06470 case eMSLICE:
06471 nodeMask = 0;
06472 break;
06473 case eCVRI:
06474 nodeMask = 0;
06475 break;
06476 case eCVIR:
06477 nodeMask = 0;
06478 break;
06479 case eREP:
06480 nodeMask = 0;
06481 break;
06482 case eCAT:
06483 nodeMask = 0;
06484 break;
06485 case eUCAT:
06486 nodeMask = 0;
06487 break;
06488 case eCOM:
06489 nodeMask = 0;
06490 break;
06491 case eNEG:
06492 nodeMask = 0;
06493 break;
06494 case eNOT:
06495 nodeMask = 0;
06496 break;
06497 case eGT:
06498 nodeMask = 0;
06499 break;
06500 case eGE:
06501 nodeMask = 0;
06502 break;
06503 case eLT:
06504 nodeMask = 0;
06505 break;
06506 case eLE:
06507 nodeMask = 0;
06508 break;
06509 case eLAND:
06510 nodeMask = 0;
06511 break;
06512 case eLOR:
06513 nodeMask = 0;
06514 break;
06515 case eCEQ:
06516 nodeMask = 0;
06517 break;
06518 case eCNE:
06519 nodeMask = 0;
06520 break;
06521 case eEQ:
06522 nodeMask = 0;
06523 break;
06524 case eNE:
06525 nodeMask = 0;
06526 break;
06527 case eRAND:
06528 nodeMask = 0;
06529 break;
06530 case eRNAND:
06531 nodeMask = 0;
06532 break;
06533 case eROR:
06534 nodeMask = 0;
06535 break;
06536 case eRNOR:
06537 nodeMask = 0;
06538 break;
06539 case eRXOR:
06540 nodeMask = 0;
06541 break;
06542 case eRXNOR:
06543 nodeMask = 0;
06544 break;
06545 case eHOOK:
06546 nodeMask = 0;
06547 break;
06548 case eINIT:
06549 nodeMask = 0;
06550 break;
06551 case eALWAYS:
06552 nodeMask = 0;
06553 break;
06554 case eEVENT:
06555 nodeMask = 0;
06556 break;
06557 case eBLOCK_REF:
06558 nodeMask = 1;
06559 if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PostVisit1( func, data );
06560 break;
06561 case eSPECIFY_REF:
06562 nodeMask = 1;
06563 if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PostVisit1( func, data );
06564 break;
06565 case eASSIGN:
06566 nodeMask = 0;
06567 break;
06568 case eFORCE:
06569 nodeMask = 0;
06570 break;
06571 case eRELEASE:
06572 nodeMask = 0;
06573 break;
06574 case eNBASSIGN:
06575 nodeMask = 0;
06576 break;
06577 case ePOSEDGE:
06578 nodeMask = 0;
06579 break;
06580 case eNEGEDGE:
06581 nodeMask = 0;
06582 break;
06583 case eEDGE:
06584 nodeMask = 2;
06585 break;
06586 case eEVOR:
06587 nodeMask = 0;
06588 break;
06589 case eDELAY:
06590 nodeMask = 0;
06591 break;
06592 case eMTM:
06593 nodeMask = 0;
06594 break;
06595 case eIF:
06596 nodeMask = 0;
06597 break;
06598 case eFOREVER:
06599 nodeMask = 0;
06600 break;
06601 case eREPEAT:
06602 nodeMask = 0;
06603 break;
06604 case eWHILE:
06605 nodeMask = 0;
06606 break;
06607 case eWAIT:
06608 nodeMask = 0;
06609 break;
06610 case eFOR:
06611 nodeMask = 0;
06612 break;
06613 case eCASE:
06614 nodeMask = 0;
06615 break;
06616 case eCASEX:
06617 nodeMask = 0;
06618 break;
06619 case eCASEZ:
06620 nodeMask = 0;
06621 break;
06622 case eCASEITEM:
06623 nodeMask = 0;
06624 break;
06625 case eCASSIGN:
06626 nodeMask = 1;
06627 break;
06628 case eARG:
06629 nodeMask = 1;
06630 break;
06631 case eFUNCTION_DEF:
06632 nodeMask = 1;
06633 if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PostVisit1( func, data );
06634 break;
06635 case eMODULE_DEF:
06636 nodeMask = 1;
06637 if(Arg<CModule*>(0)) Arg<CModule*>(0)->PostVisit1( func, data );
06638 break;
06639 case eREPEAT_CONTROL:
06640 nodeMask = 0;
06641 break;
06642 case eDELAY_CONTROL:
06643 nodeMask = 0;
06644 break;
06645 case eEVENT_CONTROL:
06646 nodeMask = 0;
06647 break;
06648 case eEXTERNAL_REF:
06649 nodeMask = 1;
06650 break;
06651 case ePORT_DEF:
06652 nodeMask = 1;
06653 if(Arg<CPort*>(0)) Arg<CPort*>(0)->PostVisit1( func, data );
06654 break;
06655 case eDEFPARAM:
06656 nodeMask = 0;
06657 break;
06658 case ePATH:
06659 nodeMask = 45;
06660 break;
06661 case ePATH_ASSIGN:
06662 nodeMask = 0;
06663 break;
06664 case eIFNONE_PATH_ASSIGN:
06665 nodeMask = 0;
06666 break;
06667 case eTRIGGER:
06668 nodeMask = 0;
06669 break;
06670 case ePASSIGN:
06671 nodeMask = 0;
06672 break;
06673 case eDEASSIGN:
06674 nodeMask = 0;
06675 break;
06676 case eDISABLE:
06677 nodeMask = 1;
06678 break;
06679 case eATTRIBUTE:
06680 nodeMask = 1;
06681 if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PostVisit1( func, data );
06682 break;
06683 case eGIF:
06684 nodeMask = 0;
06685 break;
06686 case eGFOR:
06687 nodeMask = 0;
06688 break;
06689 case eGCASE:
06690 nodeMask = 0;
06691 break;
06692 case eTABLE:
06693 nodeMask = 0;
06694 break;
06695 case eTABLE_ENTRY:
06696 nodeMask = 0;
06697 break;
06698 case eTABLE_SYMBOL:
06699 nodeMask = 1;
06700 break;
06701 case ePORTLIST_END:
06702 nodeMask = 0;
06703 break;
06704 case eMACRO_EXPR:
06705 nodeMask = 1;
06706 break;
06707 }
06708
06709
06710
06711
06712 if( GetOp() != eLIST ) {
06713 for( int i = 0; i < ArgCount(); i++ ) {
06714 if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i)->PostVisit1( func, data );
06715 }
06716 } else {
06717 std::stack<CNode*> visitLog;
06718 CNode* n = this;
06719 while( 1 ) {
06720 if( n->Arg<CNode*>(0) ) {
06721 n->Arg<CNode*>(0)-> PostVisit1( func, data );
06722 }
06723 if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
06724 break;
06725 }
06726 visitLog.push(n);
06727 n = n->Arg<CNode*>(1);
06728 if( n->GetAttributes() ) {
06729 n->GetAttributes()->PostVisit1( func, data );
06730 }
06731 }
06732 if( n->Arg<CNode*>(1) ) {
06733 n->Arg<CNode*>(1)->PostVisit1( func, data );
06734 }
06735 while( !visitLog.empty() ) {
06736 CNode* top = visitLog.top();
06737 if( top->Arg<CNode*>(1) ) {
06738 (*func)(top->Arg<CNode*>(1),data);
06739 }
06740 visitLog.pop();
06741 }
06742 }
06743
06744 (*func)( this, data );
06745 }
06746
06747
06748
06749
06750
06751
06752
06753
06754 CNode* CNode::PostSubVisit1( CNode* (*func)(CNode*, void*), void* data )
06755 {
06756 if( GetAttributes() ) {
06757 SetAttributes( GetAttributes()->PostSubVisit1( func, data ) );
06758 }
06759
06760 int nodeMask = 0;
06761 switch( GetOp() ) {
06762 case eERROR:
06763 nodeMask = 0;
06764 break;
06765 case eVCONSTANT:
06766 nodeMask = 1;
06767 break;
06768 case eRCONSTANT:
06769 nodeMask = 1;
06770 break;
06771 case eCOMMENT:
06772 nodeMask = 1;
06773 break;
06774 case eVRQ:
06775 nodeMask = 1;
06776 break;
06777 case ePRAGMA:
06778 nodeMask = 1;
06779 break;
06780 case eELIST:
06781 nodeMask = 0;
06782 break;
06783 case eWIDTH:
06784 nodeMask = 0;
06785 break;
06786 case eNOP:
06787 nodeMask = 0;
06788 break;
06789 case eSUB:
06790 nodeMask = 0;
06791 break;
06792 case eMUL:
06793 nodeMask = 0;
06794 break;
06795 case eDIV:
06796 nodeMask = 0;
06797 break;
06798 case ePOW:
06799 nodeMask = 0;
06800 break;
06801 case eADD:
06802 nodeMask = 0;
06803 break;
06804 case eLSH:
06805 nodeMask = 0;
06806 break;
06807 case eRSH:
06808 nodeMask = 0;
06809 break;
06810 case eLSHA:
06811 nodeMask = 0;
06812 break;
06813 case eRSHA:
06814 nodeMask = 0;
06815 break;
06816 case eMOD:
06817 nodeMask = 0;
06818 break;
06819 case eOR:
06820 nodeMask = 0;
06821 break;
06822 case eAND:
06823 nodeMask = 0;
06824 break;
06825 case eANDANDAND:
06826 nodeMask = 0;
06827 break;
06828 case eXOR:
06829 nodeMask = 0;
06830 break;
06831 case eXNOR:
06832 nodeMask = 0;
06833 break;
06834 case eINSTANCE_REF:
06835 nodeMask = 1;
06836 if(Arg<CInstance*>(0)) Arg<CInstance*>(0)->PostSubVisit1( func, data );
06837 break;
06838 case eGATE_REF:
06839 nodeMask = 1;
06840 if(Arg<CGate*>(0)) Arg<CGate*>(0)->PostSubVisit1( func, data );
06841 break;
06842 case eTASK_ENABLE:
06843 nodeMask = 1;
06844 break;
06845 case eSYSTASK_CALL:
06846 nodeMask = 1;
06847 break;
06848 case eTIMING_CALL:
06849 nodeMask = 1;
06850 break;
06851 case eFUNCTION_CALL:
06852 nodeMask = 5;
06853 break;
06854 case eARRAY:
06855 nodeMask = 0;
06856 break;
06857 case eNET_REF:
06858 nodeMask = ~0;
06859 break;
06860 case eREG_REF:
06861 nodeMask = ~0;
06862 break;
06863 case eREAL_REF:
06864 nodeMask = ~0;
06865 break;
06866 case ePARAM_REF:
06867 nodeMask = ~0;
06868 break;
06869 case ePORT_REF:
06870 nodeMask = ~0;
06871 break;
06872 case eFWD_REF:
06873 nodeMask = ~0;
06874 break;
06875 case eEVENT_REF:
06876 nodeMask = ~0;
06877 break;
06878 case eGENVAR_REF:
06879 nodeMask = ~0;
06880 break;
06881 case eNET_DECL:
06882 nodeMask = 1;
06883 if(Arg<CNet*>(0)) Arg<CNet*>(0)->PostSubVisit1( func, data );
06884 break;
06885 case eREG_DECL:
06886 nodeMask = 1;
06887 if(Arg<CReg*>(0)) Arg<CReg*>(0)->PostSubVisit1( func, data );
06888 break;
06889 case eREAL_DECL:
06890 nodeMask = 1;
06891 if(Arg<CReal*>(0)) Arg<CReal*>(0)->PostSubVisit1( func, data );
06892 break;
06893 case ePARAM_DECL:
06894 nodeMask = 1;
06895 if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostSubVisit1( func, data );
06896 break;
06897 case eSPECPARAM_DECL:
06898 nodeMask = 1;
06899 if(Arg<CParam*>(0)) Arg<CParam*>(0)->PostSubVisit1( func, data );
06900 break;
06901 case ePORT_DECL:
06902 nodeMask = 1;
06903 if(Arg<CPortDir*>(0)) Arg<CPortDir*>(0)->PostSubVisit1( func, data );
06904 break;
06905 case eEVENT_DECL:
06906 nodeMask = 1;
06907 if(Arg<CEvent*>(0)) Arg<CEvent*>(0)->PostSubVisit1( func, data );
06908 break;
06909 case eGENVAR_DECL:
06910 nodeMask = 1;
06911 if(Arg<CGenvar*>(0)) Arg<CGenvar*>(0)->PostSubVisit1( func, data );
06912 break;
06913 case eLIST:
06914 nodeMask = 0;
06915 break;
06916 case eRANGE:
06917 nodeMask = 0;
06918 break;
06919 case eSLICE:
06920 nodeMask = 0;
06921 break;
06922 case ePSLICE:
06923 nodeMask = 0;
06924 break;
06925 case eMSLICE:
06926 nodeMask = 0;
06927 break;
06928 case eCVRI:
06929 nodeMask = 0;
06930 break;
06931 case eCVIR:
06932 nodeMask = 0;
06933 break;
06934 case eREP:
06935 nodeMask = 0;
06936 break;
06937 case eCAT:
06938 nodeMask = 0;
06939 break;
06940 case eUCAT:
06941 nodeMask = 0;
06942 break;
06943 case eCOM:
06944 nodeMask = 0;
06945 break;
06946 case eNEG:
06947 nodeMask = 0;
06948 break;
06949 case eNOT:
06950 nodeMask = 0;
06951 break;
06952 case eGT:
06953 nodeMask = 0;
06954 break;
06955 case eGE:
06956 nodeMask = 0;
06957 break;
06958 case eLT:
06959 nodeMask = 0;
06960 break;
06961 case eLE:
06962 nodeMask = 0;
06963 break;
06964 case eLAND:
06965 nodeMask = 0;
06966 break;
06967 case eLOR:
06968 nodeMask = 0;
06969 break;
06970 case eCEQ:
06971 nodeMask = 0;
06972 break;
06973 case eCNE:
06974 nodeMask = 0;
06975 break;
06976 case eEQ:
06977 nodeMask = 0;
06978 break;
06979 case eNE:
06980 nodeMask = 0;
06981 break;
06982 case eRAND:
06983 nodeMask = 0;
06984 break;
06985 case eRNAND:
06986 nodeMask = 0;
06987 break;
06988 case eROR:
06989 nodeMask = 0;
06990 break;
06991 case eRNOR:
06992 nodeMask = 0;
06993 break;
06994 case eRXOR:
06995 nodeMask = 0;
06996 break;
06997 case eRXNOR:
06998 nodeMask = 0;
06999 break;
07000 case eHOOK:
07001 nodeMask = 0;
07002 break;
07003 case eINIT:
07004 nodeMask = 0;
07005 break;
07006 case eALWAYS:
07007 nodeMask = 0;
07008 break;
07009 case eEVENT:
07010 nodeMask = 0;
07011 break;
07012 case eBLOCK_REF:
07013 nodeMask = 1;
07014 if(Arg<CBlock*>(0)) Arg<CBlock*>(0)->PostSubVisit1( func, data );
07015 break;
07016 case eSPECIFY_REF:
07017 nodeMask = 1;
07018 if(Arg<CSpecify*>(0)) Arg<CSpecify*>(0)->PostSubVisit1( func, data );
07019 break;
07020 case eASSIGN:
07021 nodeMask = 0;
07022 break;
07023 case eFORCE:
07024 nodeMask = 0;
07025 break;
07026 case eRELEASE:
07027 nodeMask = 0;
07028 break;
07029 case eNBASSIGN:
07030 nodeMask = 0;
07031 break;
07032 case ePOSEDGE:
07033 nodeMask = 0;
07034 break;
07035 case eNEGEDGE:
07036 nodeMask = 0;
07037 break;
07038 case eEDGE:
07039 nodeMask = 2;
07040 break;
07041 case eEVOR:
07042 nodeMask = 0;
07043 break;
07044 case eDELAY:
07045 nodeMask = 0;
07046 break;
07047 case eMTM:
07048 nodeMask = 0;
07049 break;
07050 case eIF:
07051 nodeMask = 0;
07052 break;
07053 case eFOREVER:
07054 nodeMask = 0;
07055 break;
07056 case eREPEAT:
07057 nodeMask = 0;
07058 break;
07059 case eWHILE:
07060 nodeMask = 0;
07061 break;
07062 case eWAIT:
07063 nodeMask = 0;
07064 break;
07065 case eFOR:
07066 nodeMask = 0;
07067 break;
07068 case eCASE:
07069 nodeMask = 0;
07070 break;
07071 case eCASEX:
07072 nodeMask = 0;
07073 break;
07074 case eCASEZ:
07075 nodeMask = 0;
07076 break;
07077 case eCASEITEM:
07078 nodeMask = 0;
07079 break;
07080 case eCASSIGN:
07081 nodeMask = 1;
07082 break;
07083 case eARG:
07084 nodeMask = 1;
07085 break;
07086 case eFUNCTION_DEF:
07087 nodeMask = 1;
07088 if(Arg<CFunction*>(0)) Arg<CFunction*>(0)->PostSubVisit1( func, data );
07089 break;
07090 case eMODULE_DEF:
07091 nodeMask = 1;
07092 if(Arg<CModule*>(0)) Arg<CModule*>(0)->PostSubVisit1( func, data );
07093 break;
07094 case eREPEAT_CONTROL:
07095 nodeMask = 0;
07096 break;
07097 case eDELAY_CONTROL:
07098 nodeMask = 0;
07099 break;
07100 case eEVENT_CONTROL:
07101 nodeMask = 0;
07102 break;
07103 case eEXTERNAL_REF:
07104 nodeMask = 1;
07105 break;
07106 case ePORT_DEF:
07107 nodeMask = 1;
07108 if(Arg<CPort*>(0)) Arg<CPort*>(0)->PostSubVisit1( func, data );
07109 break;
07110 case eDEFPARAM:
07111 nodeMask = 0;
07112 break;
07113 case ePATH:
07114 nodeMask = 45;
07115 break;
07116 case ePATH_ASSIGN:
07117 nodeMask = 0;
07118 break;
07119 case eIFNONE_PATH_ASSIGN:
07120 nodeMask = 0;
07121 break;
07122 case eTRIGGER:
07123 nodeMask = 0;
07124 break;
07125 case ePASSIGN:
07126 nodeMask = 0;
07127 break;
07128 case eDEASSIGN:
07129 nodeMask = 0;
07130 break;
07131 case eDISABLE:
07132 nodeMask = 1;
07133 break;
07134 case eATTRIBUTE:
07135 nodeMask = 1;
07136 if(Arg<CAttr*>(0)) Arg<CAttr*>(0)->PostSubVisit1( func, data );
07137 break;
07138 case eGIF:
07139 nodeMask = 0;
07140 break;
07141 case eGFOR:
07142 nodeMask = 0;
07143 break;
07144 case eGCASE:
07145 nodeMask = 0;
07146 break;
07147 case eTABLE:
07148 nodeMask = 0;
07149 break;
07150 case eTABLE_ENTRY:
07151 nodeMask = 0;
07152 break;
07153 case eTABLE_SYMBOL:
07154 nodeMask = 1;
07155 break;
07156 case ePORTLIST_END:
07157 nodeMask = 0;
07158 break;
07159 case eMACRO_EXPR:
07160 nodeMask = 1;
07161 break;
07162 }
07163
07164
07165
07166
07167 if( GetOp() != eLIST ) {
07168 for( int i = 0; i < ArgCount(); i++ ) {
07169 if( Arg<CNode*>(i) && !((nodeMask>>i)&1) ) Arg<CNode*>(i) = Arg<CNode*>(i)->PostSubVisit1( func, data );
07170 }
07171 } else {
07172 std::stack<CNode*> visitLog;
07173 CNode* n = this;
07174 while( 1 ) {
07175 if( n->Arg<CNode*>(0) ) {
07176 n->Arg<CNode*>(0) = n->Arg<CNode*>(0)->
07177 PostSubVisit1( func, data );
07178 }
07179 if( !n->Arg<CNode*>(1) || n->Arg<CNode*>(1)->GetOp() != eLIST ) {
07180 break;
07181 }
07182 visitLog.push(n);
07183 n = n->Arg<CNode*>(1);
07184 if( n->GetAttributes() ) {
07185 n->SetAttributes( n->GetAttributes()->PostSubVisit1( func, data ) );
07186 }
07187 }
07188 if( n->Arg<CNode*>(1) ) {
07189 n->Arg<CNode*>(1) = n->Arg<CNode*>(1)->PostSubVisit1( func, data );
07190 }
07191 while( !visitLog.empty() ) {
07192 CNode* top = visitLog.top();
07193 if( top->Arg<CNode*>(1) ) {
07194 top->Arg<CNode*>(1) = (*func)(top->Arg<CNode*>(1),data);
07195 }
07196 visitLog.pop();
07197 }
07198 }
07199
07200 return (*func)( this, data );
07201 }
07202
07203
07204
07205
07206
07207
07208
07209
07210
07211 unsigned CNode::Hash()
07212 {
07213 unsigned result = GetOp();
07214 int nodeMask = 0;
07215 switch( GetOp() ) {
07216 case eERROR:
07217 nodeMask = 0;
07218 break;
07219 case eVCONSTANT:
07220 nodeMask = 1;
07221 result ^= Arg<CVector*>(0)->Hash();
07222 break;
07223 case eRCONSTANT:
07224 nodeMask = 1;
07225 result ^= strlen(Arg<char*>(0));
07226 break;
07227 case eCOMMENT:
07228 nodeMask = 1;
07229 result ^= strlen(Arg<char*>(0));
07230 break;
07231 case eVRQ:
07232 nodeMask = 1;
07233 result ^= strlen(Arg<char*>(0));
07234 break;
07235 case ePRAGMA:
07236 nodeMask = 1;
07237 result ^= strlen(Arg<char*>(0));
07238 break;
07239 case eELIST:
07240 nodeMask = 0;
07241 break;
07242 case eWIDTH:
07243 nodeMask = 0;
07244 break;
07245 case eNOP:
07246 nodeMask = 0;
07247 break;
07248 case eSUB:
07249 nodeMask = 0;
07250 break;
07251 case eMUL:
07252 nodeMask = 0;
07253 break;
07254 case eDIV:
07255 nodeMask = 0;
07256 break;
07257 case ePOW:
07258 nodeMask = 0;
07259 break;
07260 case eADD:
07261 nodeMask = 0;
07262 break;
07263 case eLSH:
07264 nodeMask = 0;
07265 break;
07266 case eRSH:
07267 nodeMask = 0;
07268 break;
07269 case eLSHA:
07270 nodeMask = 0;
07271 break;
07272 case eRSHA:
07273 nodeMask = 0;
07274 break;
07275 case eMOD:
07276 nodeMask = 0;
07277 break;
07278 case eOR:
07279 nodeMask = 0;
07280 break;
07281 case eAND:
07282 nodeMask = 0;
07283 break;
07284 case eANDANDAND:
07285 nodeMask = 0;
07286 break;
07287 case eXOR:
07288 nodeMask = 0;
07289 break;
07290 case eXNOR:
07291 nodeMask = 0;
07292 break;
07293 case eINSTANCE_REF:
07294 nodeMask = 1;
07295 result ^= Arg<unsigned long>(0);
07296 break;
07297 case eGATE_REF:
07298 nodeMask = 1;
07299 result ^= Arg<unsigned long>(0);
07300 break;
07301 case eTASK_ENABLE:
07302 nodeMask = 1;
07303 result ^= Arg<unsigned long>(0);
07304 break;
07305 case eSYSTASK_CALL:
07306 nodeMask = 1;
07307 result ^= Arg<unsigned long>(0);
07308 break;
07309 case eTIMING_CALL:
07310 nodeMask = 1;
07311 result ^= Arg<unsigned long>(0);
07312 break;
07313 case eFUNCTION_CALL:
07314 nodeMask = 5;
07315 result ^= Arg<unsigned long>(0);
07316 result ^= Arg<unsigned long>(2);
07317 break;
07318 case eARRAY:
07319 nodeMask = 0;
07320 break;
07321 case eNET_REF:
07322 nodeMask = 1;
07323 result ^= Arg<unsigned long>(0);
07324 break;
07325 case eREG_REF:
07326 nodeMask = 1;
07327 result ^= Arg<unsigned long>(0);
07328 break;
07329 case eREAL_REF:
07330 nodeMask = 1;
07331 result ^= Arg<unsigned long>(0);
07332 break;
07333 case ePARAM_REF:
07334 nodeMask = 1;
07335 result ^= Arg<unsigned long>(0);
07336 break;
07337 case ePORT_REF:
07338 nodeMask = 1;
07339 result ^= Arg<unsigned long>(0);
07340 break;
07341 case eFWD_REF:
07342 nodeMask = 1;
07343 result ^= Arg<unsigned long>(0);
07344 break;
07345 case eEVENT_REF:
07346 nodeMask = 1;
07347 result ^= Arg<unsigned long>(0);
07348 break;
07349 case eGENVAR_REF:
07350 nodeMask = 1;
07351 result ^= Arg<unsigned long>(0);
07352 break;
07353 case eNET_DECL:
07354 nodeMask = 1;
07355 result ^= Arg<unsigned long>(0);
07356 break;
07357 case eREG_DECL:
07358 nodeMask = 1;
07359 result ^= Arg<unsigned long>(0);
07360 break;
07361 case eREAL_DECL:
07362 nodeMask = 1;
07363 result ^= Arg<unsigned long>(0);
07364 break;
07365 case ePARAM_DECL:
07366 nodeMask = 1;
07367 result ^= Arg<unsigned long>(0);
07368 break;
07369 case eSPECPARAM_DECL:
07370 nodeMask = 1;
07371 result ^= Arg<unsigned long>(0);
07372 break;
07373 case ePORT_DECL:
07374 nodeMask = 1;
07375 result ^= Arg<unsigned long>(0);
07376 break;
07377 case eEVENT_DECL:
07378 nodeMask = 1;
07379 result ^= Arg<unsigned long>(0);
07380 break;
07381 case eGENVAR_DECL:
07382 nodeMask = 1;
07383 result ^= Arg<unsigned long>(0);
07384 break;
07385 case eLIST:
07386 nodeMask = 0;
07387 break;
07388 case eRANGE:
07389 nodeMask = 0;
07390 break;
07391 case eSLICE:
07392 nodeMask = 0;
07393 break;
07394 case ePSLICE:
07395 nodeMask = 0;
07396 break;
07397 case eMSLICE:
07398 nodeMask = 0;
07399 break;
07400 case eCVRI:
07401 nodeMask = 0;
07402 break;
07403 case eCVIR:
07404 nodeMask = 0;
07405 break;
07406 case eREP:
07407 nodeMask = 0;
07408 break;
07409 case eCAT:
07410 nodeMask = 0;
07411 break;
07412 case eUCAT:
07413 nodeMask = 0;
07414 break;
07415 case eCOM:
07416 nodeMask = 0;
07417 break;
07418 case eNEG:
07419 nodeMask = 0;
07420 break;
07421 case eNOT:
07422 nodeMask = 0;
07423 break;
07424 case eGT:
07425 nodeMask = 0;
07426 break;
07427 case eGE:
07428 nodeMask = 0;
07429 break;
07430 case eLT:
07431 nodeMask = 0;
07432 break;
07433 case eLE:
07434 nodeMask = 0;
07435 break;
07436 case eLAND:
07437 nodeMask = 0;
07438 break;
07439 case eLOR:
07440 nodeMask = 0;
07441 break;
07442 case eCEQ:
07443 nodeMask = 0;
07444 break;
07445 case eCNE:
07446 nodeMask = 0;
07447 break;
07448 case eEQ:
07449 nodeMask = 0;
07450 break;
07451 case eNE:
07452 nodeMask = 0;
07453 break;
07454 case eRAND:
07455 nodeMask = 0;
07456 break;
07457 case eRNAND:
07458 nodeMask = 0;
07459 break;
07460 case eROR:
07461 nodeMask = 0;
07462 break;
07463 case eRNOR:
07464 nodeMask = 0;
07465 break;
07466 case eRXOR:
07467 nodeMask = 0;
07468 break;
07469 case eRXNOR:
07470 nodeMask = 0;
07471 break;
07472 case eHOOK:
07473 nodeMask = 0;
07474 break;
07475 case eINIT:
07476 nodeMask = 0;
07477 break;
07478 case eALWAYS:
07479 nodeMask = 0;
07480 break;
07481 case eEVENT:
07482 nodeMask = 0;
07483 break;
07484 case eBLOCK_REF:
07485 nodeMask = 1;
07486 result ^= Arg<unsigned long>(0);
07487 break;
07488 case eSPECIFY_REF:
07489 nodeMask = 1;
07490 result ^= Arg<unsigned long>(0);
07491 break;
07492 case eASSIGN:
07493 nodeMask = 0;
07494 break;
07495 case eFORCE:
07496 nodeMask = 0;
07497 break;
07498 case eRELEASE:
07499 nodeMask = 0;
07500 break;
07501 case eNBASSIGN:
07502 nodeMask = 0;
07503 break;
07504 case ePOSEDGE:
07505 nodeMask = 0;
07506 break;
07507 case eNEGEDGE:
07508 nodeMask = 0;
07509 break;
07510 case eEDGE:
07511 nodeMask = 2;
07512 result ^= (unsigned long)Arg<Edge_t>(1);
07513 break;
07514 case eEVOR:
07515 nodeMask = 0;
07516 break;
07517 case eDELAY:
07518 nodeMask = 0;
07519 break;
07520 case eMTM:
07521 nodeMask = 0;
07522 break;
07523 case eIF:
07524 nodeMask = 0;
07525 break;
07526 case eFOREVER:
07527 nodeMask = 0;
07528 break;
07529 case eREPEAT:
07530 nodeMask = 0;
07531 break;
07532 case eWHILE:
07533 nodeMask = 0;
07534 break;
07535 case eWAIT:
07536 nodeMask = 0;
07537 break;
07538 case eFOR:
07539 nodeMask = 0;
07540 break;
07541 case eCASE:
07542 nodeMask = 0;
07543 break;
07544 case eCASEX:
07545 nodeMask = 0;
07546 break;
07547 case eCASEZ:
07548 nodeMask = 0;
07549 break;
07550 case eCASEITEM:
07551 nodeMask = 0;
07552 break;
07553 case eCASSIGN:
07554 nodeMask = 1;
07555 result ^= Arg<unsigned long>(0);
07556 break;
07557 case eARG:
07558 nodeMask = 1;
07559 result ^= Arg<unsigned long>(0);
07560 break;
07561 case eFUNCTION_DEF:
07562 nodeMask = 1;
07563 result ^= Arg<unsigned long>(0);
07564 break;
07565 case eMODULE_DEF:
07566 nodeMask = 1;
07567 result ^= Arg<unsigned long>(0);
07568 break;
07569 case eREPEAT_CONTROL:
07570 nodeMask = 0;
07571 break;
07572 case eDELAY_CONTROL:
07573 nodeMask = 0;
07574 break;
07575 case eEVENT_CONTROL:
07576 nodeMask = 0;
07577 break;
07578 case eEXTERNAL_REF:
07579 nodeMask = 1;
07580 result ^= Arg<unsigned long>(0);
07581 break;
07582 case ePORT_DEF:
07583 nodeMask = 1;
07584 result ^= Arg<unsigned long>(0);
07585 break;
07586 case eDEFPARAM:
07587 nodeMask = 0;
07588 break;
07589 case ePATH:
07590 nodeMask = 45;
07591 result ^= Arg<int>(0);
07592 result ^= Arg<int>(2);
07593 result ^= Arg<int>(3);
07594 result ^= Arg<int>(5);
07595 break;
07596 case ePATH_ASSIGN:
07597 nodeMask = 0;
07598 break;
07599 case eIFNONE_PATH_ASSIGN:
07600 nodeMask = 0;
07601 break;
07602 case eTRIGGER:
07603 nodeMask = 0;
07604 break;
07605 case ePASSIGN:
07606 nodeMask = 0;
07607 break;
07608 case eDEASSIGN:
07609 nodeMask = 0;
07610 break;
07611 case eDISABLE:
07612 nodeMask = 1;
07613 result ^= Arg<unsigned long>(0);
07614 break;
07615 case eATTRIBUTE:
07616 nodeMask = 1;
07617 result ^= Arg<unsigned long>(0);
07618 break;
07619 case eGIF:
07620 nodeMask = 0;
07621 break;
07622 case eGFOR:
07623 nodeMask = 0;
07624 break;
07625 case eGCASE:
07626 nodeMask = 0;
07627 break;
07628 case eTABLE:
07629 nodeMask = 0;
07630 break;
07631 case eTABLE_ENTRY:
07632 nodeMask = 0;
07633 break;
07634 case eTABLE_SYMBOL:
07635 nodeMask = 1;
07636 result ^= strlen(Arg<char*>(0));
07637 break;
07638 case ePORTLIST_END:
07639 nodeMask = 0;
07640 break;
07641 case eMACRO_EXPR:
07642 nodeMask = 1;
07643 result ^= strlen(Arg<char*>(0));
07644 break;
07645 }
07646
07647 for( int i = 0; i < ArgCount(); i++ ) {
07648 if( !((nodeMask>>i)&1) ) result ^= Arg<CNode*>(i)->Hash();
07649 }
07650 return result;
07651 }
07652
07653
07654
07655
07656
07657
07658
07659
07660
07661
07662
07663
07664
07665 int Equivalent( CNode* a, CNode* b )
07666 {
07667
07668
07669
07670 if( a == b ) {
07671 return TRUE;
07672 }
07673
07674
07675
07676 if( a == NULL || b == NULL ) {
07677 return FALSE;
07678 }
07679
07680
07681
07682 if( a->GetOp() != b->GetOp() ) {
07683 return FALSE;
07684 }
07685
07686 int nodeMask = 0;
07687 switch( a->GetOp() ) {
07688 case eERROR:
07689 nodeMask = 0;
07690 break;
07691 case eVCONSTANT:
07692 nodeMask = 1;
07693 if( !(*a->Arg<CVector*>(0)==*b->Arg<CVector*>(0)) ) { return FALSE; }
07694 break;
07695 case eRCONSTANT:
07696 nodeMask = 1;
07697 if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
07698 break;
07699 case eCOMMENT:
07700 nodeMask = 1;
07701 if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
07702 break;
07703 case eVRQ:
07704 nodeMask = 1;
07705 if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
07706 break;
07707 case ePRAGMA:
07708 nodeMask = 1;
07709 if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
07710 break;
07711 case eELIST:
07712 nodeMask = 0;
07713 break;
07714 case eWIDTH:
07715 nodeMask = 0;
07716 break;
07717 case eNOP:
07718 nodeMask = 0;
07719 break;
07720 case eSUB:
07721 nodeMask = 0;
07722 break;
07723 case eMUL:
07724 nodeMask = 0;
07725 break;
07726 case eDIV:
07727 nodeMask = 0;
07728 break;
07729 case ePOW:
07730 nodeMask = 0;
07731 break;
07732 case eADD:
07733 nodeMask = 0;
07734 break;
07735 case eLSH:
07736 nodeMask = 0;
07737 break;
07738 case eRSH:
07739 nodeMask = 0;
07740 break;
07741 case eLSHA:
07742 nodeMask = 0;
07743 break;
07744 case eRSHA:
07745 nodeMask = 0;
07746 break;
07747 case eMOD:
07748 nodeMask = 0;
07749 break;
07750 case eOR:
07751 nodeMask = 0;
07752 break;
07753 case eAND:
07754 nodeMask = 0;
07755 break;
07756 case eANDANDAND:
07757 nodeMask = 0;
07758 break;
07759 case eXOR:
07760 nodeMask = 0;
07761 break;
07762 case eXNOR:
07763 nodeMask = 0;
07764 break;
07765 case eINSTANCE_REF:
07766 nodeMask = 1;
07767 if( !(a->Arg<CInstance*>(0)==b->Arg<CInstance*>(0)) ) { return FALSE; }
07768 break;
07769 case eGATE_REF:
07770 nodeMask = 1;
07771 if( !(a->Arg<CGate*>(0)==b->Arg<CGate*>(0)) ) { return FALSE; }
07772 break;
07773 case eTASK_ENABLE:
07774 nodeMask = 1;
07775 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
07776 break;
07777 case eSYSTASK_CALL:
07778 nodeMask = 1;
07779 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
07780 break;
07781 case eTIMING_CALL:
07782 nodeMask = 1;
07783 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
07784 break;
07785 case eFUNCTION_CALL:
07786 nodeMask = 5;
07787 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
07788 if( !(a->Arg<CScope*>(2)==b->Arg<CScope*>(2)) ) { return FALSE; }
07789 break;
07790 case eARRAY:
07791 nodeMask = 0;
07792 break;
07793 case eNET_REF:
07794 nodeMask = 1;
07795 if( !(a->Arg<CNet*>(0)==b->Arg<CNet*>(0)) ) { return FALSE; }
07796 break;
07797 case eREG_REF:
07798 nodeMask = 1;
07799 if( !(a->Arg<CReg*>(0)==b->Arg<CReg*>(0)) ) { return FALSE; }
07800 break;
07801 case eREAL_REF:
07802 nodeMask = 1;
07803 if( !(a->Arg<CReal*>(0)==b->Arg<CReal*>(0)) ) { return FALSE; }
07804 break;
07805 case ePARAM_REF:
07806 nodeMask = 1;
07807 if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
07808 break;
07809 case ePORT_REF:
07810 nodeMask = 1;
07811 if( !(a->Arg<CPortDir*>(0)==b->Arg<CPortDir*>(0)) ) { return FALSE; }
07812 break;
07813 case eFWD_REF:
07814 nodeMask = 1;
07815 if( !(a->Arg<CFref*>(0)==b->Arg<CFref*>(0)) ) { return FALSE; }
07816 break;
07817 case eEVENT_REF:
07818 nodeMask = 1;
07819 if( !(a->Arg<CEvent*>(0)==b->Arg<CEvent*>(0)) ) { return FALSE; }
07820 break;
07821 case eGENVAR_REF:
07822 nodeMask = 1;
07823 if( !(a->Arg<CGenvar*>(0)==b->Arg<CGenvar*>(0)) ) { return FALSE; }
07824 break;
07825 case eNET_DECL:
07826 nodeMask = 1;
07827 if( !(a->Arg<CNet*>(0)==b->Arg<CNet*>(0)) ) { return FALSE; }
07828 break;
07829 case eREG_DECL:
07830 nodeMask = 1;
07831 if( !(a->Arg<CReg*>(0)==b->Arg<CReg*>(0)) ) { return FALSE; }
07832 break;
07833 case eREAL_DECL:
07834 nodeMask = 1;
07835 if( !(a->Arg<CReal*>(0)==b->Arg<CReal*>(0)) ) { return FALSE; }
07836 break;
07837 case ePARAM_DECL:
07838 nodeMask = 1;
07839 if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
07840 break;
07841 case eSPECPARAM_DECL:
07842 nodeMask = 1;
07843 if( !(a->Arg<CParam*>(0)==b->Arg<CParam*>(0)) ) { return FALSE; }
07844 break;
07845 case ePORT_DECL:
07846 nodeMask = 1;
07847 if( !(a->Arg<CPortDir*>(0)==b->Arg<CPortDir*>(0)) ) { return FALSE; }
07848 break;
07849 case eEVENT_DECL:
07850 nodeMask = 1;
07851 if( !(a->Arg<CEvent*>(0)==b->Arg<CEvent*>(0)) ) { return FALSE; }
07852 break;
07853 case eGENVAR_DECL:
07854 nodeMask = 1;
07855 if( !(a->Arg<CGenvar*>(0)==b->Arg<CGenvar*>(0)) ) { return FALSE; }
07856 break;
07857 case eLIST:
07858 nodeMask = 0;
07859 break;
07860 case eRANGE:
07861 nodeMask = 0;
07862 break;
07863 case eSLICE:
07864 nodeMask = 0;
07865 break;
07866 case ePSLICE:
07867 nodeMask = 0;
07868 break;
07869 case eMSLICE:
07870 nodeMask = 0;
07871 break;
07872 case eCVRI:
07873 nodeMask = 0;
07874 break;
07875 case eCVIR:
07876 nodeMask = 0;
07877 break;
07878 case eREP:
07879 nodeMask = 0;
07880 break;
07881 case eCAT:
07882 nodeMask = 0;
07883 break;
07884 case eUCAT:
07885 nodeMask = 0;
07886 break;
07887 case eCOM:
07888 nodeMask = 0;
07889 break;
07890 case eNEG:
07891 nodeMask = 0;
07892 break;
07893 case eNOT:
07894 nodeMask = 0;
07895 break;
07896 case eGT:
07897 nodeMask = 0;
07898 break;
07899 case eGE:
07900 nodeMask = 0;
07901 break;
07902 case eLT:
07903 nodeMask = 0;
07904 break;
07905 case eLE:
07906 nodeMask = 0;
07907 break;
07908 case eLAND:
07909 nodeMask = 0;
07910 break;
07911 case eLOR:
07912 nodeMask = 0;
07913 break;
07914 case eCEQ:
07915 nodeMask = 0;
07916 break;
07917 case eCNE:
07918 nodeMask = 0;
07919 break;
07920 case eEQ:
07921 nodeMask = 0;
07922 break;
07923 case eNE:
07924 nodeMask = 0;
07925 break;
07926 case eRAND:
07927 nodeMask = 0;
07928 break;
07929 case eRNAND:
07930 nodeMask = 0;
07931 break;
07932 case eROR:
07933 nodeMask = 0;
07934 break;
07935 case eRNOR:
07936 nodeMask = 0;
07937 break;
07938 case eRXOR:
07939 nodeMask = 0;
07940 break;
07941 case eRXNOR:
07942 nodeMask = 0;
07943 break;
07944 case eHOOK:
07945 nodeMask = 0;
07946 break;
07947 case eINIT:
07948 nodeMask = 0;
07949 break;
07950 case eALWAYS:
07951 nodeMask = 0;
07952 break;
07953 case eEVENT:
07954 nodeMask = 0;
07955 break;
07956 case eBLOCK_REF:
07957 nodeMask = 1;
07958 if( !(a->Arg<CBlock*>(0)==b->Arg<CBlock*>(0)) ) { return FALSE; }
07959 break;
07960 case eSPECIFY_REF:
07961 nodeMask = 1;
07962 if( !(a->Arg<CSpecify*>(0)==b->Arg<CSpecify*>(0)) ) { return FALSE; }
07963 break;
07964 case eASSIGN:
07965 nodeMask = 0;
07966 break;
07967 case eFORCE:
07968 nodeMask = 0;
07969 break;
07970 case eRELEASE:
07971 nodeMask = 0;
07972 break;
07973 case eNBASSIGN:
07974 nodeMask = 0;
07975 break;
07976 case ePOSEDGE:
07977 nodeMask = 0;
07978 break;
07979 case eNEGEDGE:
07980 nodeMask = 0;
07981 break;
07982 case eEDGE:
07983 nodeMask = 2;
07984 if( !(a->Arg<Edge_t>(1)==b->Arg<Edge_t>(1)) ) { return FALSE; }
07985 break;
07986 case eEVOR:
07987 nodeMask = 0;
07988 break;
07989 case eDELAY:
07990 nodeMask = 0;
07991 break;
07992 case eMTM:
07993 nodeMask = 0;
07994 break;
07995 case eIF:
07996 nodeMask = 0;
07997 break;
07998 case eFOREVER:
07999 nodeMask = 0;
08000 break;
08001 case eREPEAT:
08002 nodeMask = 0;
08003 break;
08004 case eWHILE:
08005 nodeMask = 0;
08006 break;
08007 case eWAIT:
08008 nodeMask = 0;
08009 break;
08010 case eFOR:
08011 nodeMask = 0;
08012 break;
08013 case eCASE:
08014 nodeMask = 0;
08015 break;
08016 case eCASEX:
08017 nodeMask = 0;
08018 break;
08019 case eCASEZ:
08020 nodeMask = 0;
08021 break;
08022 case eCASEITEM:
08023 nodeMask = 0;
08024 break;
08025 case eCASSIGN:
08026 nodeMask = 1;
08027 if( !(a->Arg<StrengthPair_t*>(0)==b->Arg<StrengthPair_t*>(0)) ) { return FALSE; }
08028 break;
08029 case eARG:
08030 nodeMask = 1;
08031 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
08032 break;
08033 case eFUNCTION_DEF:
08034 nodeMask = 1;
08035 if( !(a->Arg<CFunction*>(0)==b->Arg<CFunction*>(0)) ) { return FALSE; }
08036 break;
08037 case eMODULE_DEF:
08038 nodeMask = 1;
08039 if( !(a->Arg<CModule*>(0)==b->Arg<CModule*>(0)) ) { return FALSE; }
08040 break;
08041 case eREPEAT_CONTROL:
08042 nodeMask = 0;
08043 break;
08044 case eDELAY_CONTROL:
08045 nodeMask = 0;
08046 break;
08047 case eEVENT_CONTROL:
08048 nodeMask = 0;
08049 break;
08050 case eEXTERNAL_REF:
08051 nodeMask = 1;
08052 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
08053 break;
08054 case ePORT_DEF:
08055 nodeMask = 1;
08056 if( !(a->Arg<CPort*>(0)==b->Arg<CPort*>(0)) ) { return FALSE; }
08057 break;
08058 case eDEFPARAM:
08059 nodeMask = 0;
08060 break;
08061 case ePATH:
08062 nodeMask = 45;
08063 if( !(a->Arg<int>(0)==b->Arg<int>(0)) ) { return FALSE; }
08064 if( !(a->Arg<int>(2)==b->Arg<int>(2)) ) { return FALSE; }
08065 if( !(a->Arg<int>(3)==b->Arg<int>(3)) ) { return FALSE; }
08066 if( !(a->Arg<int>(5)==b->Arg<int>(5)) ) { return FALSE; }
08067 break;
08068 case ePATH_ASSIGN:
08069 nodeMask = 0;
08070 break;
08071 case eIFNONE_PATH_ASSIGN:
08072 nodeMask = 0;
08073 break;
08074 case eTRIGGER:
08075 nodeMask = 0;
08076 break;
08077 case ePASSIGN:
08078 nodeMask = 0;
08079 break;
08080 case eDEASSIGN:
08081 nodeMask = 0;
08082 break;
08083 case eDISABLE:
08084 nodeMask = 1;
08085 if( !(a->Arg<CSymbol*>(0)==b->Arg<CSymbol*>(0)) ) { return FALSE; }
08086 break;
08087 case eATTRIBUTE:
08088 nodeMask = 1;
08089 if( !(a->Arg<CAttr*>(0)==b->Arg<CAttr*>(0)) ) { return FALSE; }
08090 break;
08091 case eGIF:
08092 nodeMask = 0;
08093 break;
08094 case eGFOR:
08095 nodeMask = 0;
08096 break;
08097 case eGCASE:
08098 nodeMask = 0;
08099 break;
08100 case eTABLE:
08101 nodeMask = 0;
08102 break;
08103 case eTABLE_ENTRY:
08104 nodeMask = 0;
08105 break;
08106 case eTABLE_SYMBOL:
08107 nodeMask = 1;
08108 if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
08109 break;
08110 case ePORTLIST_END:
08111 nodeMask = 0;
08112 break;
08113 case eMACRO_EXPR:
08114 nodeMask = 1;
08115 if( !(!strcmp(a->Arg<char*>(0),b->Arg<char*>(0))) ) { return FALSE; }
08116 break;
08117 }
08118
08119 for( int i = 0; i < a->ArgCount(); i++ ) {
08120 if( !((nodeMask>>i)&1) &&
08121 !Equivalent(a->Arg<CNode*>(i),b->Arg<CNode*>(i)) ) return FALSE;
08122 }
08123 return TRUE;
08124 }
08125
08126
08127
08128
08129
08130
08131 int CNode::IsEvaluateable()
08132 {
08133
08134 switch( op ) {
08135 case eFUNCTION_CALL:
08136 return CFunction::Evaluateable(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
08137 case ePARAM_REF:
08138 return Arg<CParam*>(0)->GetExpression()->IsEvaluateable();
08139 case eMACRO_EXPR:
08140 return Arg<CNode*>(1) ? Arg<CNode*>(1)->IsEvaluateable() : FALSE;
08141 case eVCONSTANT:
08142 case eRCONSTANT:
08143 return TRUE;
08144 case eWIDTH:
08145 case eSUB:
08146 case eMUL:
08147 case eDIV:
08148 case ePOW:
08149 case eADD:
08150 case eLSH:
08151 case eRSH:
08152 case eLSHA:
08153 case eRSHA:
08154 case eMOD:
08155 case eOR:
08156 case eAND:
08157 case eXOR:
08158 case eXNOR:
08159 case eCVRI:
08160 case eCVIR:
08161 case eREP:
08162 case eCAT:
08163 case eUCAT:
08164 case eCOM:
08165 case eNEG:
08166 case eNOT:
08167 case eGT:
08168 case eGE:
08169 case eLT:
08170 case eLE:
08171 case eLAND:
08172 case eLOR:
08173 case eCEQ:
08174 case eCNE:
08175 case eEQ:
08176 case eNE:
08177 case eRAND:
08178 case eRNAND:
08179 case eROR:
08180 case eRNOR:
08181 case eRXOR:
08182 case eRXNOR:
08183 case eHOOK:
08184 break;
08185 case eERROR:
08186 case eCOMMENT:
08187 case eVRQ:
08188 case ePRAGMA:
08189 case eELIST:
08190 case eNOP:
08191 case eANDANDAND:
08192 case eINSTANCE_REF:
08193 case eGATE_REF:
08194 case eTASK_ENABLE:
08195 case eSYSTASK_CALL:
08196 case eTIMING_CALL:
08197 case eARRAY:
08198 case eNET_REF:
08199 case eREG_REF:
08200 case eREAL_REF:
08201 case ePORT_REF:
08202 case eFWD_REF:
08203 case eEVENT_REF:
08204 case eGENVAR_REF:
08205 case eNET_DECL:
08206 case eREG_DECL:
08207 case eREAL_DECL:
08208 case ePARAM_DECL:
08209 case eSPECPARAM_DECL:
08210 case ePORT_DECL:
08211 case eEVENT_DECL:
08212 case eGENVAR_DECL:
08213 case eLIST:
08214 case eRANGE:
08215 case eSLICE:
08216 case ePSLICE:
08217 case eMSLICE:
08218 case eINIT:
08219 case eALWAYS:
08220 case eEVENT:
08221 case eBLOCK_REF:
08222 case eSPECIFY_REF:
08223 case eASSIGN:
08224 case eFORCE:
08225 case eRELEASE:
08226 case eNBASSIGN:
08227 case ePOSEDGE:
08228 case eNEGEDGE:
08229 case eEDGE:
08230 case eEVOR:
08231 case eDELAY:
08232 case eMTM:
08233 case eIF:
08234 case eFOREVER:
08235 case eREPEAT:
08236 case eWHILE:
08237 case eWAIT:
08238 case eFOR:
08239 case eCASE:
08240 case eCASEX:
08241 case eCASEZ:
08242 case eCASEITEM:
08243 case eCASSIGN:
08244 case eARG:
08245 case eFUNCTION_DEF:
08246 case eMODULE_DEF:
08247 case eREPEAT_CONTROL:
08248 case eDELAY_CONTROL:
08249 case eEVENT_CONTROL:
08250 case eEXTERNAL_REF:
08251 case ePORT_DEF:
08252 case eDEFPARAM:
08253 case ePATH:
08254 case ePATH_ASSIGN:
08255 case eIFNONE_PATH_ASSIGN:
08256 case eTRIGGER:
08257 case ePASSIGN:
08258 case eDEASSIGN:
08259 case eDISABLE:
08260 case eATTRIBUTE:
08261 case eGIF:
08262 case eGFOR:
08263 case eGCASE:
08264 case eTABLE:
08265 case eTABLE_ENTRY:
08266 case eTABLE_SYMBOL:
08267 case ePORTLIST_END:
08268 return FALSE;
08269 default:
08270 MASSERT( FALSE );
08271 }
08272
08273 for( int i = 0; i < ArgCount(); i++ ) {
08274 if( !Arg<CNode*>(i)->IsEvaluateable() ) return FALSE;
08275 }
08276
08277 return TRUE;
08278 }
08279
08280
08281
08282
08283
08284
08285
08286
08287
08288
08289 void CNode::_EvalVector( CVector& v )
08290 {
08291 switch( op ) {
08292 case eVCONSTANT:
08293 { int width = v.GetWidth(); v.SetWidth(Arg<CVector*>(0)->GetWidth()); v = *Arg<CVector*>(0); v.SetWidth(width); };
08294 break;
08295 case eWIDTH:
08296 {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;};
08297 break;
08298 case eSUB:
08299 EVAL_VECTOR_BINARY(Sub);
08300 break;
08301 case eMUL:
08302 EVAL_VECTOR_BINARY(Mul);
08303 break;
08304 case eDIV:
08305 EVAL_VECTOR_BINARY(Div);
08306 break;
08307 case ePOW:
08308 EVAL_VECTOR_BINARY(Pow);
08309 break;
08310 case eADD:
08311 EVAL_VECTOR_BINARY(Add);
08312 break;
08313 case eLSH:
08314 EVAL_VECTOR_BINARY_SELF_RIGHT(Lsh);
08315 break;
08316 case eRSH:
08317 EVAL_VECTOR_BINARY_SELF_RIGHT(Rsh);
08318 break;
08319 case eLSHA:
08320 EVAL_VECTOR_BINARY_SELF_RIGHT(Lsha);
08321 break;
08322 case eRSHA:
08323 EVAL_VECTOR_BINARY_SELF_RIGHT(Rsha);
08324 break;
08325 case eMOD:
08326 EVAL_VECTOR_BINARY(Mod);
08327 break;
08328 case eOR:
08329 EVAL_VECTOR_BINARY(Or);
08330 break;
08331 case eAND:
08332 EVAL_VECTOR_BINARY(And);
08333 break;
08334 case eXOR:
08335 EVAL_VECTOR_BINARY(Xor);
08336 break;
08337 case eXNOR:
08338 EVAL_VECTOR_BINARY(Xnor);
08339 break;
08340 case eFUNCTION_CALL:
08341 CFunction::EvalVector(v,Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
08342 break;
08343 case ePARAM_REF:
08344 EVAL_VECTOR_PARAM_REF();
08345 break;
08346 case eCVRI:
08347 v.LoadReal( Arg<CNode*>(0)->_EvalReal() );
08348 break;
08349 case eREP:
08350 EVAL_VECTOR_BINARY(Rep);
08351 break;
08352 case eCAT:
08353 EVAL_VECTOR_BINARY(Cat);
08354 break;
08355 case eUCAT:
08356 { CVector vv(Arg<CNode*>(0)->width); Arg<CNode*>(0)->_EvalVector(vv); v = vv;};
08357 break;
08358 case eCOM:
08359 EVAL_VECTOR_UNARY(Com);
08360 break;
08361 case eNEG:
08362 EVAL_VECTOR_UNARY(Neg);
08363 break;
08364 case eNOT:
08365 EVAL_VECTOR_UNARY(Not);
08366 break;
08367 case eGT:
08368 EVAL_RELATIONAL(Gt);
08369 break;
08370 case eGE:
08371 EVAL_RELATIONAL(Ge);
08372 break;
08373 case eLT:
08374 EVAL_RELATIONAL(Lt);
08375 break;
08376 case eLE:
08377 EVAL_RELATIONAL(Le);
08378 break;
08379 case eLAND:
08380 EVAL_VECTOR_BINARY(Land);
08381 break;
08382 case eLOR:
08383 EVAL_VECTOR_BINARY(Lor);
08384 break;
08385 case eCEQ:
08386 EVAL_RELATIONAL(Ceq);
08387 break;
08388 case eCNE:
08389 EVAL_RELATIONAL(Cne);
08390 break;
08391 case eEQ:
08392 EVAL_RELATIONAL(Eq);
08393 break;
08394 case eNE:
08395 EVAL_RELATIONAL(Ne);
08396 break;
08397 case eRAND:
08398 EVAL_VECTOR_UNARY_SELF(Rand);
08399 break;
08400 case eRNAND:
08401 EVAL_VECTOR_UNARY_SELF(Rnand);
08402 break;
08403 case eROR:
08404 EVAL_VECTOR_UNARY_SELF(Ror);
08405 break;
08406 case eRNOR:
08407 EVAL_VECTOR_UNARY_SELF(Rnor);
08408 break;
08409 case eRXOR:
08410 EVAL_VECTOR_UNARY_SELF(Rxor);
08411 break;
08412 case eRXNOR:
08413 EVAL_VECTOR_UNARY_SELF(Rxnor);
08414 break;
08415 case eHOOK:
08416 EVAL_VECTOR_HOOK();
08417 break;
08418 case eMACRO_EXPR:
08419 Arg<CNode*>(1)->EvalVector(v);
08420 break;
08421 default:
08422 MASSERT( FALSE );
08423 }
08424 }
08425
08426
08427
08428
08429
08430
08431
08432
08433
08434
08435 double CNode::_EvalReal()
08436 {
08437 double d;
08438 switch( op ) {
08439 case eRCONSTANT:
08440 d = s2d(Arg<char*>(0));
08441 break;
08442 case eSUB:
08443 EVAL_REAL_BINARY(Sub);
08444 break;
08445 case eMUL:
08446 EVAL_REAL_BINARY(Mul);
08447 break;
08448 case eDIV:
08449 EVAL_REAL_BINARY(Div);
08450 break;
08451 case ePOW:
08452 EVAL_REAL_BINARY(Pow);
08453 break;
08454 case eADD:
08455 EVAL_REAL_BINARY(Add);
08456 break;
08457 case eFUNCTION_CALL:
08458 d = CFunction::EvalReal(Arg<CSymbol*>(0),Arg<CNode*>(1),Arg<CBlock*>(2));;
08459 break;
08460 case ePARAM_REF:
08461 EVAL_REAL_PARAM_REF();
08462 break;
08463 case eCVIR:
08464 { CVector v(Arg<CNode*>(0)->width); v.Signed(Arg<CNode*>(0)->type == eS); Arg<CNode*>(0)->_EvalVector(v); d = v.GetReal(); };
08465 break;
08466 case eNEG:
08467 EVAL_REAL_UNARY(Neg);
08468 break;
08469 case eHOOK:
08470 EVAL_REAL_HOOK();
08471 break;
08472 case eMACRO_EXPR:
08473 d = Arg<CNode*>(1)->EvalReal();
08474 break;
08475 default:
08476 MASSERT( FALSE );
08477 }
08478 return d;
08479 }
08480
08481
08482
08483
08484
08485 int CNode::ConditionalWiden()
08486 {
08487 switch( GetOp() ) {
08488 case eVCONSTANT:
08489 return 0;
08490 case eRCONSTANT:
08491 return 0;
08492 case eELIST:
08493 return 0;
08494 case eWIDTH:
08495 return 0;
08496 case eSUB:
08497 return 0;
08498 case eMUL:
08499 return 0;
08500 case eDIV:
08501 return 0;
08502 case ePOW:
08503 return 0;
08504 case eADD:
08505 return 0;
08506 case eLSH:
08507 return 0;
08508 case eRSH:
08509 return 0;
08510 case eLSHA:
08511 return 0;
08512 case eRSHA:
08513 return 0;
08514 case eMOD:
08515 return 0;
08516 case eOR:
08517 return 1;
08518 case eAND:
08519 return 1;
08520 case eANDANDAND:
08521 return 0;
08522 case eXOR:
08523 return 1;
08524 case eXNOR:
08525 return 1;
08526 case eSYSTASK_CALL:
08527 return 0;
08528 case eFUNCTION_CALL:
08529 return 0;
08530 case eARRAY:
08531 return 0;
08532 case eNET_REF:
08533 return 0;
08534 case eREG_REF:
08535 return 0;
08536 case eREAL_REF:
08537 return 0;
08538 case ePARAM_REF:
08539 return 0;
08540 case ePORT_REF:
08541 return 0;
08542 case eFWD_REF:
08543 return 0;
08544 case eGENVAR_REF:
08545 return 0;
08546 case eRANGE:
08547 return 0;
08548 case eSLICE:
08549 return 0;
08550 case ePSLICE:
08551 return 0;
08552 case eMSLICE:
08553 return 0;
08554 case eCVRI:
08555 return 0;
08556 case eCVIR:
08557 return 0;
08558 case eREP:
08559 return 0;
08560 case eCAT:
08561 return 0;
08562 case eUCAT:
08563 return 0;
08564 case eCOM:
08565 return 0;
08566 case eNEG:
08567 return 0;
08568 case eNOT:
08569 return 0;
08570 case eGT:
08571 return 0;
08572 case eGE:
08573 return 0;
08574 case eLT:
08575 return 0;
08576 case eLE:
08577 return 0;
08578 case eLAND:
08579 return 0;
08580 case eLOR:
08581 return 0;
08582 case eCEQ:
08583 return 0;
08584 case eCNE:
08585 return 0;
08586 case eEQ:
08587 return 0;
08588 case eNE:
08589 return 0;
08590 case eRAND:
08591 return 0;
08592 case eRNAND:
08593 return 0;
08594 case eROR:
08595 return 0;
08596 case eRNOR:
08597 return 0;
08598 case eRXOR:
08599 return 0;
08600 case eRXNOR:
08601 return 0;
08602 case eHOOK:
08603 return 0;
08604 case eMTM:
08605 return 0;
08606 case eEXTERNAL_REF:
08607 return 0;
08608 case eATTRIBUTE:
08609 return 0;
08610 case eMACRO_EXPR:
08611 return 0;
08612 default:
08613 MASSERT( FALSE );
08614 }
08615 return 0;
08616 }
08617
08618
08619
08620
08621
08622
08623 unsigned CNode::NodeMask()
08624 {
08625 switch( GetOp() ) {
08626 case eVCONSTANT:
08627 return 0;
08628 case eRCONSTANT:
08629 return 0;
08630 case eELIST:
08631 return 3;
08632 case eWIDTH:
08633 return 3;
08634 case eSUB:
08635 return 3;
08636 case eMUL:
08637 return 3;
08638 case eDIV:
08639 return 3;
08640 case ePOW:
08641 return 3;
08642 case eADD:
08643 return 3;
08644 case eLSH:
08645 return 3;
08646 case eRSH:
08647 return 3;
08648 case eLSHA:
08649 return 3;
08650 case eRSHA:
08651 return 3;
08652 case eMOD:
08653 return 3;
08654 case eOR:
08655 return 3;
08656 case eAND:
08657 return 3;
08658 case eANDANDAND:
08659 return 3;
08660 case eXOR:
08661 return 3;
08662 case eXNOR:
08663 return 3;
08664 case eSYSTASK_CALL:
08665 return 2;
08666 case eFUNCTION_CALL:
08667 return 2;
08668 case eARRAY:
08669 return 3;
08670 case eNET_REF:
08671 return 0;
08672 case eREG_REF:
08673 return 0;
08674 case eREAL_REF:
08675 return 0;
08676 case ePARAM_REF:
08677 return 0;
08678 case ePORT_REF:
08679 return 0;
08680 case eFWD_REF:
08681 return 0;
08682 case eGENVAR_REF:
08683 return 0;
08684 case eRANGE:
08685 return 3;
08686 case eSLICE:
08687 return 3;
08688 case ePSLICE:
08689 return 3;
08690 case eMSLICE:
08691 return 3;
08692 case eCVRI:
08693 return 1;
08694 case eCVIR:
08695 return 1;
08696 case eREP:
08697 return 3;
08698 case eCAT:
08699 return 3;
08700 case eUCAT:
08701 return 1;
08702 case eCOM:
08703 return 1;
08704 case eNEG:
08705 return 1;
08706 case eNOT:
08707 return 1;
08708 case eGT:
08709 return 3;
08710 case eGE:
08711 return 3;
08712 case eLT:
08713 return 3;
08714 case eLE:
08715 return 3;
08716 case eLAND:
08717 return 3;
08718 case eLOR:
08719 return 3;
08720 case eCEQ:
08721 return 3;
08722 case eCNE:
08723 return 3;
08724 case eEQ:
08725 return 3;
08726 case eNE:
08727 return 3;
08728 case eRAND:
08729 return 1;
08730 case eRNAND:
08731 return 1;
08732 case eROR:
08733 return 1;
08734 case eRNOR:
08735 return 1;
08736 case eRXOR:
08737 return 1;
08738 case eRXNOR:
08739 return 1;
08740 case eHOOK:
08741 return 7;
08742 case eMTM:
08743 return 7;
08744 case eEXTERNAL_REF:
08745 return 0;
08746 case eATTRIBUTE:
08747 return 0;
08748 case eMACRO_EXPR:
08749 return 2;
08750 default:
08751 MASSERT( FALSE );
08752 }
08753 return 0;
08754 }
08755
08756
08757
08758
08759
08760
08761 int CNode::WidthFixed()
08762 {
08763 switch( GetOp() ) {
08764 case eVCONSTANT:
08765 return NodeMask()==0;
08766 case eRCONSTANT:
08767 return 1;
08768 case eELIST:
08769 return NodeMask()==0;
08770 case eWIDTH:
08771 return NodeMask()==0;
08772 case eSUB:
08773 return NodeMask()==0;
08774 case eMUL:
08775 return NodeMask()==0;
08776 case eDIV:
08777 return NodeMask()==0;
08778 case ePOW:
08779 return NodeMask()==0;
08780 case eADD:
08781 return NodeMask()==0;
08782 case eLSH:
08783 return NodeMask()==0;
08784 case eRSH:
08785 return NodeMask()==0;
08786 case eLSHA:
08787 return NodeMask()==0;
08788 case eRSHA:
08789 return NodeMask()==0;
08790 case eMOD:
08791 return NodeMask()==0;
08792 case eOR:
08793 return NodeMask()==0;
08794 case eAND:
08795 return NodeMask()==0;
08796 case eANDANDAND:
08797 return NodeMask()==0;
08798 case eXOR:
08799 return NodeMask()==0;
08800 case eXNOR:
08801 return NodeMask()==0;
08802 case eSYSTASK_CALL:
08803 return NodeMask()==0;
08804 case eFUNCTION_CALL:
08805 return NodeMask()==0;
08806 case eARRAY:
08807 return NodeMask()==0;
08808 case eNET_REF:
08809 return NodeMask()==0;
08810 case eREG_REF:
08811 return NodeMask()==0;
08812 case eREAL_REF:
08813 return NodeMask()==0;
08814 case ePARAM_REF:
08815 return NodeMask()==0;
08816 case ePORT_REF:
08817 return NodeMask()==0;
08818 case eFWD_REF:
08819 return NodeMask()==0;
08820 case eGENVAR_REF:
08821 return NodeMask()==0;
08822 case eRANGE:
08823 return NodeMask()==0;
08824 case eSLICE:
08825 return NodeMask()==0;
08826 case ePSLICE:
08827 return NodeMask()==0;
08828 case eMSLICE:
08829 return NodeMask()==0;
08830 case eCVRI:
08831 return 1;
08832 case eCVIR:
08833 return 1;
08834 case eREP:
08835 return NodeMask()==0;
08836 case eCAT:
08837 return NodeMask()==0;
08838 case eUCAT:
08839 return NodeMask()==0;
08840 case eCOM:
08841 return NodeMask()==0;
08842 case eNEG:
08843 return NodeMask()==0;
08844 case eNOT:
08845 return 1;
08846 case eGT:
08847 return 1;
08848 case eGE:
08849 return 1;
08850 case eLT:
08851 return 1;
08852 case eLE:
08853 return 1;
08854 case eLAND:
08855 return 1;
08856 case eLOR:
08857 return 1;
08858 case eCEQ:
08859 return 1;
08860 case eCNE:
08861 return 1;
08862 case eEQ:
08863 return 1;
08864 case eNE:
08865 return 1;
08866 case eRAND:
08867 return 1;
08868 case eRNAND:
08869 return 1;
08870 case eROR:
08871 return 1;
08872 case eRNOR:
08873 return 1;
08874 case eRXOR:
08875 return 1;
08876 case eRXNOR:
08877 return 1;
08878 case eHOOK:
08879 return NodeMask()==0;
08880 case eMTM:
08881 return NodeMask()==0;
08882 case eEXTERNAL_REF:
08883 return NodeMask()==0;
08884 case eATTRIBUTE:
08885 return 1;
08886 case eMACRO_EXPR:
08887 return NodeMask()==0;
08888 default:
08889 MASSERT( FALSE );
08890 }
08891 return 0;
08892 }
08893
08894
08895
08896
08897
08898 struct LabelBitsInfo {
08899 int suppressErrorMessages;
08900 int error;
08901 };
08902
08903 void CNode::_LabelBits( CNode* n, void* arg )
08904 {
08905
08906
08907
08908
08909
08910
08911 if( labelCacheEnabled && (evalCount == 0 || !evalHeap.IsOwner(n)) ) {
08912 if( labelCache.find(n) != labelCache.end() ) {
08913 return;
08914 }
08915 labelCache[n] = 1;
08916 }
08917
08918
08919 LabelBitsInfo* info = (LabelBitsInfo*)arg;
08920 int suppressErrorMessages = info->suppressErrorMessages;
08921 unsigned nodeMask = n->NodeMask();
08922 int conditionalWiden = n->ConditionalWiden();
08923
08924 switch( n->GetOp() ) {
08925 case eVCONSTANT:
08926 n->type = n->Arg<CVector*>(0)->GetNodeType();
08927 break;
08928 case eRCONSTANT:
08929 if(1) {
08930 n->type = eR;
08931 }
08932 break;
08933 case eELIST:
08934 if( n->Arg<CNode*>(0)->type == eR ) {
08935 info->error = 1;
08936 if( !suppressErrorMessages ) {
08937 error(n->GetCoord(), "Illegal expression operand" );
08938 }
08939 } else if( n->Arg<CNode*>(1)->type == eR ) {
08940 info->error = 1;
08941 if( !suppressErrorMessages ) {
08942 error(n->GetCoord(), "Illegal expression operand" );
08943 }
08944 } else if(1) {
08945 n->type = eB;
08946 }
08947 break;
08948 case eWIDTH:
08949 if( n->Arg<CNode*>(1)->type == eS ) {
08950 n->type = eS;
08951 } else if(1) {
08952 n->type = eB;
08953 }
08954 break;
08955 case eSUB:
08956 if( n->Arg<CNode*>(0)->type == eR ) {
08957 n->type = eR;
08958 } else if( n->Arg<CNode*>(1)->type == eR ) {
08959 n->type = eR;
08960 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
08961 n->type = eS;
08962 } else if(1) {
08963 n->type = eB;
08964 }
08965 break;
08966 case eMUL:
08967 if( n->Arg<CNode*>(0)->type == eR ) {
08968 n->type = eR;
08969 } else if( n->Arg<CNode*>(1)->type == eR ) {
08970 n->type = eR;
08971 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
08972 n->type = eS;
08973 } else if(1) {
08974 n->type = eB;
08975 }
08976 break;
08977 case eDIV:
08978 if( n->Arg<CNode*>(0)->type == eR ) {
08979 n->type = eR;
08980 } else if( n->Arg<CNode*>(1)->type == eR ) {
08981 n->type = eR;
08982 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
08983 n->type = eS;
08984 } else if(1) {
08985 n->type = eB;
08986 }
08987 break;
08988 case ePOW:
08989 if( n->Arg<CNode*>(0)->type == eR ) {
08990 n->type = eR;
08991 } else if( n->Arg<CNode*>(1)->type == eR ) {
08992 n->type = eR;
08993 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
08994 n->type = eS;
08995 } else if(1) {
08996 n->type = eB;
08997 }
08998 break;
08999 case eADD:
09000 if( n->Arg<CNode*>(0)->type == eR ) {
09001 n->type = eR;
09002 } else if( n->Arg<CNode*>(1)->type == eR ) {
09003 n->type = eR;
09004 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09005 n->type = eS;
09006 } else if(1) {
09007 n->type = eB;
09008 }
09009 break;
09010 case eLSH:
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 eRSH:
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 eLSHA:
09025 if( n->Arg<CNode*>(0)->type == eS ) {
09026 n->type = eS;
09027 } else if(1) {
09028 n->type = eB;
09029 }
09030 break;
09031 case eRSHA:
09032 if( n->Arg<CNode*>(0)->type == eS ) {
09033 n->type = eS;
09034 } else if(1) {
09035 n->type = eB;
09036 }
09037 break;
09038 case eMOD:
09039 if( n->Arg<CNode*>(0)->type == eR ) {
09040 info->error = 1;
09041 if( !suppressErrorMessages ) {
09042 error(n->GetCoord(), "Illegal expression operand" );
09043 }
09044 } else if( n->Arg<CNode*>(1)->type == eR ) {
09045 info->error = 1;
09046 if( !suppressErrorMessages ) {
09047 error(n->GetCoord(), "Illegal expression operand" );
09048 }
09049 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09050 n->type = eS;
09051 } else if(1) {
09052 n->type = eB;
09053 }
09054 break;
09055 case eOR:
09056 if( n->Arg<CNode*>(0)->type == eR ) {
09057 info->error = 1;
09058 if( !suppressErrorMessages ) {
09059 error(n->GetCoord(), "Illegal expression operand" );
09060 }
09061 } else if( n->Arg<CNode*>(1)->type == eR ) {
09062 info->error = 1;
09063 if( !suppressErrorMessages ) {
09064 error(n->GetCoord(), "Illegal expression operand" );
09065 }
09066 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09067 n->type = eS;
09068 } else if(1) {
09069 n->type = eB;
09070 }
09071 break;
09072 case eAND:
09073 if( n->Arg<CNode*>(0)->type == eR ) {
09074 info->error = 1;
09075 if( !suppressErrorMessages ) {
09076 error(n->GetCoord(), "Illegal expression operand" );
09077 }
09078 } else if( n->Arg<CNode*>(1)->type == eR ) {
09079 info->error = 1;
09080 if( !suppressErrorMessages ) {
09081 error(n->GetCoord(), "Illegal expression operand" );
09082 }
09083 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09084 n->type = eS;
09085 } else if(1) {
09086 n->type = eB;
09087 }
09088 break;
09089 case eANDANDAND:
09090 if( n->Arg<CNode*>(0)->type == eR ) {
09091 info->error = 1;
09092 if( !suppressErrorMessages ) {
09093 error(n->GetCoord(), "Illegal expression operand" );
09094 }
09095 } else if( n->Arg<CNode*>(1)->type == eR ) {
09096 info->error = 1;
09097 if( !suppressErrorMessages ) {
09098 error(n->GetCoord(), "Illegal expression operand" );
09099 }
09100 } else if(1) {
09101 n->type = eB;
09102 }
09103 break;
09104 case eXOR:
09105 if( n->Arg<CNode*>(0)->type == eR ) {
09106 info->error = 1;
09107 if( !suppressErrorMessages ) {
09108 error(n->GetCoord(), "Illegal expression operand" );
09109 }
09110 } else if( n->Arg<CNode*>(1)->type == eR ) {
09111 info->error = 1;
09112 if( !suppressErrorMessages ) {
09113 error(n->GetCoord(), "Illegal expression operand" );
09114 }
09115 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09116 n->type = eS;
09117 } else if(1) {
09118 n->type = eB;
09119 }
09120 break;
09121 case eXNOR:
09122 if( n->Arg<CNode*>(0)->type == eR ) {
09123 info->error = 1;
09124 if( !suppressErrorMessages ) {
09125 error(n->GetCoord(), "Illegal expression operand" );
09126 }
09127 } else if( n->Arg<CNode*>(1)->type == eR ) {
09128 info->error = 1;
09129 if( !suppressErrorMessages ) {
09130 error(n->GetCoord(), "Illegal expression operand" );
09131 }
09132 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS ) {
09133 n->type = eS;
09134 } else if(1) {
09135 n->type = eB;
09136 }
09137 break;
09138 case eSYSTASK_CALL:
09139 n->type = Systask::Type(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1));
09140 break;
09141 case eFUNCTION_CALL:
09142 n->type = CFunction::Type(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1),n->Arg<CScope*>(2));
09143 break;
09144 case eARRAY:
09145 n->type = Array::Type(n->Arg<CNode*>(0),n->Arg<CNode*>(1));
09146 break;
09147 case eNET_REF:
09148 n->type = n->Arg<CNet*>(0)->GetNodeType();
09149 break;
09150 case eREG_REF:
09151 n->type = n->Arg<CReg*>(0)->GetNodeType();
09152 break;
09153 case eREAL_REF:
09154 if(1) {
09155 n->type = eR;
09156 }
09157 break;
09158 case ePARAM_REF:
09159 n->type = n->Arg<CParam*>(0)->GetNodeType();
09160 break;
09161 case ePORT_REF:
09162 n->type = n->Arg<CPortDir*>(0)->GetNodeType();
09163 break;
09164 case eFWD_REF:
09165 if(1) {
09166 n->type = eB;
09167 }
09168 break;
09169 case eGENVAR_REF:
09170 n->type = n->Arg<CGenvar*>(0)->GetNodeType();
09171 break;
09172 case eRANGE:
09173 if( n->Arg<CNode*>(0)->type == eR ) {
09174 info->error = 1;
09175 if( !suppressErrorMessages ) {
09176 error(n->GetCoord(), "Illegal expression operand" );
09177 }
09178 } else if( n->Arg<CNode*>(1)->type == eR ) {
09179 info->error = 1;
09180 if( !suppressErrorMessages ) {
09181 error(n->GetCoord(), "Illegal expression operand" );
09182 }
09183 } else if(1) {
09184 n->type = eB;
09185 }
09186 break;
09187 case eSLICE:
09188 if( n->Arg<CNode*>(0)->type == eR ) {
09189 info->error = 1;
09190 if( !suppressErrorMessages ) {
09191 error(n->GetCoord(), "Illegal expression operand" );
09192 }
09193 } else if( n->Arg<CNode*>(1)->type == eR ) {
09194 info->error = 1;
09195 if( !suppressErrorMessages ) {
09196 error(n->GetCoord(), "Illegal expression operand" );
09197 }
09198 } else if(1) {
09199 n->type = eB;
09200 }
09201 break;
09202 case ePSLICE:
09203 if( n->Arg<CNode*>(1)->type == eR ) {
09204 info->error = 1;
09205 if( !suppressErrorMessages ) {
09206 error(n->GetCoord(), "Illegal expression operand" );
09207 }
09208 } else if(1) {
09209 n->type = eB;
09210 }
09211 break;
09212 case eMSLICE:
09213 if( n->Arg<CNode*>(1)->type == eR ) {
09214 info->error = 1;
09215 if( !suppressErrorMessages ) {
09216 error(n->GetCoord(), "Illegal expression operand" );
09217 }
09218 } else if(1) {
09219 n->type = eB;
09220 }
09221 break;
09222 case eCVRI:
09223 if(1) {
09224 n->type = eS;
09225 }
09226 break;
09227 case eCVIR:
09228 if(1) {
09229 n->type = eR;
09230 }
09231 break;
09232 case eREP:
09233 if( n->Arg<CNode*>(0)->type == eR ) {
09234 info->error = 1;
09235 if( !suppressErrorMessages ) {
09236 error(n->GetCoord(), "Illegal expression operand" );
09237 }
09238 } else if( n->Arg<CNode*>(1)->type == eR ) {
09239 info->error = 1;
09240 if( !suppressErrorMessages ) {
09241 error(n->GetCoord(), "Illegal expression operand" );
09242 }
09243 } else if(1) {
09244 n->type = eB;
09245 }
09246 break;
09247 case eCAT:
09248 if( n->Arg<CNode*>(0)->type == eR ) {
09249 info->error = 1;
09250 if( !suppressErrorMessages ) {
09251 error(n->GetCoord(), "Illegal expression operand" );
09252 }
09253 } else if( n->Arg<CNode*>(1)->type == eR ) {
09254 info->error = 1;
09255 if( !suppressErrorMessages ) {
09256 error(n->GetCoord(), "Illegal expression operand" );
09257 }
09258 } else if(1) {
09259 n->type = eB;
09260 }
09261 break;
09262 case eUCAT:
09263 if( n->Arg<CNode*>(0)->type == eR ) {
09264 info->error = 1;
09265 if( !suppressErrorMessages ) {
09266 error(n->GetCoord(), "Illegal expression operand" );
09267 }
09268 } else if(1) {
09269 n->type = eB;
09270 }
09271 break;
09272 case eCOM:
09273 if( n->Arg<CNode*>(0)->type == eR ) {
09274 info->error = 1;
09275 if( !suppressErrorMessages ) {
09276 error(n->GetCoord(), "Illegal expression operand" );
09277 }
09278 } else if( n->Arg<CNode*>(0)->type == eS ) {
09279 n->type = eS;
09280 } else if(1) {
09281 n->type = eB;
09282 }
09283 break;
09284 case eNEG:
09285 n->type = n->Arg<CNode*>(0)->type;
09286 break;
09287 case eNOT:
09288 if(1) {
09289 n->type = eB;
09290 }
09291 break;
09292 case eGT:
09293 if(1) {
09294 n->type = eB;
09295 }
09296 break;
09297 case eGE:
09298 if(1) {
09299 n->type = eB;
09300 }
09301 break;
09302 case eLT:
09303 if(1) {
09304 n->type = eB;
09305 }
09306 break;
09307 case eLE:
09308 if(1) {
09309 n->type = eB;
09310 }
09311 break;
09312 case eLAND:
09313 if(1) {
09314 n->type = eB;
09315 }
09316 break;
09317 case eLOR:
09318 if(1) {
09319 n->type = eB;
09320 }
09321 break;
09322 case eCEQ:
09323 if( n->Arg<CNode*>(0)->type == eR ) {
09324 info->error = 1;
09325 if( !suppressErrorMessages ) {
09326 error(n->GetCoord(), "Illegal expression operand" );
09327 }
09328 } else if( n->Arg<CNode*>(1)->type == eR ) {
09329 info->error = 1;
09330 if( !suppressErrorMessages ) {
09331 error(n->GetCoord(), "Illegal expression operand" );
09332 }
09333 } else if(1) {
09334 n->type = eB;
09335 }
09336 break;
09337 case eCNE:
09338 if( n->Arg<CNode*>(0)->type == eR ) {
09339 info->error = 1;
09340 if( !suppressErrorMessages ) {
09341 error(n->GetCoord(), "Illegal expression operand" );
09342 }
09343 } else if( n->Arg<CNode*>(1)->type == eR ) {
09344 info->error = 1;
09345 if( !suppressErrorMessages ) {
09346 error(n->GetCoord(), "Illegal expression operand" );
09347 }
09348 } else if(1) {
09349 n->type = eB;
09350 }
09351 break;
09352 case eEQ:
09353 if(1) {
09354 n->type = eB;
09355 }
09356 break;
09357 case eNE:
09358 if(1) {
09359 n->type = eB;
09360 }
09361 break;
09362 case eRAND:
09363 if( n->Arg<CNode*>(0)->type == eR ) {
09364 info->error = 1;
09365 if( !suppressErrorMessages ) {
09366 error(n->GetCoord(), "Illegal expression operand" );
09367 }
09368 } else if(1) {
09369 n->type = eB;
09370 }
09371 break;
09372 case eRNAND:
09373 if( n->Arg<CNode*>(0)->type == eR ) {
09374 info->error = 1;
09375 if( !suppressErrorMessages ) {
09376 error(n->GetCoord(), "Illegal expression operand" );
09377 }
09378 } else if(1) {
09379 n->type = eB;
09380 }
09381 break;
09382 case eROR:
09383 if( n->Arg<CNode*>(0)->type == eR ) {
09384 info->error = 1;
09385 if( !suppressErrorMessages ) {
09386 error(n->GetCoord(), "Illegal expression operand" );
09387 }
09388 } else if(1) {
09389 n->type = eB;
09390 }
09391 break;
09392 case eRNOR:
09393 if( n->Arg<CNode*>(0)->type == eR ) {
09394 info->error = 1;
09395 if( !suppressErrorMessages ) {
09396 error(n->GetCoord(), "Illegal expression operand" );
09397 }
09398 } else if(1) {
09399 n->type = eB;
09400 }
09401 break;
09402 case eRXOR:
09403 if( n->Arg<CNode*>(0)->type == eR ) {
09404 info->error = 1;
09405 if( !suppressErrorMessages ) {
09406 error(n->GetCoord(), "Illegal expression operand" );
09407 }
09408 } else if(1) {
09409 n->type = eB;
09410 }
09411 break;
09412 case eRXNOR:
09413 if( n->Arg<CNode*>(0)->type == eR ) {
09414 info->error = 1;
09415 if( !suppressErrorMessages ) {
09416 error(n->GetCoord(), "Illegal expression operand" );
09417 }
09418 } else if(1) {
09419 n->type = eB;
09420 }
09421 break;
09422 case eHOOK:
09423 if( n->Arg<CNode*>(1)->type == eR ) {
09424 n->type = eR;
09425 } else if( n->Arg<CNode*>(2)->type == eR ) {
09426 n->type = eR;
09427 } else if( n->Arg<CNode*>(1)->type == eS && n->Arg<CNode*>(2)->type == eS ) {
09428 n->type = eS;
09429 } else if(1) {
09430 n->type = eB;
09431 }
09432 break;
09433 case eMTM:
09434 if( n->Arg<CNode*>(0)->type == eR ) {
09435 n->type = eR;
09436 } else if( n->Arg<CNode*>(1)->type == eR ) {
09437 n->type = eR;
09438 } else if( n->Arg<CNode*>(2)->type == eR ) {
09439 n->type = eR;
09440 } else if( n->Arg<CNode*>(0)->type == eS && n->Arg<CNode*>(1)->type == eS && n->Arg<CNode*>(2)->type == eS ) {
09441 n->type = eS;
09442 } else if(1) {
09443 n->type = eB;
09444 }
09445 break;
09446 case eEXTERNAL_REF:
09447 n->type = External::Type(n->Arg<CSymbol*>(0));
09448 break;
09449 case eATTRIBUTE:
09450 if(1) {
09451 n->type = eU;
09452 }
09453 break;
09454 case eMACRO_EXPR:
09455 n->type = n->Arg<CNode*>(1)->type;
09456 break;
09457 default:
09458 MASSERT( FALSE );
09459 }
09460
09461
09462
09463
09464 switch( n->type ) {
09465 case eE:
09466 case eR:
09467 n->width = 0;
09468 return;
09469 }
09470
09471
09472
09473
09474 switch( n->GetOp() ) {
09475 case eERROR:
09476 n->width = 0;
09477 break;
09478 case eVCONSTANT:
09479 n->width = (!n->Arg<CVector*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CVector*>(0)->GetWidth();
09480 break;
09481 case eRCONSTANT:
09482 n->width = 0;
09483 break;
09484 case eELIST:
09485 n->width = cADD(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09486 break;
09487 case eWIDTH:
09488 n->width = ((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(0)->EvalINT32();
09489 break;
09490 case eSUB:
09491 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09492 break;
09493 case eMUL:
09494 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09495 break;
09496 case eDIV:
09497 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09498 break;
09499 case ePOW:
09500 n->width = n->Arg<CNode*>(0)->width;
09501 break;
09502 case eADD:
09503 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09504 break;
09505 case eLSH:
09506 n->width = n->Arg<CNode*>(0)->width;
09507 break;
09508 case eRSH:
09509 n->width = n->Arg<CNode*>(0)->width;
09510 break;
09511 case eLSHA:
09512 n->width = n->Arg<CNode*>(0)->width;
09513 break;
09514 case eRSHA:
09515 n->width = n->Arg<CNode*>(0)->width;
09516 break;
09517 case eMOD:
09518 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09519 break;
09520 case eOR:
09521 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09522 break;
09523 case eAND:
09524 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09525 break;
09526 case eANDANDAND:
09527 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09528 break;
09529 case eXOR:
09530 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09531 break;
09532 case eXNOR:
09533 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09534 break;
09535 case eSYSTASK_CALL:
09536 n->width = Systask::Width(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1));
09537 break;
09538 case eFUNCTION_CALL:
09539 n->width = CFunction::Width(n->Arg<CSymbol*>(0),n->Arg<CNode*>(1),n->Arg<CScope*>(2));
09540 break;
09541 case eARRAY:
09542 n->width = Array::Width(n->Arg<CNode*>(0),n->Arg<CNode*>(1));
09543 break;
09544 case eNET_REF:
09545 n->width = (!n->Arg<CNet*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CNet*>(0)->GetWidth();
09546 break;
09547 case eREG_REF:
09548 n->width = (!n->Arg<CReg*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CReg*>(0)->GetWidth();
09549 break;
09550 case eREAL_REF:
09551 n->width = (!n->Arg<CReal*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CReal*>(0)->GetWidth();
09552 break;
09553 case ePARAM_REF:
09554 n->width = (!n->Arg<CParam*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CParam*>(0)->GetWidth();
09555 break;
09556 case ePORT_REF:
09557 n->width = (!n->Arg<CPortDir*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CPortDir*>(0)->GetWidth();
09558 break;
09559 case eFWD_REF:
09560 n->width = (!n->Arg<CFref*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CFref*>(0)->GetWidth();
09561 break;
09562 case eGENVAR_REF:
09563 n->width = (!n->Arg<CGenvar*>(0)->IsWidthEvaluateable()&&suppressErrorMessages) ? 0 : n->Arg<CGenvar*>(0)->GetWidth();
09564 break;
09565 case eRANGE:
09566 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());
09567 break;
09568 case eSLICE:
09569 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());
09570 break;
09571 case ePSLICE:
09572 n->width = ((info->error |= !n->Arg<CNode*>(1)->IsEvaluateable())&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(1)->EvalINT32();
09573 break;
09574 case eMSLICE:
09575 n->width = ((info->error |= !n->Arg<CNode*>(1)->IsEvaluateable())&&suppressErrorMessages) ? 0 : n->Arg<CNode*>(1)->EvalINT32();
09576 break;
09577 case eCVRI:
09578 n->width = 32;
09579 break;
09580 case eCVIR:
09581 n->width = 0;
09582 break;
09583 case eREP:
09584 n->width = cMUL(((info->error |= !n->Arg<CNode*>(0)->IsEvaluateable())&&suppressErrorMessages) ? 0: n->Arg<CNode*>(0)->EvalINT32(),n->Arg<CNode*>(1)->width);
09585 break;
09586 case eCAT:
09587 n->width = cADD(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width);
09588 break;
09589 case eUCAT:
09590 n->width = n->Arg<CNode*>(0)->width;
09591 break;
09592 case eCOM:
09593 n->width = n->Arg<CNode*>(0)->width;
09594 break;
09595 case eNEG:
09596 n->width = n->Arg<CNode*>(0)->width;
09597 break;
09598 case eNOT:
09599 n->width = 1;
09600 break;
09601 case eGT:
09602 n->width = 1;
09603 break;
09604 case eGE:
09605 n->width = 1;
09606 break;
09607 case eLT:
09608 n->width = 1;
09609 break;
09610 case eLE:
09611 n->width = 1;
09612 break;
09613 case eLAND:
09614 n->width = 1;
09615 break;
09616 case eLOR:
09617 n->width = 1;
09618 break;
09619 case eCEQ:
09620 n->width = 1;
09621 break;
09622 case eCNE:
09623 n->width = 1;
09624 break;
09625 case eEQ:
09626 n->width = 1;
09627 break;
09628 case eNE:
09629 n->width = 1;
09630 break;
09631 case eRAND:
09632 n->width = 1;
09633 break;
09634 case eRNAND:
09635 n->width = 1;
09636 break;
09637 case eROR:
09638 n->width = 1;
09639 break;
09640 case eRNOR:
09641 n->width = 1;
09642 break;
09643 case eRXOR:
09644 n->width = 1;
09645 break;
09646 case eRXNOR:
09647 n->width = 1;
09648 break;
09649 case eHOOK:
09650 n->width = cMAX(n->Arg<CNode*>(1)->width,n->Arg<CNode*>(2)->width);
09651 break;
09652 case eMTM:
09653 n->width = cMAX(n->Arg<CNode*>(0)->width,n->Arg<CNode*>(1)->width,n->Arg<CNode*>(2)->width);
09654 break;
09655 case eEXTERNAL_REF:
09656 n->width = External::Width(n->Arg<CSymbol*>(0));
09657 break;
09658 case eATTRIBUTE:
09659 n->width = 0;
09660 break;
09661 case eMACRO_EXPR:
09662 n->width = n->Arg<CNode*>(1)->width;
09663 break;
09664 }
09665
09666
09667
09668
09669 n->FixedWidth(1);
09670 int operandWidth = -1;
09671 for( int i = 0; i < n->ArgCount(); i++ ) {
09672 if( ((nodeMask>>i)&1) && n->Arg<CNode*>(i) ) {
09673 int widthFixed = n->Arg<CNode*>(i)->WidthFixed() ||
09674 n->Arg<CNode*>(i)->FixedWidth();
09675
09676 if( n->ConditionalWiden() && !widthFixed ) {
09677 n->FixedWidth( 0 );
09678 break;
09679 } else if( !widthFixed ) {
09680 n->FixedWidth( 0 );
09681 break;
09682 } else {
09683 int w = n->Arg<CNode*>(i)->width;
09684 if( operandWidth != w ) {
09685 if( operandWidth >= 0 ) {
09686 n->FixedWidth( 0 );
09687 break;
09688 }
09689 operandWidth = w;
09690 }
09691 }
09692 }
09693 }
09694 if( !conditionalWiden && nodeMask != 0 ) {
09695 n->FixedWidth( 0 );
09696 }
09697 }
09698
09699
09700
09701
09702
09703
09704
09705
09706
09707
09708 CNode* CNode::FixBits( INT32 newWidth, NodeType_t newType )
09709 {
09710
09711 int calculateMax = 0;
09712 int realOp = 0;
09713 int conditionalWiden = ConditionalWiden();
09714 unsigned nodeMask = NodeMask();
09715 unsigned scalarMask = 0;
09716 unsigned selfDeterminedMask = 0;
09717 switch( GetOp() ) {
09718 case eERROR:
09719 realOp = 0;
09720 break;
09721 case eVCONSTANT:
09722 realOp = 0;
09723 break;
09724 case eRCONSTANT:
09725 realOp = 0;
09726 break;
09727 case eCOMMENT:
09728 realOp = 0;
09729 break;
09730 case eVRQ:
09731 realOp = 0;
09732 break;
09733 case ePRAGMA:
09734 realOp = 0;
09735 break;
09736 case eELIST:
09737 realOp = 0;
09738 selfDeterminedMask = nodeMask;
09739 break;
09740 case eWIDTH:
09741 realOp = 0;
09742 selfDeterminedMask = nodeMask;
09743 break;
09744 case eNOP:
09745 realOp = 0;
09746 break;
09747 case eSUB:
09748 realOp = 1;
09749 break;
09750 case eMUL:
09751 realOp = 1;
09752 break;
09753 case eDIV:
09754 realOp = 1;
09755 break;
09756 case ePOW:
09757 realOp = 1;
09758 selfDeterminedMask = 1<<1;
09759 break;
09760 case eADD:
09761 realOp = 1;
09762 break;
09763 case eLSH:
09764 realOp = 0;
09765 selfDeterminedMask = 1<<1;
09766 break;
09767 case eRSH:
09768 realOp = 0;
09769 selfDeterminedMask = 1<<1;
09770 break;
09771 case eLSHA:
09772 realOp = 0;
09773 selfDeterminedMask = 1<<1;
09774 break;
09775 case eRSHA:
09776 realOp = 0;
09777 selfDeterminedMask = 1<<1;
09778 break;
09779 case eMOD:
09780 realOp = 0;
09781 break;
09782 case eOR:
09783 realOp = 0;
09784 break;
09785 case eAND:
09786 realOp = 0;
09787 break;
09788 case eANDANDAND:
09789 realOp = 0;
09790 break;
09791 case eXOR:
09792 realOp = 0;
09793 break;
09794 case eXNOR:
09795 realOp = 0;
09796 break;
09797 case eINSTANCE_REF:
09798 realOp = 0;
09799 break;
09800 case eGATE_REF:
09801 realOp = 0;
09802 break;
09803 case eTASK_ENABLE:
09804 realOp = 0;
09805 break;
09806 case eSYSTASK_CALL:
09807 realOp = 0;
09808 selfDeterminedMask = nodeMask;
09809 break;
09810 case eTIMING_CALL:
09811 realOp = 0;
09812 break;
09813 case eFUNCTION_CALL:
09814 realOp = 0;
09815 selfDeterminedMask = nodeMask;
09816 break;
09817 case eARRAY:
09818 realOp = 0;
09819 selfDeterminedMask = 1<<1;
09820 break;
09821 case eNET_REF:
09822 realOp = 0;
09823 break;
09824 case eREG_REF:
09825 realOp = 0;
09826 break;
09827 case eREAL_REF:
09828 realOp = 0;
09829 break;
09830 case ePARAM_REF:
09831 realOp = 0;
09832 break;
09833 case ePORT_REF:
09834 realOp = 0;
09835 break;
09836 case eFWD_REF:
09837 realOp = 0;
09838 break;
09839 case eEVENT_REF:
09840 realOp = 0;
09841 break;
09842 case eGENVAR_REF:
09843 realOp = 0;
09844 break;
09845 case eNET_DECL:
09846 realOp = 0;
09847 break;
09848 case eREG_DECL:
09849 realOp = 0;
09850 break;
09851 case eREAL_DECL:
09852 realOp = 0;
09853 break;
09854 case ePARAM_DECL:
09855 realOp = 0;
09856 break;
09857 case eSPECPARAM_DECL:
09858 realOp = 0;
09859 break;
09860 case ePORT_DECL:
09861 realOp = 0;
09862 break;
09863 case eEVENT_DECL:
09864 realOp = 0;
09865 break;
09866 case eGENVAR_DECL:
09867 realOp = 0;
09868 break;
09869 case eLIST:
09870 realOp = 0;
09871 break;
09872 case eRANGE:
09873 realOp = 0;
09874 selfDeterminedMask = nodeMask;
09875 break;
09876 case eSLICE:
09877 realOp = 0;
09878 selfDeterminedMask = nodeMask;
09879 break;
09880 case ePSLICE:
09881 realOp = 0;
09882 selfDeterminedMask = nodeMask;
09883 break;
09884 case eMSLICE:
09885 realOp = 0;
09886 selfDeterminedMask = nodeMask;
09887 break;
09888 case eCVRI:
09889 realOp = 0;
09890 selfDeterminedMask = nodeMask;
09891 break;
09892 case eCVIR:
09893 realOp = 0;
09894 selfDeterminedMask = nodeMask;
09895 break;
09896 case eREP:
09897 realOp = 0;
09898 selfDeterminedMask = nodeMask;
09899 break;
09900 case eCAT:
09901 realOp = 0;
09902 selfDeterminedMask = nodeMask;
09903 break;
09904 case eUCAT:
09905 realOp = 0;
09906 selfDeterminedMask = nodeMask;
09907 break;
09908 case eCOM:
09909 realOp = 0;
09910 break;
09911 case eNEG:
09912 realOp = 0;
09913 break;
09914 case eNOT:
09915 realOp = 0;
09916 scalarMask = 1;
09917 break;
09918 case eGT:
09919 realOp = 0;
09920 calculateMax = 1;
09921 break;
09922 case eGE:
09923 realOp = 0;
09924 calculateMax = 1;
09925 break;
09926 case eLT:
09927 realOp = 0;
09928 calculateMax = 1;
09929 break;
09930 case eLE:
09931 realOp = 0;
09932 calculateMax = 1;
09933 break;
09934 case eLAND:
09935 realOp = 0;
09936 scalarMask = 3;
09937 break;
09938 case eLOR:
09939 realOp = 0;
09940 scalarMask = 3;
09941 break;
09942 case eCEQ:
09943 realOp = 0;
09944 calculateMax = 1;
09945 break;
09946 case eCNE:
09947 realOp = 0;
09948 calculateMax = 1;
09949 break;
09950 case eEQ:
09951 realOp = 0;
09952 calculateMax = 1;
09953 break;
09954 case eNE:
09955 realOp = 0;
09956 calculateMax = 1;
09957 break;
09958 case eRAND:
09959 realOp = 0;
09960 selfDeterminedMask = nodeMask;
09961 break;
09962 case eRNAND:
09963 realOp = 0;
09964 selfDeterminedMask = nodeMask;
09965 break;
09966 case eROR:
09967 realOp = 0;
09968 selfDeterminedMask = nodeMask;
09969 break;
09970 case eRNOR:
09971 realOp = 0;
09972 selfDeterminedMask = nodeMask;
09973 break;
09974 case eRXOR:
09975 realOp = 0;
09976 selfDeterminedMask = nodeMask;
09977 break;
09978 case eRXNOR:
09979 realOp = 0;
09980 selfDeterminedMask = nodeMask;
09981 break;
09982 case eHOOK:
09983 realOp = 1;
09984 scalarMask = 1;
09985 break;
09986 case eINIT:
09987 realOp = 0;
09988 break;
09989 case eALWAYS:
09990 realOp = 0;
09991 break;
09992 case eEVENT:
09993 realOp = 0;
09994 break;
09995 case eBLOCK_REF:
09996 realOp = 0;
09997 break;
09998 case eSPECIFY_REF:
09999 realOp = 0;
10000 break;
10001 case eASSIGN:
10002 realOp = 0;
10003 break;
10004 case eFORCE:
10005 realOp = 0;
10006 break;
10007 case eRELEASE:
10008 realOp = 0;
10009 break;
10010 case eNBASSIGN:
10011 realOp = 0;
10012 break;
10013 case ePOSEDGE:
10014 realOp = 0;
10015 break;
10016 case eNEGEDGE:
10017 realOp = 0;
10018 break;
10019 case eEDGE:
10020 realOp = 0;
10021 break;
10022 case eEVOR:
10023 realOp = 0;
10024 break;
10025 case eDELAY:
10026 realOp = 0;
10027 break;
10028 case eMTM:
10029 realOp = 1;
10030 break;
10031 case eIF:
10032 realOp = 0;
10033 break;
10034 case eFOREVER:
10035 realOp = 0;
10036 break;
10037 case eREPEAT:
10038 realOp = 0;
10039 break;
10040 case eWHILE:
10041 realOp = 0;
10042 break;
10043 case eWAIT:
10044 realOp = 0;
10045 break;
10046 case eFOR:
10047 realOp = 0;
10048 break;
10049 case eCASE:
10050 realOp = 0;
10051 break;
10052 case eCASEX:
10053 realOp = 0;
10054 break;
10055 case eCASEZ:
10056 realOp = 0;
10057 break;
10058 case eCASEITEM:
10059 realOp = 0;
10060 break;
10061 case eCASSIGN:
10062 realOp = 0;
10063 break;
10064 case eARG:
10065 realOp = 0;
10066 break;
10067 case eFUNCTION_DEF:
10068 realOp = 0;
10069 break;
10070 case eMODULE_DEF:
10071 realOp = 0;
10072 break;
10073 case eREPEAT_CONTROL:
10074 realOp = 0;
10075 break;
10076 case eDELAY_CONTROL:
10077 realOp = 0;
10078 break;
10079 case eEVENT_CONTROL:
10080 realOp = 0;
10081 break;
10082 case eEXTERNAL_REF:
10083 realOp = 0;
10084 break;
10085 case ePORT_DEF:
10086 realOp = 0;
10087 break;
10088 case eDEFPARAM:
10089 realOp = 0;
10090 break;
10091 case ePATH:
10092 realOp = 0;
10093 break;
10094 case ePATH_ASSIGN:
10095 realOp = 0;
10096 break;
10097 case eIFNONE_PATH_ASSIGN:
10098 realOp = 0;
10099 break;
10100 case eTRIGGER:
10101 realOp = 0;
10102 break;
10103 case ePASSIGN:
10104 realOp = 0;
10105 break;
10106 case eDEASSIGN:
10107 realOp = 0;
10108 break;
10109 case eDISABLE:
10110 realOp = 0;
10111 break;
10112 case eATTRIBUTE:
10113 realOp = 0;
10114 break;
10115 case eGIF:
10116 realOp = 0;
10117 break;
10118 case eGFOR:
10119 realOp = 0;
10120 break;
10121 case eGCASE:
10122 realOp = 0;
10123 break;
10124 case eTABLE:
10125 realOp = 0;
10126 break;
10127 case eTABLE_ENTRY:
10128 realOp = 0;
10129 break;
10130 case eTABLE_SYMBOL:
10131 realOp = 0;
10132 break;
10133 case ePORTLIST_END:
10134 realOp = 0;
10135 break;
10136 case eMACRO_EXPR:
10137 realOp = 0;
10138 break;
10139 default:
10140 MASSERT( FALSE );
10141 }
10142
10143
10144
10145 unsigned realMask = 0;
10146 unsigned forceRealMask = 0;
10147 int widthsDiffer = 0;
10148 int originalWidth = width;
10149 for( int i = 0; i < ArgCount(); i++ ) {
10150 if( ((nodeMask>>i)&1) && Arg<CNode*>(i)->type == eR ) {
10151 realMask |= 1<<i;
10152 }
10153 if( ((nodeMask>>i)&1) &&
10154 Arg<CNode*>(i)->type != eR &&
10155 (Arg<CNode*>(i)->GetOp() != eVCONSTANT ||
10156 Arg<CNode*>(i)->width != width) ) {
10157 widthsDiffer = 1;
10158 }
10159 }
10160
10161
10162
10163
10164 if( newType == eU && newWidth == 0 ) {
10165 newType = type;
10166 newWidth = width;
10167
10168
10169
10170
10171 } else if( (newType == eB || newType == eS || newType == eU) &&
10172 (type == eB || type == eS) ) {
10173 if( newWidth > width ) {
10174 width = newWidth;
10175 }
10176 if( newType == eU ) {
10177 newType = type;
10178 }
10179 }
10180
10181 MASSERT( newType != eR || newWidth == 0 );
10182 MASSERT( newType != eE || newWidth == 0 );
10183
10184
10185
10186
10187
10188 if( realMask ) {
10189 forceRealMask = (~realMask & nodeMask);
10190 }
10191
10192
10193
10194
10195
10196 int convertWidth = conditionalWiden && FixedWidth();
10197 if( convertWidth ) {
10198 width = originalWidth;
10199 }
10200 if( newType == eB && type == eS ) {
10201 type = eB;
10202 }
10203
10204
10205
10206 int cWidth = width;
10207 NodeType_t cType = type;
10208 if( calculateMax ) {
10209 cType = eS;
10210 int max = 0;
10211 int foundReal = 0;
10212 int foundUnsigned = 0;
10213 for( int i = 0; i < ArgCount(); i++ ) {
10214 if( (nodeMask>>i)&1 ) {
10215 switch( Arg<CNode*>(i)->type ) {
10216 case eB:
10217 foundUnsigned = 1;
10218 break;
10219 case eR:
10220 foundReal = 1;
10221 break;
10222 }
10223 if( Arg<CNode*>(i)->width > max ) {
10224 max = Arg<CNode*>(i)->width;
10225 }
10226 }
10227 }
10228 if( foundReal ) {
10229 cWidth = 0;
10230 cType = eR;
10231 } else if( foundUnsigned ) {
10232 cType = eB;
10233 cWidth = max;
10234 } else {
10235 cWidth = max;
10236 }
10237 }
10238
10239
10240
10241
10242 for( int i = 0; i < ArgCount(); i++ ) {
10243 if( (nodeMask>>i)&1 ) {
10244 if( (scalarMask>>i)&1 ) {
10245 if( Arg<CNode*>(i)->type == eR ) {
10246 CNode* node;
10247 Arg<CNode*>(i) = cNE( Arg<CNode*>(i), cREAL(0), &loc );
10248 Arg<CNode*>(i)->LabelBits();
10249 } else if( type == eR ) {
10250
10251 CNode* node;
10252 Arg<CNode*>(i) = cCNE( Arg<CNode*>(i), cINT32(0), &loc );
10253 Arg<CNode*>(i)->LabelBits();
10254 }
10255 Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eU );
10256 } else if( (forceRealMask>>i)&1 ) {
10257 Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eR );
10258 } else if( (selfDeterminedMask>>i)&1 ) {
10259 Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( 0, eU );
10260 } else {
10261 Arg<CNode*>(i) = Arg<CNode*>(i)->FixBits( cWidth, cType );
10262 }
10263 }
10264 }
10265
10266
10267
10268
10269
10270
10271 if( newType != eR && convertWidth ) {
10272 CNode* nn = cWIDTH(cINT32(newWidth), this);
10273 nn->width = newWidth;
10274 nn->type = type;
10275 return nn;
10276 }
10277 if( newType == eR && (type == eB || type == eS) ) {
10278 CNode* nn = cCVIR( this );
10279 nn->width = 0;
10280 nn->type = eR;
10281 return nn;
10282
10283 } else if( (newType == eB || newType == eS) && type == eR ) {
10284 CNode* nn = cCVRI( this );
10285 nn->width = newWidth;
10286 nn->type = newType;
10287 return nn;
10288 }
10289
10290 return this;
10291 }
10292
10293
10294
10295
10296
10297 void CNode::Dump( FILE* f )
10298 {
10299 switch( GetOp() ) {
10300 case eERROR:
10301 fprintf( f, "???" );
10302 break;
10303 case eVCONSTANT:
10304 fprintf( f, "%s", Arg<CVector*>(0)->GetVString() );
10305 break;
10306 case eRCONSTANT:
10307 fprintf( f, "%s", (char*)Arg<char*>(0) );
10308 break;
10309 case eELIST:
10310 fprintf( f, "" );
10311 Arg<CNode*>(0)->Dump( f );
10312 fprintf( f, "," );
10313 Arg<CNode*>(1)->Dump( f );
10314 fprintf( f, "" );
10315 break;
10316 case eWIDTH:
10317 fprintf( f, "WIDTH(" );
10318 fprintf( f, "%s", type==eS ? "S" : "U" );
10319 fprintf( f, "," );
10320 fprintf( f, "%d", width );
10321 fprintf( f, "," );
10322 Arg<CNode*>(0)->Dump( f );
10323 fprintf( f, "," );
10324 Arg<CNode*>(1)->Dump( f );
10325 fprintf( f, ")" );
10326 break;
10327 case eSUB:
10328 fprintf( f, "(" );
10329 Arg<CNode*>(0)->Dump( f );
10330 fprintf( f, ")-(" );
10331 Arg<CNode*>(1)->Dump( f );
10332 fprintf( f, ")" );
10333 break;
10334 case eMUL:
10335 fprintf( f, "(" );
10336 Arg<CNode*>(0)->Dump( f );
10337 fprintf( f, ")*(" );
10338 Arg<CNode*>(1)->Dump( f );
10339 fprintf( f, ")" );
10340 break;
10341 case eDIV:
10342 fprintf( f, "(" );
10343 Arg<CNode*>(0)->Dump( f );
10344 fprintf( f, ")/(" );
10345 Arg<CNode*>(1)->Dump( f );
10346 fprintf( f, ")" );
10347 break;
10348 case ePOW:
10349 fprintf( f, "(" );
10350 Arg<CNode*>(0)->Dump( f );
10351 fprintf( f, ")**(" );
10352 Arg<CNode*>(1)->Dump( f );
10353 fprintf( f, ")" );
10354 break;
10355 case eADD:
10356 fprintf( f, "(" );
10357 Arg<CNode*>(0)->Dump( f );
10358 fprintf( f, ")+(" );
10359 Arg<CNode*>(1)->Dump( f );
10360 fprintf( f, ")" );
10361 break;
10362 case eLSH:
10363 fprintf( f, "(" );
10364 Arg<CNode*>(0)->Dump( f );
10365 fprintf( f, ")<<(" );
10366 Arg<CNode*>(1)->Dump( f );
10367 fprintf( f, ")" );
10368 break;
10369 case eRSH:
10370 fprintf( f, "(" );
10371 Arg<CNode*>(0)->Dump( f );
10372 fprintf( f, ")>>(" );
10373 Arg<CNode*>(1)->Dump( f );
10374 fprintf( f, ")" );
10375 break;
10376 case eLSHA:
10377 fprintf( f, "(" );
10378 Arg<CNode*>(0)->Dump( f );
10379 fprintf( f, ")<<<(" );
10380 Arg<CNode*>(1)->Dump( f );
10381 fprintf( f, ")" );
10382 break;
10383 case eRSHA:
10384 fprintf( f, "(" );
10385 Arg<CNode*>(0)->Dump( f );
10386 fprintf( f, ")>>>(" );
10387 Arg<CNode*>(1)->Dump( f );
10388 fprintf( f, ")" );
10389 break;
10390 case eMOD:
10391 fprintf( f, "(" );
10392 Arg<CNode*>(0)->Dump( f );
10393 fprintf( f, ")%%(" );
10394 Arg<CNode*>(1)->Dump( f );
10395 fprintf( f, ")" );
10396 break;
10397 case eOR:
10398 fprintf( f, "(" );
10399 Arg<CNode*>(0)->Dump( f );
10400 fprintf( f, ")|(" );
10401 Arg<CNode*>(1)->Dump( f );
10402 fprintf( f, ")" );
10403 break;
10404 case eAND:
10405 fprintf( f, "(" );
10406 Arg<CNode*>(0)->Dump( f );
10407 fprintf( f, ")&(" );
10408 Arg<CNode*>(1)->Dump( f );
10409 fprintf( f, ")" );
10410 break;
10411 case eANDANDAND:
10412 fprintf( f, "(" );
10413 Arg<CNode*>(0)->Dump( f );
10414 fprintf( f, ")&&&(" );
10415 Arg<CNode*>(1)->Dump( f );
10416 fprintf( f, ")" );
10417 break;
10418 case eXOR:
10419 fprintf( f, "(" );
10420 Arg<CNode*>(0)->Dump( f );
10421 fprintf( f, ")^(" );
10422 Arg<CNode*>(1)->Dump( f );
10423 fprintf( f, ")" );
10424 break;
10425 case eXNOR:
10426 fprintf( f, "(" );
10427 Arg<CNode*>(0)->Dump( f );
10428 fprintf( f, ")~^(" );
10429 Arg<CNode*>(1)->Dump( f );
10430 fprintf( f, ")" );
10431 break;
10432 case eFUNCTION_CALL:
10433 fprintf( f, "" );
10434 fprintf( f, "%s", Arg<CSymbol*>(0)->GetName() );
10435 fprintf( f, "(" );
10436 Arg<CNode*>(1)->Dump( f );
10437 fprintf( f, ")" );
10438 break;
10439 case eARRAY:
10440 fprintf( f, "" );
10441 Arg<CNode*>(0)->Dump( f );
10442 fprintf( f, "[" );
10443 Arg<CNode*>(1)->Dump( f );
10444 fprintf( f, "]" );
10445 break;
10446 case eNET_REF:
10447 fprintf( f, "%s", Arg<CNet*>(0)->GetName() );
10448 break;
10449 case eREG_REF:
10450 fprintf( f, "%s", Arg<CReg*>(0)->GetName() );
10451 break;
10452 case eREAL_REF:
10453 fprintf( f, "%s", Arg<CReal*>(0)->GetName() );
10454 break;
10455 case ePARAM_REF:
10456 fprintf( f, "%s", Arg<CParam*>(0)->GetName() );
10457 break;
10458 case ePORT_REF:
10459 fprintf( f, "%s", Arg<CPort*>(0)->GetName() );
10460 break;
10461 case eFWD_REF:
10462 fprintf( f, "%s", Arg<CFref*>(0)->GetName() );
10463 break;
10464 case eGENVAR_REF:
10465 fprintf( f, "%s", Arg<CGenvar*>(0)->GetName() );
10466 break;
10467 case eLIST:
10468 fprintf( f, "(" );
10469 Arg<CNode*>(0)->Dump( f );
10470 fprintf( f, "," );
10471 Arg<CNode*>(1)->Dump( f );
10472 fprintf( f, ")" );
10473 break;
10474 case eRANGE:
10475 fprintf( f, "" );
10476 Arg<CNode*>(0)->Dump( f );
10477 fprintf( f, ":" );
10478 Arg<CNode*>(1)->Dump( f );
10479 fprintf( f, "" );
10480 break;
10481 case eSLICE:
10482 fprintf( f, "" );
10483 Arg<CNode*>(0)->Dump( f );
10484 fprintf( f, ":" );
10485 Arg<CNode*>(1)->Dump( f );
10486 fprintf( f, "" );
10487 break;
10488 case ePSLICE:
10489 fprintf( f, "" );
10490 Arg<CNode*>(0)->Dump( f );
10491 fprintf( f, "+:" );
10492 Arg<CNode*>(1)->Dump( f );
10493 fprintf( f, "" );
10494 break;
10495 case eMSLICE:
10496 fprintf( f, "" );
10497 Arg<CNode*>(0)->Dump( f );
10498 fprintf( f, "-:" );
10499 Arg<CNode*>(1)->Dump( f );
10500 fprintf( f, "" );
10501 break;
10502 case eCVRI:
10503 fprintf( f, "CVRI(" );
10504 Arg<CNode*>(0)->Dump( f );
10505 fprintf( f, ")" );
10506 break;
10507 case eCVIR:
10508 fprintf( f, "CVIR(" );
10509 Arg<CNode*>(0)->Dump( f );
10510 fprintf( f, ")" );
10511 break;
10512 case eREP:
10513 fprintf( f, "{" );
10514 Arg<CNode*>(0)->Dump( f );
10515 fprintf( f, "{" );
10516 Arg<CNode*>(1)->Dump( f );
10517 fprintf( f, "}}" );
10518 break;
10519 case eCAT:
10520 fprintf( f, "{" );
10521 Arg<CNode*>(0)->Dump( f );
10522 fprintf( f, "," );
10523 Arg<CNode*>(1)->Dump( f );
10524 fprintf( f, "}" );
10525 break;
10526 case eUCAT:
10527 fprintf( f, "{" );
10528 Arg<CNode*>(0)->Dump( f );
10529 fprintf( f, "}" );
10530 break;
10531 case eCOM:
10532 fprintf( f, "~(" );
10533 Arg<CNode*>(0)->Dump( f );
10534 fprintf( f, ")" );
10535 break;
10536 case eNEG:
10537 fprintf( f, "-(" );
10538 Arg<CNode*>(0)->Dump( f );
10539 fprintf( f, ")" );
10540 break;
10541 case eNOT:
10542 fprintf( f, "!(" );
10543 Arg<CNode*>(0)->Dump( f );
10544 fprintf( f, ")" );
10545 break;
10546 case eGT:
10547 fprintf( f, "(" );
10548 Arg<CNode*>(0)->Dump( f );
10549 fprintf( f, ")>(" );
10550 Arg<CNode*>(1)->Dump( f );
10551 fprintf( f, ")" );
10552 break;
10553 case eGE:
10554 fprintf( f, "(" );
10555 Arg<CNode*>(0)->Dump( f );
10556 fprintf( f, ")>=(" );
10557 Arg<CNode*>(1)->Dump( f );
10558 fprintf( f, ")" );
10559 break;
10560 case eLT:
10561 fprintf( f, "(" );
10562 Arg<CNode*>(0)->Dump( f );
10563 fprintf( f, ")<(" );
10564 Arg<CNode*>(1)->Dump( f );
10565 fprintf( f, ")" );
10566 break;
10567 case eLE:
10568 fprintf( f, "(" );
10569 Arg<CNode*>(0)->Dump( f );
10570 fprintf( f, ")<=(" );
10571 Arg<CNode*>(1)->Dump( f );
10572 fprintf( f, ")" );
10573 break;
10574 case eLAND:
10575 fprintf( f, "(" );
10576 Arg<CNode*>(0)->Dump( f );
10577 fprintf( f, ")&&(" );
10578 Arg<CNode*>(1)->Dump( f );
10579 fprintf( f, ")" );
10580 break;
10581 case eLOR:
10582 fprintf( f, "(" );
10583 Arg<CNode*>(0)->Dump( f );
10584 fprintf( f, ")||(" );
10585 Arg<CNode*>(1)->Dump( f );
10586 fprintf( f, ")" );
10587 break;
10588 case eCEQ:
10589 fprintf( f, "(" );
10590 Arg<CNode*>(0)->Dump( f );
10591 fprintf( f, ")===(" );
10592 Arg<CNode*>(1)->Dump( f );
10593 fprintf( f, ")" );
10594 break;
10595 case eCNE:
10596 fprintf( f, "(" );
10597 Arg<CNode*>(0)->Dump( f );
10598 fprintf( f, ")!==(" );
10599 Arg<CNode*>(1)->Dump( f );
10600 fprintf( f, ")" );
10601 break;
10602 case eEQ:
10603 fprintf( f, "(" );
10604 Arg<CNode*>(0)->Dump( f );
10605 fprintf( f, ")==(" );
10606 Arg<CNode*>(1)->Dump( f );
10607 fprintf( f, ")" );
10608 break;
10609 case eNE:
10610 fprintf( f, "(" );
10611 Arg<CNode*>(0)->Dump( f );
10612 fprintf( f, ")!=(" );
10613 Arg<CNode*>(1)->Dump( f );
10614 fprintf( f, ")" );
10615 break;
10616 case eRAND:
10617 fprintf( f, "&(" );
10618 Arg<CNode*>(0)->Dump( f );
10619 fprintf( f, ")" );
10620 break;
10621 case eRNAND:
10622 fprintf( f, "~&(" );
10623 Arg<CNode*>(0)->Dump( f );
10624 fprintf( f, ")" );
10625 break;
10626 case eROR:
10627 fprintf( f, "|(" );
10628 Arg<CNode*>(0)->Dump( f );
10629 fprintf( f, ")" );
10630 break;
10631 case eRNOR:
10632 fprintf( f, "~|(" );
10633 Arg<CNode*>(0)->Dump( f );
10634 fprintf( f, ")" );
10635 break;
10636 case eRXOR:
10637 fprintf( f, "^(" );
10638 Arg<CNode*>(0)->Dump( f );
10639 fprintf( f, ")" );
10640 break;
10641 case eRXNOR:
10642 fprintf( f, "~^(" );
10643 Arg<CNode*>(0)->Dump( f );
10644 fprintf( f, ")" );
10645 break;
10646 case eHOOK:
10647 fprintf( f, "(" );
10648 Arg<CNode*>(0)->Dump( f );
10649 fprintf( f, ")?(" );
10650 Arg<CNode*>(1)->Dump( f );
10651 fprintf( f, "):(" );
10652 Arg<CNode*>(2)->Dump( f );
10653 fprintf( f, ")" );
10654 break;
10655 case eINIT:
10656 fprintf( f, "INIT(*)" );
10657 break;
10658 case ePOSEDGE:
10659 fprintf( f, "POSEDGE(" );
10660 Arg<CNode*>(0)->Dump( f );
10661 fprintf( f, ")" );
10662 break;
10663 case eNEGEDGE:
10664 fprintf( f, "NEGEDGE(" );
10665 Arg<CNode*>(0)->Dump( f );
10666 fprintf( f, ")" );
10667 break;
10668 case eEDGE:
10669 fprintf( f, "EDGE(" );
10670 Arg<CNode*>(0)->Dump( f );
10671 fprintf( f, ")" );
10672 break;
10673 case eMTM:
10674 fprintf( f, "(" );
10675 Arg<CNode*>(0)->Dump( f );
10676 fprintf( f, ":" );
10677 Arg<CNode*>(1)->Dump( f );
10678 fprintf( f, ":" );
10679 Arg<CNode*>(2)->Dump( f );
10680 fprintf( f, ")" );
10681 break;
10682 case eMACRO_EXPR:
10683 fprintf( f, "`" );
10684 Arg<CNode*>(0)->Dump( f );
10685 fprintf( f, "<" );
10686 Arg<CNode*>(1)->Dump( f );
10687 fprintf( f, ">" );
10688 break;
10689 case eCOMMENT:
10690 case eVRQ:
10691 case ePRAGMA:
10692 case eNOP:
10693 case eINSTANCE_REF:
10694 case eGATE_REF:
10695 case eTASK_ENABLE:
10696 case eSYSTASK_CALL:
10697 case eTIMING_CALL:
10698 case eEVENT_REF:
10699 case eNET_DECL:
10700 case eREG_DECL:
10701 case eREAL_DECL:
10702 case ePARAM_DECL:
10703 case eSPECPARAM_DECL:
10704 case ePORT_DECL:
10705 case eEVENT_DECL:
10706 case eGENVAR_DECL:
10707 case eALWAYS:
10708 case eEVENT:
10709 case eBLOCK_REF:
10710 case eSPECIFY_REF:
10711 case eASSIGN:
10712 case eFORCE:
10713 case eRELEASE:
10714 case eNBASSIGN:
10715 case eEVOR:
10716 case eDELAY:
10717 case eIF:
10718 case eFOREVER:
10719 case eREPEAT:
10720 case eWHILE:
10721 case eWAIT:
10722 case eFOR:
10723 case eCASE:
10724 case eCASEX:
10725 case eCASEZ:
10726 case eCASEITEM:
10727 case eCASSIGN:
10728 case eARG:
10729 case eFUNCTION_DEF:
10730 case eMODULE_DEF:
10731 case eREPEAT_CONTROL:
10732 case eDELAY_CONTROL:
10733 case eEVENT_CONTROL:
10734 case eEXTERNAL_REF:
10735 case ePORT_DEF:
10736 case eDEFPARAM:
10737 case ePATH:
10738 case ePATH_ASSIGN:
10739 case eIFNONE_PATH_ASSIGN:
10740 case eTRIGGER:
10741 case ePASSIGN:
10742 case eDEASSIGN:
10743 case eDISABLE:
10744 case eATTRIBUTE:
10745 case eGIF:
10746 case eGFOR:
10747 case eGCASE:
10748 case eTABLE:
10749 case eTABLE_ENTRY:
10750 case eTABLE_SYMBOL:
10751 case ePORTLIST_END:
10752 MASSERT( FALSE );
10753 break;
10754 }
10755 }
10756
10757 #endif // DEFINE_METHODS
10758
10759 #ifdef DEFINE_TEST_HARNESS
10760 void CNodeTestHarness()
10761 {
10762 for( int i = 0; i < 127; ++i ) {
10763 CNode* n = new(CNode::stack) CNode( NULL, (NodeOp_t)i );
10764 if( n->Precedence() != n->Precedence_1() ) {
10765 printf( "Fail %s\n", nodeOpName[i] );
10766 exit(1);
10767 }
10768 }
10769 }
10770 #endif // DEFINE_TEST_HARNESS