; German forum: http://www.purebasic.fr/german/viewtopic.php?t=1408&start=10
; Author: LittleFurz (updated for PB 4.00 by Andre)
; Date: 15. January 2005
; OS: Windows
; Demo: No



Structure sMemory 
    MemPointer.l 
    MemType.l 
    MemSize.l 
EndStructure 

Structure sPointer 
    potName.s 
    potZeile.l 
EndStructure 

Structure sStore 
    stoDataS.s 
    stoDataL.l 
    stoType.l 
EndStructure 

Structure sToken 
    tokBefehl.s 
    
    tokData1.s 
    tokType1.l 
    
    tokData2.s 
    tokType2.l 
EndStructure 

Structure AllTypes 
    StructureUnion 
        b.b 
        w.w 
        l.l 
        f.f 
        s.s 
    EndStructureUnion 
EndStructure 

Enumeration 
    #TYPString 
    #TYPLong 
    #TYPMemory 
    #TYPPointer 
EndEnumeration 

Enumeration 
    #STCByte 
    #STCWord 
    #STCDWord 
    #STCString 
EndEnumeration 

Enumeration 
    #CMPLower 
    #CMPEqual 
    #CMPHigher 
    #CMPNotEqual 
    #CMPWrong 
EndEnumeration 

#Version = "0.1.2" 
#CodePage = "code.OBJ" 
#PtrsPage = "Ptr.OBJ" 

Global CMPResult.l 

Global lngFunkPtr.l 
Global lngResult.l 
Global lngDataPush.l 

Global StartExecution.l 
Global StoppExecution.l 

Global lngMemorySize.l 

Global strCommand.s 

NewList Memory.l() 
NewList Source.sToken() 
NewList Points.sPointer() 
NewList Stack.sStore() 
NewList JMPStack.l() 
NewList StructStack.l() 
Dim Speicher.sMemory(0) 
Dim SideMemy.sMemory(0) 

;IncludeFile "Easy3.pb.declare" 
Declare cMain()
Declare AssembleParameter()

cMain() 
End 

