Interpreter.hpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #ifndef NDB_INTERPRETER_HPP
  14. #define NDB_INTERPRETER_HPP
  15. #include <ndb_types.h>
  16. class Interpreter {
  17. public:
  18.   inline static Uint32 mod4(Uint32 len){
  19.     return len + ((4 - (len & 3)) & 3);
  20.   }
  21.   
  22.   /**
  23.    * General Mnemonic format
  24.    *
  25.    * i = Instruction            -  5 Bits ( 0 - 5 ) max 63
  26.    * x = Register 1             -  3 Bits ( 6 - 8 ) max 7
  27.    * y = Register 2             -  3 Bits ( 9 -11 ) max 7
  28.    * b = Branch offset (only branches)
  29.    *
  30.    *           1111111111222222222233
  31.    * 01234567890123456789012345678901
  32.    * iiiiiixxxyyy    bbbbbbbbbbbbbbbb
  33.    *
  34.    *
  35.    */
  36.   /**
  37.    * Instructions
  38.    */
  39.   STATIC_CONST( READ_ATTR_INTO_REG    = 1 );
  40.   STATIC_CONST( WRITE_ATTR_FROM_REG   = 2 );
  41.   STATIC_CONST( LOAD_CONST_NULL       = 3 );
  42.   STATIC_CONST( LOAD_CONST16          = 4 );
  43.   STATIC_CONST( LOAD_CONST32          = 5 );
  44.   STATIC_CONST( LOAD_CONST64          = 6 );
  45.   STATIC_CONST( ADD_REG_REG           = 7 );
  46.   STATIC_CONST( SUB_REG_REG           = 8 );
  47.   STATIC_CONST( BRANCH                = 9 );
  48.   STATIC_CONST( BRANCH_REG_EQ_NULL    = 10 );
  49.   STATIC_CONST( BRANCH_REG_NE_NULL    = 11 );
  50.   STATIC_CONST( BRANCH_EQ_REG_REG     = 12 );
  51.   STATIC_CONST( BRANCH_NE_REG_REG     = 13 );
  52.   STATIC_CONST( BRANCH_LT_REG_REG     = 14 );
  53.   STATIC_CONST( BRANCH_LE_REG_REG     = 15 );
  54.   STATIC_CONST( BRANCH_GT_REG_REG     = 16 );
  55.   STATIC_CONST( BRANCH_GE_REG_REG     = 17 );
  56.   STATIC_CONST( EXIT_OK               = 18 );
  57.   STATIC_CONST( EXIT_REFUSE           = 19 );
  58.   STATIC_CONST( CALL                  = 20 );
  59.   STATIC_CONST( RETURN                = 21 );
  60.   STATIC_CONST( EXIT_OK_LAST          = 22 );
  61.   STATIC_CONST( BRANCH_ATTR_OP_ARG    = 23 );
  62.   STATIC_CONST( BRANCH_ATTR_EQ_NULL   = 24 );
  63.   STATIC_CONST( BRANCH_ATTR_NE_NULL   = 25 );
  64.   
  65.   /**
  66.    * Macros for creating code
  67.    */
  68.   static Uint32 Read(Uint32 AttrId, Uint32 Register);
  69.   static Uint32 Write(Uint32 AttrId, Uint32 Register);
  70.   
  71.   static Uint32 LoadNull(Uint32 Register);
  72.   static Uint32 LoadConst16(Uint32 Register, Uint32 Value);
  73.   static Uint32 LoadConst32(Uint32 Register); // Value in next word
  74.   static Uint32 LoadConst64(Uint32 Register); // Value in next 2 words
  75.   static Uint32 Add(Uint32 DstReg, Uint32 SrcReg1, Uint32 SrcReg2);
  76.   static Uint32 Sub(Uint32 DstReg, Uint32 SrcReg1, Uint32 SrcReg2);
  77.   static Uint32 Branch(Uint32 Inst, Uint32 Reg1, Uint32 Reg2);
  78.   static Uint32 ExitOK();
  79.   /**
  80.    * Branch string
  81.    *
  82.    * i = Instruction            -  5 Bits ( 0 - 5 ) max 63
  83.    * a = Attribute id
  84.    * l = Length of string
  85.    * b = Branch offset
  86.    * t = branch type
  87.    * d = Array length diff
  88.    * v = Varchar flag
  89.    * p = No-blank-padding flag for char compare
  90.    *
  91.    *           1111111111222222222233
  92.    * 01234567890123456789012345678901
  93.    * iiiiii   ddvtttpbbbbbbbbbbbbbbbb
  94.    * aaaaaaaaaaaaaaaallllllllllllllll
  95.    * -string....                    -
  96.    */
  97.   enum UnaryCondition {
  98.     IS_NULL = 0,
  99.     IS_NOT_NULL = 1
  100.   };
  101.   enum BinaryCondition {
  102.     EQ = 0,
  103.     NE = 1,
  104.     LT = 2,
  105.     LE = 3,
  106.     GT = 4,
  107.     GE = 5,
  108.     LIKE = 6,
  109.     NOT_LIKE = 7
  110.   };
  111.   static Uint32 BranchCol(BinaryCondition cond, 
  112.   Uint32 arrayLengthDiff, Uint32 varchar, bool nopad);
  113.   static Uint32 BranchCol_2(Uint32 AttrId);
  114.   static Uint32 BranchCol_2(Uint32 AttrId, Uint32 Len);
  115.   static Uint32 getBinaryCondition(Uint32 op1);
  116.   static Uint32 getArrayLengthDiff(Uint32 op1);
  117.   static Uint32 isVarchar(Uint32 op1);
  118.   static Uint32 isNopad(Uint32 op1);
  119.   static Uint32 getBranchCol_AttrId(Uint32 op2);
  120.   static Uint32 getBranchCol_Len(Uint32 op2);
  121.   
  122.   /**
  123.    * Macros for decoding code
  124.    */
  125.   static Uint32 getOpCode(Uint32 op);
  126.   static Uint32 getReg1(Uint32 op);
  127.   static Uint32 getReg2(Uint32 op);
  128.   static Uint32 getReg3(Uint32 op);
  129. };
  130. inline
  131. Uint32
  132. Interpreter::Read(Uint32 AttrId, Uint32 Register){
  133.   return (AttrId << 16) + (Register << 6) + READ_ATTR_INTO_REG;
  134. }
  135. inline
  136. Uint32
  137. Interpreter::Write(Uint32 AttrId, Uint32 Register){
  138.   return (AttrId << 16) + (Register << 6) + WRITE_ATTR_FROM_REG;
  139. }
  140. inline
  141. Uint32
  142. Interpreter::LoadConst16(Uint32 Register, Uint32 Value){
  143.   return (Value << 16) + (Register << 6) + LOAD_CONST16;
  144. }
  145. inline
  146. Uint32
  147. Interpreter::LoadConst32(Uint32 Register){
  148.   return (Register << 6) + LOAD_CONST32;
  149. }
  150. inline
  151. Uint32
  152. Interpreter::LoadConst64(Uint32 Register){
  153.   return (Register << 6) + LOAD_CONST64;
  154. }
  155. inline
  156. Uint32
  157. Interpreter::Add(Uint32 Dcoleg, Uint32 SrcReg1, Uint32 SrcReg2){
  158.   return (SrcReg1 << 6) + (SrcReg2 << 9) + (Dcoleg << 16) + ADD_REG_REG;
  159. }
  160. inline
  161. Uint32
  162. Interpreter::Sub(Uint32 Dcoleg, Uint32 SrcReg1, Uint32 SrcReg2){
  163.   return (SrcReg1 << 6) + (SrcReg2 << 9) + (Dcoleg << 16) + SUB_REG_REG;
  164. }
  165. inline
  166. Uint32
  167. Interpreter::Branch(Uint32 Inst, Uint32 Reg1, Uint32 Reg2){
  168.   return (Reg1 << 9) + (Reg2 << 6) + Inst;
  169. }
  170. inline
  171. Uint32
  172. Interpreter::BranchCol(BinaryCondition cond, 
  173.        Uint32 arrayLengthDiff,
  174.        Uint32 varchar, bool nopad){
  175.   //ndbout_c("BranchCol: cond=%d diff=%u varchar=%u nopad=%d",
  176.       //cond, arrayLengthDiff, varchar, nopad);
  177.   return 
  178.     BRANCH_ATTR_OP_ARG + 
  179.     (arrayLengthDiff << 9) + 
  180.     (varchar << 11) +
  181.     (cond << 12) +
  182.     (nopad << 15);
  183. }
  184. inline
  185. Uint32 
  186. Interpreter::BranchCol_2(Uint32 AttrId, Uint32 Len){
  187.   return (AttrId << 16) + Len;
  188. }
  189. inline
  190. Uint32 
  191. Interpreter::BranchCol_2(Uint32 AttrId){
  192.   return (AttrId << 16);
  193. }
  194. inline
  195. Uint32
  196. Interpreter::getBinaryCondition(Uint32 op){
  197.   return (op >> 12) & 0x7;
  198. }
  199. inline
  200. Uint32
  201. Interpreter::getArrayLengthDiff(Uint32 op){
  202.   return (op >> 9) & 0x3;
  203. }
  204. inline
  205. Uint32
  206. Interpreter::isVarchar(Uint32 op){
  207.   return (op >> 11) & 1;
  208. }
  209. inline
  210. Uint32
  211. Interpreter::isNopad(Uint32 op){
  212.   return (op >> 15) & 1;
  213. }
  214. inline
  215. Uint32
  216. Interpreter::getBranchCol_AttrId(Uint32 op){
  217.   return (op >> 16) & 0xFFFF;
  218. }
  219. inline
  220. Uint32
  221. Interpreter::getBranchCol_Len(Uint32 op){
  222.   return op & 0xFFFF;
  223. }
  224. inline
  225. Uint32
  226. Interpreter::ExitOK(){
  227.   return EXIT_OK;
  228. }
  229. inline
  230. Uint32
  231. Interpreter::getOpCode(Uint32 op){
  232.   return op & 0x3f;
  233. }
  234. inline
  235. Uint32
  236. Interpreter::getReg1(Uint32 op){
  237.   return (op >> 6) & 0x7;
  238. }
  239. inline
  240. Uint32
  241. Interpreter::getReg2(Uint32 op){
  242.   return (op >> 9) & 0x7;
  243. }
  244. inline
  245. Uint32
  246. Interpreter::getReg3(Uint32 op){
  247.   return (op >> 16) & 0x7;
  248. }
  249. #endif