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