PureBoard

Code: Alles auswählen

Structure CFASM_PARAM
  type.b
  StructureUnion
    byte.b
    word.w
    long.l
    quad.q
    float.f
    double.d
    char.c
    *pointer
  EndStructureUnion
EndStructure

#Pointer = -1


Procedure CallFunctionASM(*func, param.CFASM_PARAM(), *ret.CFASM_PARAM)
  count.l = CountList(param())
  *memory = AllocateMemory(count*9+1)
  type.b = *ret\type
  pos.l = 0
  ForEach param()
    PokeB(*memory+pos, param()\type): pos + 1
    Select param()\type
    Case #Pointer
      PokeL(*memory+pos, param()\pointer): pos + 4
    Case #Byte
      PokeB(*memory+pos, param()\byte): pos + 1
    Case #Word
      PokeW(*memory+pos, param()\word): pos + 2
    Case #Long
      PokeL(*memory+pos, param()\long): pos + 4
    Case #Quad
      PokeQ(*memory+pos, param()\quad): pos + 8
    Case #Float
      PokeF(*memory+pos, param()\float): pos + 4
    Case #Double
      PokeD(*memory+pos, param()\double): pos + 8
    Case #Character
      PokeW(*memory+pos, param()\char): pos + 2
    EndSelect
  Next
  ! MOV Ecx, dword [p.p_func]
  ! MOV Edi, dword [p.v_count]
  ! MOV Esi, dword [p.p_memory]
  callfunctionasm_loop:
    ! MOVSX Ebx, byte [Esi]
    ! INC Esi
    ! CMP Ebx, -1 ;Pointer
    ! JE  l_callfunctionasm_long
    ! CMP Ebx, 0 ;Byte
    ! JE  l_callfunctionasm_byte
    ! CMP Ebx, 1 ;Word
    ! JE  l_callfunctionasm_word
    ! CMP Ebx, 2 ;Long
    ! JE  l_callfunctionasm_long
    ! CMP Ebx, 3 ;Float
    ! JE  l_callfunctionasm_long
    ! CMP Ebx, 4 ;Quad
    ! JE  l_callfunctionasm_quad
    ! CMP Ebx, 6 ;Double
    ! JE  l_callfunctionasm_double
    ! CMP Ebx, 7 ;Character
    ! JE  l_callfunctionasm_char
    ! JMP l_callfunctionasm_next
    callfunctionasm_byte:
      ! MOVSX eax, byte [esi]
      ! PUSH eax
      ! ADD esi, 1
      ! JMP l_callfunctionasm_next
    callfunctionasm_word:
      ! MOVSX eax, word [esi]
      ! PUSH eax
      ! ADD esi, 2
      ! JMP l_callfunctionasm_next
    callfunctionasm_long:
      ! PUSH dword [esi]
      ! ADD esi, 4
      ! JMP l_callfunctionasm_next
    callfunctionasm_quad:
      ! PUSH dword [esi+4]
      ! PUSH dword [esi]
      ! ADD esi, 8
      ! JMP l_callfunctionasm_next
    callfunctionasm_double:
      ! LEA eax, qword [esi]
      ! PUSH dword [eax+4]
      ! PUSH dword [eax]
      ! ADD esi, 8
      ! JMP l_callfunctionasm_next
    callfunctionasm_char:
      ! MOVZX eax, word [esi]
      ! PUSH eax
      ! ADD esi, 2
      ! JMP l_callfunctionasm_next
    callfunctionasm_next:
    ! DEC edi
    ! JNE l_callfunctionasm_loop
  ! CALL ecx
  If (type = #Pointer)
    *pointer = 0
    ! MOV dword [p.p_pointer], eax
    *ret\pointer = *pointer
  ElseIf (type = #Byte)
    byte.b = 0
    ! MOV byte [p.v_byte], al
    *ret\byte = byte
  ElseIf (type = #Word)
    word.w = 0
    ! MOV word [p.v_word], ax
    *ret\word = word
  ElseIf (type = #Long)
    long.l = 0
    ! MOV dword [p.v_long], eax
    *ret\long = long
  ElseIf (type = #Quad)
    quad.q = 0
    ! PUSH edx
    ! PUSH eax
    ! POP dword [p.v_quad+4]
    ! POP dword [p.v_quad+4]
    *ret\quad = quad
  ElseIf (type = #Float)
    float.f = 0
    ! FSTP dword [p.v_float]
    *ret\float = float
  ElseIf (type = #Double)
    double.d = 0
    ! FSTP qword [p.v_double]
    *ret\double = double
  ElseIf (type = #Character)
    char.w = 0
    ! MOV word [p.v_char], ax
    *ret\char = char
  EndIf
  FreeMemory(*memory)
EndProcedure


Procedure.f test(double.d, long.l, quad.q, *pointer)
  Debug double
  Debug long
  Debug quad
  Debug *pointer
  ProcedureReturn 2.5
EndProcedure


NewList param.CFASM_PARAM()
InsertElement(param())
param()\type = #Double
param()\double = -1.234
InsertElement(param())
param()\type = #Long
param()\long = 12
InsertElement(param())
param()\type = #Quad
param()\quad = 247932409487029348
InsertElement(param())
param()\type = #Pointer
param()\pointer = @param()

ret.CFASM_PARAM\type = #Float

CallFunctionASM(@test(), param(), ret)

Debug "----------"
Debug ret\float

Code: Alles auswählen

Runtime Procedure Get(w1,w2,w3)
  ;magische Funktion
EndProcedure

Runtime Procedure output(text.s)
  ;noch mehr magie
EndProcedure

Runtime Procedure SetF(float.f)
  ;reinste hexerei!
EndProcedure

Threaded CallStringRet.s
Procedure CallString(*ret.integer,String.s)
  ;zerlegen
  ;functionsname mit runtime-library in Adresse *func übersetzen
  ;parameteranzahl finden
  Select  PCount
    Case 0
      ret=CallFunctionFast(*func)
    Case 1
      ret=CallFunctionFast(*func,f1)
      ;usw.
  EndSelect
  CallStringRet=Str(ret)
  *ret\i=@CallStringRet
  Procedure #True ;wurde ausgeführt.
EndProcedure

    
  
adr.i
CallString(@adr,"Get(10,20,44)"):
Debug PeekS(adr)
CallString(@adr, ~"Output(\"test\")"):
Debug PeekS(adr)
CallString(@adr,"SetF(10.4F)"):
Debug PeekS(adr); (F kennzeichnet hier die Float-Zahl).