Home Explore Help
Sign In
cpp
/
EsenthalEngine
mirror of https://github.com/feiyunwill/EsenthelEngine.git
2
0
Fork 0
Files Issues 0 Wiki
Branch: master
Branches Tags
EsenthalEngine
/
Engine
/
Source
/
Code
/
Compile
/
CE Func List.h

CE Func List.h 9.8 KB
Permalink History Raw

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465 
  1. static void $nop(PARAMS) { thread.func_code_pos+=Call::Size(0); }
    2. 

  2. static void $call$20func(PARAMS) { thread.func_code_pos+=Call::Size(1); thread.call(*(CodeEnvironment::FuncBody*)call.param(0).getInstructP(), call.param(0).getInstructI2(),                          null,                          null); }
    3. 

  3. static void $call$20func$20result(PARAMS) { thread.func_code_pos+=Call::Size(2); thread.call(*(CodeEnvironment::FuncBody*)call.param(0).getInstructP(), call.param(0).getInstructI2(),                          null, call.param(1).address(thread)); }
    4. 

  4. static void $call$20method(PARAMS) { thread.func_code_pos+=Call::Size(2); thread.call(*(CodeEnvironment::FuncBody*)call.param(0).getInstructP(), call.param(0).getInstructI2(), call.param(1).address(thread),                          null); }
    5. 

  5. static void $call$20method$20result(PARAMS) { thread.func_code_pos+=Call::Size(3); thread.call(*(CodeEnvironment::FuncBody*)call.param(0).getInstructP(), call.param(0).getInstructI2(), call.param(1).address(thread), call.param(2).address(thread)); }
    6. 

  6. static void $set$20const$201(PARAMS) { *(byte *)(thread.func_stack+call.param(0).getInstructI()) = (byte &)call.param(1).raw; thread.func_code_pos+=Call::Size(2); }
    7. 

  7. static void $set$20const$202(PARAMS) { *(short*)(thread.func_stack+call.param(0).getInstructI()) = (short&)call.param(1).raw; thread.func_code_pos+=Call::Size(2); }
    8. 

  8. static void $set$20const$204(PARAMS) { *(int  *)(thread.func_stack+call.param(0).getInstructI()) = (int  &)call.param(1).raw; thread.func_code_pos+=Call::Size(2); }
    9. 

  9. static void $set$20const$208(PARAMS) { *(long *)(thread.func_stack+call.param(0).getInstructI()) = (long &)call.param(1).raw; thread.func_code_pos+=Call::Size(2); }
    10. 

  10. static void $set$20const$20heap$201(PARAMS) { *(byte *)(thread.func_stack+call.param(0).getInstructI()) = PARAM(1,byte ); thread.func_code_pos+=Call::Size(2); }
    11. 

  11. static void $set$20const$20heap$202(PARAMS) { *(short*)(thread.func_stack+call.param(0).getInstructI()) = PARAM(1,short); thread.func_code_pos+=Call::Size(2); }
    12. 

  12. static void $set$20const$20heap$204(PARAMS) { *(int  *)(thread.func_stack+call.param(0).getInstructI()) = PARAM(1,int  ); thread.func_code_pos+=Call::Size(2); }
    13. 

  13. static void $set$20const$20heap$208(PARAMS) { *(long *)(thread.func_stack+call.param(0).getInstructI()) = PARAM(1,long ); thread.func_code_pos+=Call::Size(2); }
    14. 

  14. static void $set$20addr$20heap(PARAMS) { *(ptr*)(thread.heap      +call.param(0).getInstructI()) = call.param(1).address(thread); thread.func_code_pos+=Call::Size(2); }
    15. 

  15. static void $set$20addr$20stack(PARAMS) { *(ptr*)(thread.func_stack+call.param(0).getInstructI()) = call.param(1).address(thread); thread.func_code_pos+=Call::Size(2); }
    16. 

  16. static void $set$20addr$20result(PARAMS) { *(ptr*)(thread.func_result                            ) = call.param(0).address(thread); thread.func_code_pos+=Call::Size(1); }
    17. 

  17. static void $indirection(PARAMS) { *(ptr*)(thread.func_stack+call.param(0).getInstructI()) = PARAM(1,ptr); thread.func_code_pos+=Call::Size(2); }
    18. 

  18. static void $address$20of(PARAMS) { PARAM(0,ptr) = call.param(1).address(thread); thread.func_code_pos+=Call::Size(2); }
    19. 

  19. static void $offset$201s(PARAMS) { PARAM_REF(0) = (byte*)call.param(1).address(thread) + PARAM(2,sbyte ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    20. 

  20. static void $offset$201u(PARAMS) { PARAM_REF(0) = (byte*)call.param(1).address(thread) + PARAM(2,byte  ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    21. 

  21. static void $offset$202s(PARAMS) { PARAM_REF(0) = (byte*)call.param(1).address(thread) + PARAM(2,short ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    22. 

  22. static void $offset$202u(PARAMS) { PARAM_REF(0) = (byte*)call.param(1).address(thread) + PARAM(2,ushort) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    23. 

  23. static void $offset$204s(PARAMS) { PARAM_REF(0) = (byte*)call.param(1).address(thread) + PARAM(2,int   ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    24. 

  24. static void $offset$204u(PARAMS) { PARAM_REF(0) = (byte*)call.param(1).address(thread) + PARAM(2,uint  ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    25. 

  25. static void $offset$208s(PARAMS) { PARAM_REF(0) = (byte*)call.param(1).address(thread) + PARAM(2,long  ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    26. 

  26. static void $offset$208u(PARAMS) { PARAM_REF(0) = (byte*)call.param(1).address(thread) + PARAM(2,ulong ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    27. 

  27. static void $inc$20ptr$202(PARAMS) { ++PARAM(0,short*); thread.func_code_pos+=Call::Size(1); }
    28. 

  28. static void $dec$20ptr$202(PARAMS) { --PARAM(0,short*); thread.func_code_pos+=Call::Size(1); }
    29. 

  29. static void $inc$20ptr$204(PARAMS) { ++PARAM(0,int  *); thread.func_code_pos+=Call::Size(1); }
    30. 

  30. static void $dec$20ptr$204(PARAMS) { --PARAM(0,int  *); thread.func_code_pos+=Call::Size(1); }
    31. 

  31. static void $inc$20ptr$208(PARAMS) { ++PARAM(0,long *); thread.func_code_pos+=Call::Size(1); }
    32. 

  32. static void $dec$20ptr$208(PARAMS) { --PARAM(0,long *); thread.func_code_pos+=Call::Size(1); }
    33. 

  33. static void $inc$20ptr$20n(PARAMS) {   PARAM(0,byte *) += call.param(1).getInstructI(); thread.func_code_pos+=Call::Size(2); }
    34. 

  34. static void $dec$20ptr$20n(PARAMS) {   PARAM(0,byte *) -= call.param(1).getInstructI(); thread.func_code_pos+=Call::Size(2); }
    35. 

  35. static void $add$20ptr$201s(PARAMS) { PARAM(0,byte*) += PARAM(1,sbyte ) * call.param(2).getInstructI(); thread.func_code_pos+=Call::Size(3); }
    36. 

  36. static void $add$20ptr$201u(PARAMS) { PARAM(0,byte*) += PARAM(1,byte  ) * call.param(2).getInstructI(); thread.func_code_pos+=Call::Size(3); }
    37. 

  37. static void $add$20ptr$202s(PARAMS) { PARAM(0,byte*) += PARAM(1,short ) * call.param(2).getInstructI(); thread.func_code_pos+=Call::Size(3); }
    38. 

  38. static void $add$20ptr$202u(PARAMS) { PARAM(0,byte*) += PARAM(1,ushort) * call.param(2).getInstructI(); thread.func_code_pos+=Call::Size(3); }
    39. 

  39. static void $add$20ptr$204s(PARAMS) { PARAM(0,byte*) += PARAM(1,int   ) * call.param(2).getInstructI(); thread.func_code_pos+=Call::Size(3); }
    40. 

  40. static void $add$20ptr$204u(PARAMS) { PARAM(0,byte*) += PARAM(1,uint  ) * call.param(2).getInstructI(); thread.func_code_pos+=Call::Size(3); }
    41. 

  41. static void $add$20ptr$208s(PARAMS) { PARAM(0,byte*) += PARAM(1,long  ) * call.param(2).getInstructI(); thread.func_code_pos+=Call::Size(3); }
    42. 

  42. static void $add$20ptr$208u(PARAMS) { PARAM(0,byte*) += PARAM(1,ulong ) * call.param(2).getInstructI(); thread.func_code_pos+=Call::Size(3); }
    43. 

  43. static void $ptr$20add$201s(PARAMS) { PARAM(0,ptr) = PARAM(1,byte*) + PARAM(2,sbyte ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    44. 

  44. static void $ptr$20add$201u(PARAMS) { PARAM(0,ptr) = PARAM(1,byte*) + PARAM(2,byte  ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    45. 

  45. static void $ptr$20add$202s(PARAMS) { PARAM(0,ptr) = PARAM(1,byte*) + PARAM(2,short ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    46. 

  46. static void $ptr$20add$202u(PARAMS) { PARAM(0,ptr) = PARAM(1,byte*) + PARAM(2,ushort) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    47. 

  47. static void $ptr$20add$204s(PARAMS) { PARAM(0,ptr) = PARAM(1,byte*) + PARAM(2,int   ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    48. 

  48. static void $ptr$20add$204u(PARAMS) { PARAM(0,ptr) = PARAM(1,byte*) + PARAM(2,uint  ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    49. 

  49. static void $ptr$20add$208s(PARAMS) { PARAM(0,ptr) = PARAM(1,byte*) + PARAM(2,long  ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    50. 

  50. static void $ptr$20add$208u(PARAMS) { PARAM(0,ptr) = PARAM(1,byte*) + PARAM(2,ulong ) * call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    51. 

  51. static void $ptr$20diff(PARAMS) { PARAM(0,uintptr) = (PARAM(1,byte*) - PARAM(2,byte*)) / call.param(3).getInstructI(); thread.func_code_pos+=Call::Size(4); }
    52. 

  52. static void $goto(PARAMS) {                     thread.func_code_pos = (byte*)call.param(0).getInstructP(); }
    53. 

  53. static void $goto$20cond$201(PARAMS) { if( PARAM(1,byte )) thread.func_code_pos = (byte*)call.param(0).getInstructP(); else thread.func_code_pos+=Call::Size(2); }
    54. 

  54. static void $goto$20cond$202(PARAMS) { if( PARAM(1,short)) thread.func_code_pos = (byte*)call.param(0).getInstructP(); else thread.func_code_pos+=Call::Size(2); }
    55. 

  55. static void $goto$20cond$204(PARAMS) { if( PARAM(1,int  )) thread.func_code_pos = (byte*)call.param(0).getInstructP(); else thread.func_code_pos+=Call::Size(2); }
    56. 

  56. static void $goto$20cond$208(PARAMS) { if( PARAM(1,long )) thread.func_code_pos = (byte*)call.param(0).getInstructP(); else thread.func_code_pos+=Call::Size(2); }
    57. 

  57. static void $goto$20cond$20f(PARAMS) { if( PARAM(1,flt  )) thread.func_code_pos = (byte*)call.param(0).getInstructP(); else thread.func_code_pos+=Call::Size(2); }
    58. 

  58. static void $goto$20cond$20d(PARAMS) { if( PARAM(1,dbl  )) thread.func_code_pos = (byte*)call.param(0).getInstructP(); else thread.func_code_pos+=Call::Size(2); }
    59. 

  59. static void $goto$20cond$20n$201(PARAMS) { if(!PARAM(1,byte )) thread.func_code_pos = (byte*)call.param(0).getInstructP(); else thread.func_code_pos+=Call::Size(2); }
    60. 

  60. static void $goto$20cond$20n$202(PARAMS) { if(!PARAM(1,short)) thread.func_code_pos = (byte*)call.param(0).getInstructP(); else thread.func_code_pos+=Call::Size(2); }
    61. 

  61. static void $goto$20cond$20n$204(PARAMS) { if(!PARAM(1,int  )) thread.func_code_pos = (byte*)call.param(0).getInstructP(); else thread.func_code_pos+=Call::Size(2); }
    62. 

  62. static void $goto$20cond$20n$208(PARAMS) { if(!PARAM(1,long )) thread.func_code_pos = (byte*)call.param(0).getInstructP(); else thread.func_code_pos+=Call::Size(2); }
    63. 

  63. static void $goto$20cond$20n$20f(PARAMS) { if(!PARAM(1,flt  )) thread.func_code_pos = (byte*)call.param(0).getInstructP(); else thread.func_code_pos+=Call::Size(2); }
    64. 

  64. static void $goto$20cond$20n$20d(PARAMS) { if(!PARAM(1,dbl  )) thread.func_code_pos = (byte*)call.param(0).getInstructP(); else thread.func_code_pos+=Call::Size(2); }
    65. 

  65.