home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 40 / IOPROG_40.ISO / SOFT / NETFrameworkSDK.exe / comsdk.cab / samples1.exe / smc / toplist.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-23  |  11.5 KB  |  227 lines
  1. /*****************************************************************************/
  2. #ifndef TREEOP
  3. #error  Define TREEOP before including this file.
  4. #endif
  5. /*****************************************************************************/
  6. //
  7. //    Node enum
  8. //                   , token
  9. //                            ,  "Node name"
  10. //
  11. //
  12. //                                            ,ILcode
  13. //                                                       ,operator precedence
  14. //                                                          ,operKind
  15.  
  16. TREEOP(TN_ERROR      , tkNone,   "error"      ,CEE_NOP   , 0,TNK_NONE)
  17. TREEOP(TN_NONE       , tkNone,   "<none>"     ,CEE_NOP   , 0,TNK_NONE)
  18.  
  19. //-----------------------------------------------------------------------------
  20. //  Leaf nodes (i.e. these nodes have no sub-operands):
  21. //-----------------------------------------------------------------------------
  22.  
  23. TREEOP(TN_NAME       , tkNone,   "name"       ,CEE_NOP   , 0,TNK_LEAF)
  24. TREEOP(TN_THIS       , tkNone,   "this"       ,CEE_NOP   , 0,TNK_LEAF)
  25. TREEOP(TN_BASE       , tkNone,   "base"       ,CEE_NOP   , 0,TNK_LEAF)
  26. TREEOP(TN_DBGBRK     , tkNone,   "debugbreak" ,CEE_NOP   , 0,TNK_LEAF)
  27.  
  28. //-----------------------------------------------------------------------------
  29. //  Constant nodes:
  30. //-----------------------------------------------------------------------------
  31.  
  32. TREEOP(TN_CNS_INT    , tkNone,   "int const"  ,CEE_NOP   , 0,TNK_LEAF|TNK_CONST)
  33. TREEOP(TN_CNS_LNG    , tkNone,   "lng const"  ,CEE_NOP   , 0,TNK_LEAF|TNK_CONST)
  34. TREEOP(TN_CNS_FLT    , tkNone,   "flt const"  ,CEE_NOP   , 0,TNK_LEAF|TNK_CONST)
  35. TREEOP(TN_CNS_DBL    , tkNone,   "dbl const"  ,CEE_NOP   , 0,TNK_LEAF|TNK_CONST)
  36. TREEOP(TN_CNS_STR    , tkNone,   "str const"  ,CEE_NOP   , 0,TNK_LEAF|TNK_CONST)
  37. TREEOP(TN_NULL       , tkNone,   "null"       ,CEE_NOP   , 0,TNK_LEAF|TNK_CONST)
  38.  
  39. //-----------------------------------------------------------------------------
  40. //  Unary  operators (0 or 1 operands):
  41. //-----------------------------------------------------------------------------
  42.  
  43. TREEOP(TN_ADDROF     , tkAnd,    "&"          ,CEE_NOP   ,14,TNK_UNOP)
  44.  
  45. TREEOP(TN_NOT        , tkTilde,  "~"          ,CEE_NOP   ,14,TNK_UNOP)
  46. TREEOP(TN_LOG_NOT    , tkBang,   "!"          ,CEE_NOP   ,14,TNK_UNOP)
  47. TREEOP(TN_NOP        , tkAdd,    "unary +"    ,CEE_NOP   ,14,TNK_UNOP)
  48. TREEOP(TN_NEG        , tkSub,    "unary -"    ,CEE_NOP   ,14,TNK_UNOP)
  49. TREEOP(TN_THROW      , tkNone,   "throw"      ,CEE_NOP   ,14,TNK_UNOP)
  50.  
  51. TREEOP(TN_INC_POST   , tkInc,    "++ post"    ,CEE_NOP   ,14,TNK_UNOP)
  52. TREEOP(TN_DEC_POST   , tkDec,    "-- post"    ,CEE_NOP   ,14,TNK_UNOP)
  53. TREEOP(TN_INC_PRE    , tkInc,    "++ pre"     ,CEE_NOP   ,14,TNK_UNOP)
  54. TREEOP(TN_DEC_PRE    , tkDec,    "-- pre"     ,CEE_NOP   ,14,TNK_UNOP)
  55.  
  56. TREEOP(TN_TYPE       , tkNone,   "<type>"     ,CEE_NOP   , 0,TNK_UNOP)
  57. TREEOP(TN_TOKEN      , tkNone,   "<token>"    ,CEE_NOP   , 0,TNK_UNOP)
  58.  
  59. TREEOP(TN_INST_STUB  , tkNone,   "inst-stub"  ,CEE_NOP   , 0,TNK_UNOP)
  60.  
  61. //-----------------------------------------------------------------------------
  62. //  Binary operators (2 operands):
  63. //-----------------------------------------------------------------------------
  64.  
  65. TREEOP(TN_ADD        , tkAdd,    "+"          ,CEE_ADD   ,12,TNK_BINOP)
  66. TREEOP(TN_SUB        , tkSub,    "-"          ,CEE_SUB   ,12,TNK_BINOP)
  67. TREEOP(TN_MUL        , tkMul,    "*"          ,CEE_MUL   ,13,TNK_BINOP)
  68. TREEOP(TN_DIV        , tkDiv,    "/"          ,CEE_DIV   ,13,TNK_BINOP)
  69. TREEOP(TN_MOD        , tkPct,    "%"          ,CEE_REM   ,13,TNK_BINOP)
  70.  
  71. TREEOP(TN_AND        , tkAnd,    "&"          ,CEE_AND   , 7,TNK_BINOP|TNK_LOGOP)
  72. TREEOP(TN_XOR        , tkXor,    "^"          ,CEE_XOR   , 7,TNK_BINOP|TNK_LOGOP)
  73. TREEOP(TN_OR         , tkOr ,    "|"          ,CEE_OR    , 6,TNK_BINOP|TNK_LOGOP)
  74.  
  75. TREEOP(TN_LSH        , tkLsh,    "<<"         ,CEE_NOP   ,11,TNK_BINOP)
  76. TREEOP(TN_RSH        , tkRsh,    ">>"         ,CEE_NOP   ,11,TNK_BINOP)
  77. TREEOP(TN_RSZ        , tkRsz,    ">>>"        ,CEE_NOP   ,11,TNK_BINOP)
  78.  
  79. TREEOP(TN_EQ         , tkEQ,     "=="         ,CEE_BEQ   , 9,TNK_BINOP|TNK_RELOP)
  80. TREEOP(TN_NE         , tkNE,     "!="         ,CEE_BNE_UN, 9,TNK_BINOP|TNK_RELOP)
  81. TREEOP(TN_LT         , tkLT,     "<"          ,CEE_BLT   ,10,TNK_BINOP|TNK_RELOP)
  82. TREEOP(TN_LE         , tkLE,     "<="         ,CEE_BLE   ,10,TNK_BINOP|TNK_RELOP)
  83. TREEOP(TN_GE         , tkGE,     ">="         ,CEE_BGE   ,10,TNK_BINOP|TNK_RELOP)
  84. TREEOP(TN_GT         , tkGT,     ">"          ,CEE_BGT   ,10,TNK_BINOP|TNK_RELOP)
  85.  
  86. // NOTE: The "op=" varieties must appear in the same order as "op" above
  87.  
  88. TREEOP(TN_ASG        , tkAsg,    "="          ,CEE_NOP   , 2,TNK_BINOP|TNK_ASGOP)
  89. TREEOP(TN_ASG_ADD    , tkAsgAdd, "+="         ,CEE_ADD   , 2,TNK_BINOP|TNK_ASGOP)
  90. TREEOP(TN_ASG_SUB    , tkAsgSub, "-="         ,CEE_SUB   , 2,TNK_BINOP|TNK_ASGOP)
  91. TREEOP(TN_ASG_MUL    , tkAsgMul, "*="         ,CEE_MUL   , 2,TNK_BINOP|TNK_ASGOP)
  92. TREEOP(TN_ASG_DIV    , tkAsgDiv, "/="         ,CEE_DIV   , 2,TNK_BINOP|TNK_ASGOP)
  93. TREEOP(TN_ASG_MOD    , tkAsgMod, "%="         ,CEE_REM   , 2,TNK_BINOP|TNK_ASGOP)
  94.  
  95. TREEOP(TN_ASG_AND    , tkAsgAnd, "&="         ,CEE_AND   , 2,TNK_BINOP|TNK_ASGOP)
  96. TREEOP(TN_ASG_XOR    , tkAsgXor, "^="         ,CEE_XOR   , 2,TNK_BINOP|TNK_ASGOP)
  97. TREEOP(TN_ASG_OR     , tkAsgOr , "|="         ,CEE_OR    , 2,TNK_BINOP|TNK_ASGOP)
  98.  
  99. TREEOP(TN_ASG_LSH    , tkAsgLsh, "<<="        ,CEE_SHL   , 2,TNK_BINOP|TNK_ASGOP)
  100. TREEOP(TN_ASG_RSH    , tkAsgRsh, ">>="        ,CEE_SHR   , 2,TNK_BINOP|TNK_ASGOP)
  101. TREEOP(TN_ASG_RSZ    , tkAsgRsz, ">>>="       ,CEE_SHR_UN, 2,TNK_BINOP|TNK_ASGOP)
  102.  
  103. TREEOP(TN_ASG_CNC    , tkAsgCnc, "%%="        ,CEE_NOP   , 2,TNK_BINOP|TNK_ASGOP)
  104.  
  105. TREEOP(TN_COMMA      , tkNone,   ","          ,CEE_NOP   , 1,TNK_BINOP)
  106.  
  107. TREEOP(TN_QMARK      , tkQMark,  "?"          ,CEE_NOP   , 3,TNK_BINOP)
  108. TREEOP(TN_COLON      , tkColon,  ":"          ,CEE_NOP   , 3,TNK_BINOP)
  109.  
  110. TREEOP(TN_LOG_OR     , tkLogOr , "||"         ,CEE_NOP   , 4,TNK_BINOP)
  111. TREEOP(TN_LOG_AND    , tkLogAnd, "&&"         ,CEE_NOP   , 5,TNK_BINOP)
  112.  
  113. TREEOP(TN_ISTYPE     , tkISTYPE, "istype"     ,CEE_NOP   ,14,TNK_BINOP)
  114.  
  115. TREEOP(TN_INDEX      , tkNone,   "[]"         ,CEE_NOP   ,15,TNK_BINOP)
  116. TREEOP(TN_CALL       , tkNone,   "()"         ,CEE_NOP   ,15,TNK_BINOP)
  117. TREEOP(TN_ARROW      , tkNone,   "->"         ,CEE_NOP   ,12,TNK_BINOP)
  118.  
  119. TREEOP(TN_REFADDR    , tkREFADDR,"ref&"       ,CEE_NOP   , 0,TNK_BINOP)
  120.  
  121. //-----------------------------------------------------------------------------
  122. //  Other nodes that look like unary/binary operators:
  123. //-----------------------------------------------------------------------------
  124.  
  125. TREEOP(TN_IND        , tkMul,    "indir"      ,CEE_NOP   ,12,TNK_UNOP)   // is prec correct?
  126.  
  127. TREEOP(TN_NEW        , tkNone,   "new"        ,CEE_NOP   ,14,TNK_BINOP)
  128. TREEOP(TN_DELETE     , tkNone,   "delete"     ,CEE_NOP   ,14,TNK_UNOP)
  129.  
  130. TREEOP(TN_CONCAT     , tkNone,   "%%"         ,CEE_NOP   , 0,TNK_BINOP)
  131. TREEOP(TN_CONCAT_ASG , tkNone,   "%%="        ,CEE_NOP   , 0,TNK_BINOP|TNK_ASGOP)
  132.  
  133. TREEOP(TN_AND_NOSTR  , tkNone,   "math &"     ,CEE_NOP   , 0,TNK_BINOP)
  134. TREEOP(TN_ANA_NOSTR  , tkNone,   "math &="    ,CEE_NOP   , 0,TNK_BINOP|TNK_ASGOP)
  135.  
  136. TREEOP(TN_LIST       , tkNone,   "<list>"     ,CEE_NOP   , 0,TNK_BINOP)
  137.  
  138. TREEOP(TN_CAST       , tkNone,   "cast"       ,CEE_NOP   , 0,TNK_BINOP)
  139.  
  140. TREEOP(TN_CLASS      , tkNone,   "className"  ,CEE_NOP   , 0,TNK_BINOP)
  141.  
  142. TREEOP(TN_TRY        , tkNone,   "try"        ,CEE_NOP   , 0,TNK_BINOP)
  143. TREEOP(TN_CATCH      , tkNone,   "catch"      ,CEE_NOP   , 0,TNK_BINOP)
  144. TREEOP(TN_EXCEPT     , tkNone,   "except"     ,CEE_NOP   , 0,TNK_BINOP)
  145. TREEOP(TN_FINALLY    , tkNone,   "finally"    ,CEE_NOP   , 0,TNK_UNOP)
  146.  
  147. TREEOP(TN_DOT        , tkNone,   "."          ,CEE_NOP   , 0,TNK_BINOP)
  148. TREEOP(TN_DOT_NAME   , tkNone,   "name.name"  ,CEE_NOP   , 0,TNK_UNOP)
  149.  
  150. TREEOP(TN_GOTO       , tkNone,   "goto"       ,CEE_NOP   , 0,TNK_UNOP)
  151. TREEOP(TN_LABEL      , tkNone,   "label"      ,CEE_NOP   , 0,TNK_UNOP)
  152.  
  153. TREEOP(TN_ARR_INIT   , tkNone,   "arr init"   ,CEE_NOP   , 0,TNK_UNOP)
  154. TREEOP(TN_ARR_LEN    , tkNone,   "arr length" ,CEE_NOP   , 0,TNK_UNOP)
  155.  
  156. TREEOP(TN_SIZEOF     , tkSIZEOF, "sizeof"     ,CEE_NOP   , 0,TNK_UNOP)
  157. TREEOP(TN_TYPEOF     , tkTYPEOF, "typeof"     ,CEE_NOP   , 0,TNK_UNOP)
  158.  
  159. TREEOP(TN_BOX        , tkNone,   "box"        ,CEE_NOP   , 0,TNK_UNOP)
  160. TREEOP(TN_UNBOX      , tkNone,   "unbox"      ,CEE_NOP   , 0,TNK_UNOP)
  161.  
  162. //-----------------------------------------------------------------------------
  163. //  Statement operator nodes that have ordinary tree structure:
  164. //-----------------------------------------------------------------------------
  165.  
  166. TREEOP(TN_EXPR_STMT  , tkNone,   "stmtExpr"   ,CEE_NOP   , 0,TNK_UNOP)
  167.  
  168. TREEOP(TN_IF         , tkNone,   "if"         ,CEE_NOP   , 0,TNK_BINOP)
  169.  
  170. TREEOP(TN_DO         , tkNone,   "do"         ,CEE_NOP   , 0,TNK_BINOP)
  171. TREEOP(TN_FOR        , tkNone,   "for"        ,CEE_NOP   , 0,TNK_BINOP)
  172. TREEOP(TN_WHILE      , tkNone,   "while"      ,CEE_NOP   , 0,TNK_BINOP)
  173.  
  174. TREEOP(TN_EXCLUDE    , tkNone,   "excludeStmt",CEE_NOP   , 0,TNK_BINOP)
  175.  
  176. TREEOP(TN_BREAK      , tkNone,   "break"      ,CEE_NOP   , 0,TNK_UNOP)
  177. TREEOP(TN_CONTINUE   , tkNone,   "continue"   ,CEE_NOP   , 0,TNK_UNOP)
  178.  
  179. TREEOP(TN_SWITCH     , tkNone,   "switch"     ,CEE_NOP   , 0,TNK_BINOP)
  180. TREEOP(TN_CASE       , tkNone,   "case"       ,CEE_NOP   , 0,TNK_UNOP)
  181.  
  182. TREEOP(TN_RETURN     , tkNone,   "return"     ,CEE_NOP   , 0,TNK_BINOP)
  183.  
  184. TREEOP(TN_ASSERT     , tkNone,   "assert"     ,CEE_NOP   , 0,TNK_UNOP)
  185.  
  186. TREEOP(TN_VARARG_BEG , tkNone,   "vararg-beg" ,CEE_NOP   , 0,TNK_BINOP)
  187. TREEOP(TN_VARARG_GET , tkNone,   "vararg-get" ,CEE_NOP   , 0,TNK_BINOP)
  188.  
  189. //-----------------------------------------------------------------------------
  190. //  Statement operator nodes that have special fields:
  191. //-----------------------------------------------------------------------------
  192.  
  193. TREEOP(TN_NAMESPACE  , tkNone,   "namespace"  ,CEE_NOP   , 0,TNK_NONE)
  194. TREEOP(TN_ANY_SYM    , tkNone,   "qualname"   ,CEE_NOP   , 0,TNK_NONE)
  195. TREEOP(TN_LCL_SYM    , tkNone,   "lcl var"    ,CEE_NOP   , 0,TNK_NONE)
  196. TREEOP(TN_MEM_SYM    , tkNone,   "member"     ,CEE_NOP   , 0,TNK_NONE)
  197. TREEOP(TN_VAR_SYM    , tkNone,   "variable"   ,CEE_NOP   , 0,TNK_NONE)
  198. TREEOP(TN_BFM_SYM    , tkNone,   "bitfield"   ,CEE_NOP   , 0,TNK_NONE)
  199. TREEOP(TN_FNC_SYM    , tkNone,   "function"   ,CEE_NOP   , 0,TNK_NONE)
  200. TREEOP(TN_FNC_PTR    , tkNone,   "meth-ptr"   ,CEE_NOP   , 0,TNK_NONE)
  201. TREEOP(TN_PROPERTY   , tkNone,   "property"   ,CEE_NOP   , 0,TNK_NONE)
  202.  
  203. TREEOP(TN_BLOCK      , tkNone,   "{}"         ,CEE_NOP   , 0,TNK_NONE)
  204.  
  205. //-----------------------------------------------------------------------------
  206. //  Declaration nodes that have special fields:
  207. //-----------------------------------------------------------------------------
  208.  
  209. TREEOP(TN_VAR_DECL   , tkNone,   "var-decl"   ,CEE_NOP   , 0,TNK_NONE) // may form a loop
  210. TREEOP(TN_SLV_INIT   , tkNone,   "slv-init"   ,CEE_NOP   , 0,TNK_NONE)
  211.  
  212. //-----------------------------------------------------------------------------
  213. //  Declaration nodes:
  214. //-----------------------------------------------------------------------------
  215.  
  216. TREEOP(TN_DCL_VAR    , tkNone,   "varDecl"    ,CEE_NOP   , 0,TNK_NONE)
  217.  
  218. //-----------------------------------------------------------------------------
  219. //  Nodes that never actually appear in trees
  220. //-----------------------------------------------------------------------------
  221.  
  222. TREEOP(TN_DEFINED    , tkNone,   "defined"    ,CEE_NOP   , 0,TNK_NONE)
  223.  
  224. /*****************************************************************************/
  225. #undef  TREEOP
  226. /*****************************************************************************/
  227.