;- Hauptprogramm 
Procedure cMain() 
    Define.s tmpZeile, strFileName 
    Define.l FileProc, lngFilehWnd 
    
    strFileName = ProgramParameter() 
    strCommand  = AssembleParameter() 
    Debug "File : " + strFileName 
    Debug "Param: " + strCommand 
    If FileSize(strFileName) > 0 
        Debug "Pointer File: " + Str(VBinSize(strFileName, #PtrsPage)) 
        Debug "Code File:    " + Str(VBinSize(strFileName, #CodePage))        
        Debug "------ Read Resources ------" 
        lngFilehWnd = VBin(strFileName, #PtrsPage, "") 
        Debug "Reading Pointers..." 
        While FileProc < VBinSize(strFileName, #PtrsPage) 
            AddElement(Points()) 
            FileProc + ReadStructure(Points(), lngFilehWnd+FileProc, @"sl") 
            Debug ">> Jumpmark " + Points()\potName + " at " + Str(Points()\potZeile) 
        Wend: FileProc = 0        
        
        Debug "Reading Source..." 
        lngFilehWnd = VBin(strFileName, #CodePage, "") 
        While FileProc < VBinSize(strFileName, #CodePage) 
            AddElement(Source()) 
            FileProc + ReadStructure(Source(), lngFilehWnd+FileProc, @"sslsl") 
        Wend: FileProc = 0    
        Debug "Source Lines: " + Str(CountList(Source())) 
        
        Debug "------ Start Programm ------" 
        StartExecution = GetTickCount_() 
        ForEach Source() 
            Debug RSet(Str(ListIndex(Source())),3,"0")+": "+Source()\tokBefehl+"("+Source()\tokData1+"["+Str(Source()\tokType1)+"]"+"-"+Source()\tokData2+"["+Str(Source()\tokType2)+"]"+")" 
            
            Select Source()\tokBefehl 
                Case "siz": Easy_SIZ(Source()): Case "mov": Easy_MOV(Source()) 
                Case "int": Easy_INT(Source()): Case "add": Easy_ADD(Source()) 
                Case "inc": Easy_INC(Source()): Case "dec": Easy_DEC(Source()) 
                Case "cnv": Easy_CNV(Source()): Case "jmp": Easy_JMP(Source()) 
                Case "ret": Easy_RET(Source()): Case "got": Easy_GOT(Source()) 
                Case "cmp": Easy_CMP(Source()): Case "jl" : Easy_JL (Source()) 
                Case "jnl": Easy_JNL(Source()): Case "je" : Easy_JE (Source()) 
                Case "jne": Easy_JNE(Source()): Case "jg" : Easy_JG (Source()) 
                Case "jng": Easy_JNG(Source()): Case "opn": Easy_OPN(Source()) 
                Case "sto": Easy_STO(Source()): Case "cls": Easy_CLS(Source()) 
                Case "cal": Easy_CAL(Source()): Case "flp": Easy_FLP(Source()) 
                Case "lad": Easy_LAD(Source()): Case "byt": Easy_BYT(Source()) 
                Case "and": Easy_AND(Source()): Case "or" : Easy_OR (Source()) 
                Case "xor": Easy_XOR(Source()) 
            EndSelect 
        Next 
        StoppExecution = GetTickCount_() 
        Debug "Execution finished in: " + Str(StoppExecution-StartExecution) 
    EndIf 
EndProcedure 

;- Standart Befehle 
Procedure Easy_SIZ(*Token.sToken) 
    Define.l lngI 
      
    Debug "> Allocate Memory" 
    If *Token\tokType1 = #TYPLong 
        lngMemorySize = Val(*Token\tokData1) 
        Dim Speicher.sMemory(lngMemorySize) 
        For lngI = 0 To lngMemorySize 
            Speicher(lngI)\MemPointer = AllocateMemory(4) 
            Speicher(lngI)\MemSize = 4 
            Speicher(lngI)\MemType = #TYPLong 
            PokeL(Speicher(lngI)\MemPointer, 0000) 
            Debug ">> Alocated Mem: " + Str(Speicher(lngI)\MemPointer) 
        Next 
    Else 
        Debug ">> Can't allocate memory !" 
    EndIf 
EndProcedure 

Procedure Easy_MOV(*Token.sToken) 
    Define.l lngSize, lngMemA, lngMemB 
      
    Select *Token\tokType2 
        Case #TYPString 
            SetString(*Token\tokData2   , Speicher(Val(*Token\tokData1))) 
        Case #TYPLong  
            SetLong(Val(*Token\tokData2), Speicher(Val(*Token\tokData1))) 
        Case #TYPMemory 
            MemCopy(Speicher(Val(*Token\tokData2)), Speicher(Val(*Token\tokData1)) ) 
        Case #TYPPointer 
            lngMemA = Speicher(Val(*Token\tokData1))\MemPointer 
            SetLong(lngMemA, Speicher(Val(*Token\tokData1))) 
            Speicher(Val(*Token\tokData1))\MemType = #TYPPointer 
    EndSelect 
EndProcedure 

Procedure Easy_INT(*Token.sToken) 
    Define.s SpeicherA 
    
    Select *Token\tokType2 
        Case #TYPLong  : SpeicherA = *Token\tokData2 
        Case #TYPString: SpeicherA = *Token\tokData2 
        Case #TYPMemory 
            If Speicher(Val(*Token\tokData2))\MemType = #TYPString 
                SpeicherA = GetString(Speicher(Val(*Token\tokData2))) 
            ElseIf Speicher(Val(*Token\tokData2))\MemType = #TYPLong 
                SpeicherA = Str(GetLong(Speicher(Val(*Token\tokData2)))) 
            EndIf 
    EndSelect 

    Select *Token\tokData1 
        Case "0" ; Debug 
            Debug "------ Debug Message ------" 
            Debug "Msg (" + *Token\tokData2 + "): " + SpeicherA 
        Case "1" ; Ende 
            SelectElement(Source(), CountList(Source())) 
        Case "2" ; Delay 
            Delay(Val(SpeicherA)) 
        Case "3" ; Runing Since 
            SetLong(StartExecution, Speicher(Val(SpeicherA))) 
        Case "4" ; Runing 
            StoppExecution = GetTickCount_() 
            SetLong(StoppExecution-StartExecution, Speicher(Val(SpeicherA))) 
        Case "5" ; Get Easy Version 
            SetString(#Version, Speicher(Val(SpeicherA))) 
        Case "6" ; Get Command prompt 
            SetString(strCommand, Speicher(Val(SpeicherA))) 
    EndSelect 
EndProcedure 

Procedure Easy_ADD(*Token.sToken) 
    Define.l CalcResult, lngDestMemType, lngSourceMemType 
    Define.s AssmResult 
    
    lngDestMemType = Speicher(Val(*Token\tokData1))\MemType 
    Select *Token\tokType2 
        Case #TYPLong 
            If lngDestMemType = #TYPLong 
                CalcResult = GetLong(Speicher(Val(*Token\tokData1))) 
                CalcResult + Val(*Token\tokData2) 
                SetLong(CalcResult, Speicher(Val(*Token\tokData1))) 
            EndIf 
        Case #TYPString 
            If lngDestMemType = #TYPString 
                AssmResult = GetString(Speicher(Val(*Token\tokData1))) 
                AssmResult = AssmResult + *Token\tokData2 
                SetString(AssmResult ,Speicher(Val(*Token\tokData1))) 
            EndIf 
        Case #TYPMemory 
            lngSourceMemType = Speicher(Val(*Token\tokData2))\MemType 
            If lngDestMemType = lngSourceMemType 
                Select lngDestMemType 
                    Case #TYPLong 
                        CalcResult = GetLong(Speicher(Val(*Token\tokData1))) 
                        CalcResult + GetLong(Speicher(Val(*Token\tokData2))) 
                        SetLong(CalcResult, Speicher(Val(*Token\tokData1))) 
                    Case #TYPString 
                        AssmResult = GetString(Speicher(Val(*Token\tokData1))) 
                        AssmResult + GetString(Speicher(Val(*Token\tokData2))) 
                        SetString(AssmResult ,Speicher(Val(*Token\tokData1)))                        
                EndSelect 
            EndIf 
    EndSelect 
EndProcedure 

Procedure Easy_INC(*Token.sToken) 
    Define.l CalcResult 
    
    If *Token\tokType1 = #TYPMemory And Speicher(Val(*Token\tokData1))\MemType = #TYPLong 
        CalcResult = GetLong(Speicher(Val(*Token\tokData1))) + 1 
        SetLong(CalcResult, Speicher(Val(*Token\tokData1))) 
    EndIf 
EndProcedure 

Procedure Easy_DEC(*Token.sToken) 
    Define.l CalcResult 
    
    If *Token\tokType1 = #TYPMemory And Speicher(Val(*Token\tokData1))\MemType = #TYPLong 
        CalcResult = GetLong(Speicher(Val(*Token\tokData1))) - 1 
        SetLong(CalcResult, Speicher(Val(*Token\tokData1))) 
    EndIf 
EndProcedure 

Procedure Easy_CNV(*Token.sToken) 
    Define.s strTemp 
      
    If *Token\tokType1 = #TYPMemory 
        Select *Token\tokData2 
            Case "0" ; Long to String 
                strTemp = Str(GetLong(Speicher(Val(*Token\tokData1)))) 
                SetString(strTemp, Speicher(Val(*Token\tokData1))) 
            Case "1" ; String to Long 
                strTemp = GetString(Speicher(Val(*Token\tokData1))) 
                SetLong(Val(strTemp), Speicher(Val(*Token\tokData1))) 
        EndSelect 
    EndIf 
EndProcedure 

Procedure Easy_LNK(*Token.sToken) 
    Define.l lngMemA, lngMemB 
    
    If *Token\tokType1 = #TYPMemory And *Token\tokType2 = #TYPMemory 
        lngMemA = @Speicher(Val(*Token\tokData1)) 
        lngMemB = @Speicher(Val(*Token\tokData2)) 
        CopyMemory(lngMemB, lngMemA, SizeOf(sMemory)) 
    EndIf 
EndProcedure 

Procedure Easy_FLP(*Token.sToken) 
    Define.l lngI, *lngMemA, *lngMemB 
    
    Debug "> Fliping Memory" 
    If *Token\tokType1 = #TYPLong 
        If *Token\tokData1 = "0": Dim SideMemy.sMemory(lngMemorySize): EndIf 
        
        For lngI = 0 To lngMemorySize 
            If *Token\tokData1 = "0"     ; Save Memory 
                CopyMemory(@Speicher(lngI), SideMemy(lngI), SizeOf(sMemory)) 
                Speicher(lngI)\MemPointer = AllocateMemory(4) 
                Speicher(lngI)\MemSize = 4 
                Speicher(lngI)\MemType = #TYPLong 
                If NextElement(Stack()) 
                    
                EndIf 
            Else ; Restore Memory 
                CopyMemory(@SideMemy(lngI), @Speicher(lngI), SizeOf(sMemory)) 
                SideMemy(lngI)\MemPointer = AllocateMemory(4) 
                SideMemy(lngI)\MemSize = 4 
                SideMemy(lngI)\MemType = #TYPLong 
            EndIf 
        Next 
    EndIf 
EndProcedure 

Procedure Easy_LAD(*Token.sToken) 
    Define.l lngI 
    
    Debug "> Move Stack" 
    For lngI = 0 To CountList(Stack())-1 
        SelectElement(Stack(), lngI) 
        If Stack()\stoType = #TYPString 
            SetString(Stack()\stoDataS, Speicher(lngI)) 
        ElseIf Stack()\stoType = #TYPLong 
            SetLong(Stack()\stoDataL,   Speicher(lngI)) 
        EndIf 
        Debug ">> Move " + Str(lngI) + ": " + Str(Stack()\stoDataL) + " / " + Stack()\stoDataS 
    Next 
    ClearList(Stack()) 
EndProcedure 

Procedure Easy_BYT(*Token.sToken) 
    Define.s AssmResult 
    
    If *Token\tokType1 = #TYPMemory And *Token\tokType2 = #TYPLong 
        AssmResult = GetString(Speicher(Val(*Token\tokData1))) 
        AssmResult + Chr(Val(*Token\tokData2)) 
        SetString(AssmResult ,Speicher(Val(*Token\tokData1)))              
    EndIf 
EndProcedure 

;- Sprung anweisungen 
Procedure Easy_JMP(*Token.sToken) 
    Define.l lngZeile, JMPPointer 
    
    lngZeile = ResolvePointer(*Token\tokData1) 
    If lngZeile <> -1 
        JMPPointer = ListIndex(Source()) 
        SelectElement(Source(), lngZeile) 
        Debug "> Jump Command" 
        Debug ">> Jump to: " + Str(lngZeile) 
        Debug ">> Saved Point: " + Str(JMPPointer)        
        AddElement(JMPStack()) 
        JMPStack() = JMPPointer 
    EndIf 
EndProcedure 

Procedure Easy_RET(*Token.sToken) 
    Define.l JMPPointer 
    
    LastElement(JMPStack()) 
    JMPPointer = JMPStack() 
    DeleteElement(JMPStack()) 
    Debug "> Return Command" 
    Debug ">> Return to: " +  Str(JMPPointer) 
    SelectElement(Source(), JMPPointer) 
    JMPPointer = 0 
EndProcedure 

Procedure Easy_GOT(*Token.sToken) 
    Define.l lngZeile 
    
    lngZeile = ResolvePointer(*Token\tokData1) 
    If lngZeile <> -1 
        Debug "> Goto Command" 
        Debug ">> Goto: " + Str(lngZeile) 
        SelectElement(Source(), lngZeile)        
    EndIf 
EndProcedure 
;- AND,OR,XOR Operant 
Procedure Easy_AND(*Token.sToken) 
    Define.l SpeicherA, SpeicherB 
    
    Select *Token\tokType1 
        Case #TYPLong: SpeicherA = Val(*Token\tokData1) 
        Case #TYPMemory 
            If Speicher(Val(*Token\tokData1))\MemType = #TYPLong 
                SpeicherA = GetLong(Speicher(Val(*Token\tokData1))) 
            EndIf 
    EndSelect 
    
    Select *Token\tokType2 
        Case #TYPLong: SpeicherB = Val(*Token\tokData2) 
        Case #TYPMemory 
            If Speicher(Val(*Token\tokData2))\MemType = #TYPLong 
                SpeicherA = GetLong(Speicher(Val(*Token\tokData2))) 
            EndIf 
    EndSelect    
    
    SpeicherA = SpeicherA & SpeicherB 
    SetLong(SpeicherA, Speicher(0)) 
EndProcedure 

Procedure Easy_OR(*Token.sToken) 
    Define.l SpeicherA, SpeicherB 
    
    Select *Token\tokType1 
        Case #TYPLong: SpeicherA = Val(*Token\tokData1) 
        Case #TYPMemory 
            If Speicher(Val(*Token\tokData1))\MemType = #TYPLong 
                SpeicherA = GetLong(Speicher(Val(*Token\tokData1))) 
            EndIf 
    EndSelect 
    
    Select *Token\tokType2 
        Case #TYPLong: SpeicherB = Val(*Token\tokData2) 
        Case #TYPMemory 
            If Speicher(Val(*Token\tokData2))\MemType = #TYPLong 
                SpeicherA = GetLong(Speicher(Val(*Token\tokData2))) 
            EndIf 
    EndSelect    
    
    SpeicherA = SpeicherA | SpeicherB 
    SetLong(SpeicherA, Speicher(0)) 
EndProcedure 

Procedure Easy_XOR(*Token.sToken) 
    Define.l SpeicherA, SpeicherB 
    
    Select *Token\tokType1 
        Case #TYPLong: SpeicherA = Val(*Token\tokData1) 
        Case #TYPMemory 
            If Speicher(Val(*Token\tokData1))\MemType = #TYPLong 
                SpeicherA = GetLong(Speicher(Val(*Token\tokData1))) 
            EndIf 
    EndSelect 
    
    Select *Token\tokType2 
        Case #TYPLong: SpeicherB = Val(*Token\tokData2) 
        Case #TYPMemory 
            If Speicher(Val(*Token\tokData2))\MemType = #TYPLong 
                SpeicherA = GetLong(Speicher(Val(*Token\tokData2))) 
            EndIf 
    EndSelect    
    
    SpeicherA = SpeicherA ! SpeicherB 
    SetLong(SpeicherA, Speicher(0)) 
EndProcedure 

;- Structure Construct 
Procedure Easy_STC(*Token.sToken) 
    Define.l NeedMem, CurrentMem 
    
    ForEach StructStack() 
        Select StructStack() 
            Case "0" NeedMem + 1: Case "1" NeedMem + 2 
            Case "2" NeedMem + 4: Case "3" NeedMem + 4 
        EndSelect 
    Next 
    
    If *Token\tokData1 = #TYPMemory And NeedMem > 0 
        FreeMemory(Speicher(*Token\tokData1)\MemPointer) 
        Speicher(*Token\tokData1)\MemPointer = AllocateMemory(NeedMem) 
        Speicher(*Token\tokData1)\MemSize = 0 
        Speicher(*Token\tokData1)\MemType = #TYPPointer 
        
        ForEach StructStack() 
            If StructStack() = #STCString 
                PokeL(Speicher(*Token\tokData1)\MemPointer+CurrentMem, AllocateMemory(0)) 
            EndIf 
            Select StructStack() 
                Case "0" CurrentMem + 1: Case "1" CurrentMem + 2 
                Case "2" CurrentMem + 4: Case "3" CurrentMem + 4 
            EndSelect                        
        Next 
    EndIf 
EndProcedure 

Procedure Easy_STB(*Token.sToken) 
    Define.l lngNewMem 
    
    If *Token\tokData1 = #TYPLong 
        AddElement(StructStack()) 
        Select *Token\tokData2 
            Case "0": StructStack() = #STCByte 
            Case "1": StructStack() = #STCWord 
            Case "2": StructStack() = #STCDWord 
            Case "3": StructStack() = #STCString 
        EndSelect 
    EndIf 
EndProcedure 

;- Vergleich Funktionen 
Procedure Easy_CMP(*Token.sToken) 
    Define.sMemory CMPMemberA, CMPMemberB 
    Define.l lngMemberA, lngMemberB 
    Define.s strMemberA, strMemberB 
    
    Select *Token\tokType1 
        Case #TYPLong 
            CMPMemberA\MemPointer = AllocateMemory(4) 
            CMPMemberA\MemType = #TYPLong 
            CMPMemberA\MemSize = 4 
            PokeL(CMPMemberA\MemPointer, Val(*Token\tokData1)) 
        Case #TYPString 
            CMPMemberA\MemPointer = AllocateMemory(Len(*Token\tokData1)+1) 
            CMPMemberA\MemType = #TYPString 
            CMPMemberA\MemSize = Len(*Token\tokData1) 
            PokeS(CMPMemberA\MemPointer, *Token\tokData1, Len(*Token\tokData1)) 
        Case #TYPMemory 
            CopyMemory(Speicher(Val(*Token\tokData1)), CMPMemberA, SizeOf(sMemory))            
    EndSelect 
    
    Select *Token\tokType2 
        Case #TYPLong 
            CMPMemberB\MemPointer = AllocateMemory(4) 
            CMPMemberB\MemType = #TYPLong 
            CMPMemberB\MemSize = 4 
            PokeL(CMPMemberB\MemPointer, Val(*Token\tokData2)) 
        Case #TYPString 
            CMPMemberB\MemPointer = AllocateMemory(Len(*Token\tokData2)+1) 
            CMPMemberB\MemType = #TYPString 
            CMPMemberB\MemSize = Len(*Token\tokData2) 
            PokeS(CMPMemberB\MemPointer, *Token\tokData2, Len(*Token\tokData2)) 
        Case #TYPMemory 
            CopyMemory(Speicher(Val(*Token\tokData2)), CMPMemberB, SizeOf(sMemory))            
    EndSelect    
    
    Debug "> Compare Command:" 
    If CMPMemberA\MemType = CMPMemberB\MemType 
        Debug ">> Compare Members:" 
        Select CMPMemberA\MemType 
            Case #TYPLong 
                lngMemberA = PeekL(CMPMemberA\MemPointer) 
                lngMemberB = PeekL(CMPMemberB\MemPointer) 
                Debug ">> MemberA: " + Str(lngMemberA) 
                Debug ">> MemberB: " + Str(lngMemberB) 
                
                If lngMemberA = lngMemberB 
                    CMPResult = #CMPEqual 
                    Debug ">> Compare: Equal" 
                ElseIf lngMemberA < lngMemberB 
                    CMPResult = #CMPLower 
                    Debug ">> Compare: Lower"                    
                ElseIf lngMemberA > lngMemberB 
                    CMPResult = #CMPHigher 
                    Debug ">> Compare: Higher"                    
                EndIf 
            Case #TYPString 
                strMemberA = PeekS(CMPMemberA\MemPointer, CMPMemberA\MemSize) 
                strMemberB = PeekS(CMPMemberB\MemPointer, CMPMemberB\MemSize) 
                Debug ">> MemberA: " + strMemberA 
                Debug ">> MemberB: " + strMemberB      
                
                If strMemberA = strMemberB 
                    CMPResult = #CMPEqual 
                    Debug ">> Compare: Equal" 
                ElseIf Len(strMemberA) < Len(strMemberB) 
                    CMPResult = #CMPLower 
                    Debug ">> Compare: Lower"                    
                ElseIf Len(strMemberA) > Len(strMemberB) 
                    CMPResult = #CMPHigher 
                    Debug ">> Compare: Higher"      
                Else 
                    CMPResult = #CMPNotEqual 
                    Debug ">> Compare: Not Equal" 
                EndIf 
        EndSelect 
    Else 
        Debug ">> Compare failed !" 
        Debug ">> Members are diffrent !" 
        Debug ">> MemberA: " + Str(CMPMemberA\MemType) 
        Debug ">> MemberB: " + Str(CMPMemberB\MemType) 
    EndIf 
EndProcedure 

Procedure Easy_JL(*Token.sToken) 
    Define.l lngZeile 
    
    If CMPResult = #CMPLower 
        lngZeile = ResolvePointer(*Token\tokData1) 
        If lngZeile <> -1 
            Debug "> Jump on lower" 
            Debug ">> Goto: " + Str(lngZeile) 
            SelectElement(Source(), lngZeile)        
        EndIf        
    EndIf 
EndProcedure 

Procedure Easy_JNL(*Token.sToken) 
    Define.l lngZeile 
    
    If CMPResult <> #CMPLower And CMPResult <> #CMPWrong 
        lngZeile = ResolvePointer(*Token\tokData1) 
        If lngZeile <> -1 
            Debug "> Jump not lower" 
            Debug ">> Goto: " + Str(lngZeile) 
            SelectElement(Source(), lngZeile)        
        EndIf    
    EndIf 
EndProcedure 

Procedure Easy_JE(*Token.sToken) 
    Define.l lngZeile 
    
    If CMPResult = #CMPEqual 
        lngZeile = ResolvePointer(*Token\tokData1) 
        If lngZeile <> -1 
            Debug "> Jump equals" 
            Debug ">> Goto: " + Str(lngZeile) 
            SelectElement(Source(), lngZeile)        
        EndIf    
    EndIf 
EndProcedure 

Procedure Easy_JNE(*Token.sToken) 
    Define.l lngZeile 
    
    If CMPResult <> #CMPEqual And CMPResult <> #CMPWrong 
        lngZeile = ResolvePointer(*Token\tokData1) 
        If lngZeile <> -1 
            Debug "> jump not equals" 
            Debug ">> Goto: " + Str(lngZeile) 
            SelectElement(Source(), lngZeile)        
        EndIf    
    EndIf 
EndProcedure 

Procedure Easy_JG(*Token.sToken) 
    Define.l lngZeile 
    
    If CMPResult = #CMPHigher 
        lngZeile = ResolvePointer(*Token\tokData1) 
        If lngZeile <> -1 
            Debug "> jump greater" 
            Debug ">> Goto: " + Str(lngZeile) 
            SelectElement(Source(), lngZeile)        
        EndIf    
    EndIf      
EndProcedure 

Procedure Easy_JNG(*Token.sToken) 
    Define.l lngZeile 
    
    If CMPResult <> #CMPHigher And CMPResult <> #CMPWrong 
        lngZeile = ResolvePointer(*Token\tokData1) 
        If lngZeile <> -1 
            Debug "> jump not greater" 
            Debug ">> Goto: " + Str(lngZeile) 
            SelectElement(Source(), lngZeile)        
        EndIf    
    EndIf      
EndProcedure 

;- Lib Call Befehle 
Procedure Easy_STO(*Token.sToken) 
    Define.l lngPointer, lngMemSize 
    
    Debug "> Store Data" 
    Select *Token\tokType1 
        Case #TYPLong 
            AddElement(Stack()) 
            Stack()\stoDataL = Val(*Token\tokData1) 
            Stack()\stoType = #TYPLong 
            Debug ">> Store Long" 
        Case #TYPString 
            AddElement(Stack()) 
            Stack()\stoDataS = *Token\tokData1 
            Stack()\stoType = #TYPString      
            Debug ">> Store String" 
        Case #TYPMemory 
            AddElement(Stack()) 
            lngPointer = Speicher(Val(*Token\tokData1))\MemPointer 
            lngMemSize = Speicher(Val(*Token\tokData1))\MemSize 
            Select Speicher(Val(*Token\tokData1))\MemType 
                Case #TYPLong 
                    If Speicher(Val(*Token\tokData1))\MemType = #TYPLong 
                        Stack()\stoDataL = PeekL(lngPointer) 
                        Stack()\stoType  = #TYPLong 
                    EndIf 
                    Debug ">> Store Long (from Memory)" 
                Case #TYPString 
                    If Speicher(Val(*Token\tokData1))\MemType = #TYPString 
                        Stack()\stoDataS = PeekS(lngPointer, lngMemSize) 
                        Stack()\stoType = #TYPString 
                    EndIf 
                    Debug ">> Store String (from Memory)" 
                Case #TYPPointer 
                    If Speicher(Val(*Token\tokData1))\MemType = #TYPString 
                        Stack()\stoDataL = PeekL(lngPointer) 
                        Stack()\stoType = #TYPPointer 
                    EndIf 
                    Debug ">> Store Pointer (from Memory)" 
            EndSelect 
        Case #TYPPointer 
            AddElement(Stack()) 
            Stack()\stoDataL = Speicher(Val(*Token\tokData1))\MemPointer 
            Stack()\stoType = #TYPPointer 
            Debug ">> Store Pointer" 
    EndSelect 
    Debug "------ END STO CMD ------" 
EndProcedure 

Procedure Easy_OPN(*Token.sToken) 
    Define.s strLibName 
    
    Select *Token\tokType1 
        Case #TYPString 
            strLibName = *Token\tokData1 
        Case #TYPMemory 
            If Speicher(Val(*Token\tokData1))\MemType = #TYPString 
                strLibName = GetString(Speicher(Val(*Token\tokData1))) 
            EndIf 
    EndSelect 
    
    SetLong(OpenLibrary(#PB_Any, strLibName), Speicher(Val(*Token\tokData2))) 
EndProcedure 

Procedure Easy_CLS(*Token.sToken) 
    Define.l lngLibPtr 
    
    Select *Token\tokType1 
        Case #TYPLong 
            lngLibPtr = Val(*Token\tokData1) 
        Case #TYPMemory 
            If Speicher(Val(*Token\tokData1)) 
                lngLibPtr = GetLong(Speicher(Val(*Token\tokData1))) 
            EndIf 
    EndSelect 
    
    If lngLibPtr <> 0 
        CloseLibrary(lngLibPtr) 
    EndIf 
EndProcedure 

Procedure Easy_CAL(*Token.sToken) 
    Define.s FunkName 
    Define.l lngLibPtr 
    
    ; LibraryPointer 
    Select *Token\tokType1 
        Case #TYPLong  : lngLibPtr = Val(*Token\tokData1) 
        Case #TYPMemory: lngLibPtr = GetLong(Speicher(Val(*Token\tokData1))) 
    EndSelect 
    
    ; FunkName 
    Select *Token\tokType2 
        Case #TYPString: FunkName = *Token\tokData2 
        Case #TYPMemory: FunkName = GetString(Speicher(Val(*Token\tokData2))) 
    EndSelect 
    
    lngFunkPtr = IsFunction(lngLibPtr, FunkName) 
    Debug "> Lib CALL" 
    Debug ">> FunkName: " + FunkName 
    Debug ">> LibPtr: " + Str(lngLibPtr) 
    Debug ">> CalPtr: " + Str(lngFunkPtr) 
    
    If lngFunkPtr <> 0 
        ForEach Stack() 
            If Stack()\stoType = #TYPString 
                lngDataPush = @Stack()\stoDataS 
            Else 
                lngDataPush = Stack()\stoDataL 
            EndIf 
            !PUSH dword [v_lngDataPush] 
        Next 

        !CALL    [v_lngFunkPtr] 
        !MOV     dword [v_lngResult], Eax 
        
        SetLong(lngResult, Speicher(0)) 
        Debug ">> Lib CALL Result: " + Str(GetLong(Speicher(0))) 
        ClearList(Stack()) 
    EndIf 
EndProcedure 

;- Sonstige Funktionen 
Procedure SetString(strString.s, *MemPoint.sMemory)    
    If *MemPoint\MemSize < Len(strString) 
        *MemPoint\MemPointer = ReAllocateMemory(*MemPoint\MemPointer, Len(strString)) 
    EndIf 
    PokeS(*MemPoint\MemPointer, strString);, Len(strString)) 
    *MemPoint\MemSize = Len(strString) 
    *MemPoint\MemType = #TYPString 
EndProcedure 

Procedure.s GetString(*MemPoint.sMemory) 
    If *MemPoint\MemType = #TYPString 
        ProcedureReturn PeekS(*MemPoint\MemPointer, *MemPoint\MemSize) 
    Else 
        ProcedureReturn "" 
    EndIf 
EndProcedure 

Procedure SetLong(lngLong.l, *MemPoint.sMemory) 
    If *MemPoint\MemSize > 4 
        *MemPoint\MemPointer = ReAllocateMemory(*MemPoint\MemPointer, 4) 
    EndIf 
    PokeL(*MemPoint\MemPointer, lngLong) 
    *MemPoint\MemSize = 4 
    *MemPoint\MemType = #TYPLong 
EndProcedure 

Procedure.l GetLong(*MemPoint.sMemory) 
    If *MemPoint\MemType = #TYPLong 
        ProcedureReturn PeekL(*MemPoint\MemPointer) 
    Else 
        ProcedureReturn 0 
    EndIf 
EndProcedure 

Procedure.s AssembleParameter() 
    Define.s tmpParameter, strResult 
    
    Repeat 
        tmpParameter = ProgramParameter() 
        If tmpParameter <> "": strResult + tmpParameter + " ": EndIf 
    Until tmpParameter = "" 
    ProcedureReturn Trim(strResult) 
EndProcedure 

Procedure.l ReadStructure(*Var.AllTypes, *Source.l, *Struc.BYTE) 
    Define.l Length 
    Define.l Differenz 
    
    Differenz = *Source 
    While *Struc\b 
        Select *Struc\b 
            Case 'b': CopyMemory(*Source, *Var, 1): *Var + 1: *Source + 1 
            Case 'w': CopyMemory(*Source, *Var, 2): *Var + 2: *Source + 2 
            Case 'l': CopyMemory(*Source, *Var, 4): *Var + 4: *Source + 4 
            Case 'f': CopyMemory(*Source, *Var, 4): *Var + 4: *Source + 4 
            Case 's' 
                Length = PeekL(*Source)        : *Source + 4 
                *Var\s = PeekS(*Source, Length): *Source + Length 
                *Var + 4 
        EndSelect 
        *Struc + 1 
    Wend 
    
    ProcedureReturn *Source-Differenz 
EndProcedure 

Procedure.l ResolvePointer(strPtrName.s) 
    ForEach Points() 
        If Points()\potName = strPtrName 
            ProcedureReturn Points()\potZeile 
        EndIf 
    Next 
    ProcedureReturn -1 
EndProcedure 

Procedure.l MemCopy(*SorcMem.sMemory, *DestMem.sMemory) 
    Define.l NewMem 
    
    If *DestMem\MemSize < *SorcMem\MemSize 
        NewMem = ReAllocateMemory(*DestMem\MemPointer, *SorcMem\MemSize) 
        If NewMem <> 0: *DestMem\MemPointer = NewMem: EndIf 
    EndIf 
    CopyMemory(*SorcMem\MemPointer, *DestMem\MemPointer, *SorcMem\MemSize) 
    *DestMem\MemSize = *SorcMem\MemSize 
    *DestMem\MemType = *SorcMem\MemType 
EndProcedure
; IDE Options = PureBasic v4.02 (Windows - x86)
; Folding = -------