Const Direkt             = 1
Const Immediate          = 2
Const VarInt             = 3
Const CMarke             = 4
Const RegisterEAX        = 5
Const RegisterEBX        = 6
Const RegisterIndirektEAX= 7
Const RegisterIndirektEBX= 8
Const KeinParameter      = 9


Type ConstIntTyp
 Field Name$
 Field Wert
End Type 

Type MarkeTyp
 Field Name$
 Field Adresse
End Type

Type VariableTyp
 Field Name$
 Field Adresse
 Field Wert
End Type

Type AsmBefehlTypTyp
 Field BefehlNr
 Field Befehl$
 Field Parameter1Typ
 Field Parameter2Typ
 Field Lang
End Type

Type AssemblerTyp
 Field Position
 Field InputDatei$
 Field OutputDatei$

 Field Speicher

 Field InputDateiNr
 Field OutputDateiNr

 Field AusgabeArt
End Type

Type AsmBefehlTyp
 Field Parameter1$
 Field Parameter2$
 Field Parameter1Typ
 Field Parameter2Typ
 Field Position
 Field BefehlNr
End Type

Global ConstInt.ConstIntTyp
Global Marke.MarkeTyp
Global Variable.VariableTyp
Global AsmBefehlTyp.AsmBefehlTypTyp
Global Assembler.AssemblerTyp
Global AsmBefehl.AsmBefehlTyp


Global BefehlLang[32]
Global BefehlName$[32]
Global BefehlTyp$[32]

;MOV
Const MOV_EAX_EBX                 =   1                                                                       
Const MOV_EBX_EAX                 =   2 

Const MOV_EAX_Const               =   3                                                                       
Const MOV_EBX_Const               =   4

Const RESTORE_EAX_CONST           =   5
Const RESTORE_EBX_CONST           =   6

Const RESTORE_EAX_EBX             =   7
Const RESTORE_EBX_EAX             =   8
   
Const LOAD_EAX_CONST              =   9
Const LOAD_EBX_CONST              =  10

Const LOAD_EAX_EBX                =  11
Const LOAD_EBX_EAX                =  12
 
;Mathe                                                                     
Const ADD_EAX_EBX                 =  13
Const NEG_EAX                     =  14
Const SUB_EAX_EBX                 =  15
Const DIV_EAX_EBX                 =  16     
Const MUL_EAX_EBX                 =  17

;Setzt Zero=True
;EAX und EBX
                                         
Const LT_EAX_EBX                  =  18 ;* <
Const GT_EAX_EBX                  =  19 ;* >
Const LE_EAX_EBX                  =  20 ;* <=
Const GE_EAX_EBX                  =  21 ;* >=
Const EQ_EAX_EBX                  =  22 ;* <>
Const NE_EAX_EBX                  =  23 ;* =
                                       
;Push                                 
Const Push_EAX                    =  24
Const Push_EBX                    =  25
                                       
;Pop                                   
Const POP_EAX                     =  26
Const POP_EBX                     =  27
                                       
;Function                             
Const Call_Int                    =  28

Const JMP_CONST                   =  29
Const JZ_CONST                    =  30

Const Ret                         =  31
Const Call                        =  32

Type TaskTyp
 Field Speicher
 Field SpeicherByte

 Field EIP       
 Field ZERO

 ;Register
 Field EAX     
 Field EBX

 Field StackZeiger
 
End Type

Global Task.TaskTyp

 
Function Run_VM()
 Repeat
  Select PeekByte(Task\Speicher,Task\EIP)
   Case MOV_EAX_EBX
    Task\EAX=Task\EBX   
    Task\EIP=Task\EIP+1                                                                                   
   Case MOV_EBX_EAX
    Task\EBX=Task\EAX               
    Task\EIP=Task\EIP+1
 
   Case MOV_EAX_CONST
    Task\EAX=PeekInt(Task\Speicher,Task\EIP+1)
    Task\EIP=Task\EIP+5
   Case MOV_EBX_CONST
    Task\EBX=PeekInt(Task\Speicher,Task\EIP+1)
    Task\EIP=Task\EIP+5   

   Case RESTORE_EAX_CONST
    PokeInt Task\Speicher,PeekInt(Task\Speicher,Task\EIP+1),Task\EAX   
    Task\EIP=Task\EIP+5           
   Case RESTORE_EBX_CONST         
    PokeInt Task\Speicher,PeekInt(Task\Speicher,Task\EIP+1),Task\EBX     
    Task\EIP=Task\EIP+5 

   Case RESTORE_EAX_EBX
    PokeInt Task\Speicher,Task\EAX,Task\EBX 
    Task\EIP=Task\EIP+1               
   Case RESTORE_EBX_EAX           
    PokeInt Task\Speicher,Task\EBX,Task\EAX 
    Task\EIP=Task\EIP+1

   Case LOAD_EAX_CONST
    Task\EAX=PeekInt(Task\Speicher,PeekInt(Task\Speicher,Task\EIP+1))
    Task\EIP=Task\EIP+5               
   Case LOAD_EBX_CONST
    Task\EBX=PeekInt(Task\Speicher,PeekInt(Task\Speicher,Task\EIP+1))
    Task\EIP=Task\EIP+5

   Case LOAD_EAX_EBX
    Task\EAX=PeekInt(Task\Speicher,Task\EBX)             
    Task\EIP=Task\EIP+1                 
   Case LOAD_EBX_EAX
    Task\EBX=PeekInt(Task\Speicher,Task\EAX)               
    Task\EIP=Task\EIP+1 

   Case ADD_EAX_EBX
    Task\EAX=Task\EAX+Task\EBX
    Task\EIP=Task\EIP+1               
   Case NEG_EAX 
    Task\EAX=-Task\EAX
    Task\EIP=Task\EIP+1                   
   Case SUB_EAX_EBX   
    Task\EAX=Task\EAX-Task\EBX 
    Task\EIP=Task\EIP+1                 
   Case DIV_EAX_EBX 
    Task\EAX=Task\EAX/Task\EBX
    Task\EIP=Task\EIP+1               
   Case MUL_EAX_EBX
    Task\EAX=Task\EAX*Task\EBX                 
    Task\EIP=Task\EIP+1

   Case LT_EAX_EBX ; <
    If Task\EAX<Task\EBX Then
      Task\ZERO=True
     Else
      Task\ZERO=False 
    End If   
    Task\EIP=Task\EIP+1

   Case GT_EAX_EBX ; >
    If Task\EAX>Task\EBX Then
     Task\ZERO=True
    Else
     Task\ZERO=False 
    End If 
    Task\EIP=Task\EIP+1

   Case LE_EAX_EBX ; <=
    If Task\EAX<=Task\EBX Then
     Task\ZERO=True
    Else
     Task\ZERO=False 
    End If 
    Task\EIP=Task\EIP+1

   Case GE_EAX_EBX ; >=
    If Task\EAX>=Task\EBX Then
     Task\ZERO=True
    Else
     Task\ZERO=False 
    End If
    Task\EIP=Task\EIP+1
   Case EQ_EAX_EBX ; <>
    If Task\EAX<>Task\EBX Then
      Task\ZERO=True
    Else
      Task\ZERO=False 
    End If 
    Task\EIP=Task\EIP+1

   Case NE_EAX_EBX ; =
    If Task\EAX=Task\EBX Then
      Task\ZERO=True
    Else
      Task\ZERO=False 
    End If   
    Task\EIP=Task\EIP+1
                   
   Case Push_EAX
    PushInt Task\EAX
    Task\EIP=Task\EIP+1             
   Case Push_EBX                   
    PushInt Task\EBX
    Task\EIP=Task\EIP+1                                         
                                 
   Case POP_EAX
    Task\EAX=PopInt()
    Task\EIP=Task\EIP+1                   
   Case POP_EBX                   
    Task\EAX=PopInt()
    Task\EIP=Task\EIP+1 
           
   Case Call_Int
    Select PeekInt(Task\Speicher,Task\EIP+1)
     Case 1
      Print Task\EAX
     Case 3
      Print GetString$(Task\EAX)
     Case 2
      Print "ENDE"
      Return 
    End Select
    Task\EIP=Task\EIP+5


   Case JMP_CONST
    Task\EIP=PeekInt(Task\Speicher,Task\EIP+1)

   Case JZ_CONST
    If Task\ZERO=True Then
      Task\EIP=PeekInt(Task\Speicher,Task\EIP+1)
     Else
      Task\EIP=Task\EIP+5
    End If 

   Case RET
    Task\EIP=PopInt()                 
   Case Call                   
    PushInt(Task\EIP+5)
    Task\EIP=PeekInt(Task\Speicher,Task\EIP+1)   
  End Select 
 Forever
End Function

Function SetString(P,S$)
 LenS=Len(S$)-1
 For X=0 To LenS
  PokeByte Task\Speicher,P+X,Asc(Mid$(S$,X,1))
 Next
End Function 

Function GetString$(P)
 Zeichen=PeekByte(Task\Speicher,P)
 While Zeichen<>0
  S$=S$+Chr$(Zeichen)
  P=P+1
  Zeichen=PeekByte(Task\Speicher,P)
 Wend
 Return S$ 
End Function 


Function GetInt(IntNr)
 PeekInt(Task\Speicher,IntNr*4+5)
End Function 

Function PushInt(IntWert)
 PokeInt Task\Speicher,Task\StackZeiger,IntWert
 Task\StackZeiger=Task\StackZeiger+4
End Function

Function PopInt()
 Task\StackZeiger=Task\StackZeiger-4
 Return PeekInt(Task\Speicher,Task\StackZeiger)
End Function

                 
Function Inst_Assembler()
 BefehlLang[ 1]=1
 BefehlName[ 1]="MOV_EAX_EBX"
 BefehlTyp [ 1]="MOV"

 BefehlLang[ 2]=1                                                                             
 BefehlName[ 2]="MOV_EBX_EAX"
 BefehlTyp [ 2]="MOV"

 BefehlLang[ 3]=5           
 BefehlName[ 3]="MOV_EAX_Const" 
 BefehlTyp [ 3]="MOV"

 BefehlLang[ 4]=5                                                                                 
 BefehlName[ 4]="MOV_EBX_Const"
 BefehlTyp [ 4]="MOV"

 BefehlLang[ 5]=5               
 BefehlName[ 5]="RESTORE_EAX_CONST"
 BefehlTyp [ 5]="RESTORE"

 BefehlLang[ 6]=5         
 BefehlName[ 6]="RESTORE_EBX_CONST"
 BefehlTyp [ 6]="RESTORE"

 BefehlLang[ 7]=1         
 BefehlName[ 7]="RESTORE_EAX_EBX"
 BefehlTyp [ 7]="RESTORE"

 BefehlLang[ 8]=1         
 BefehlName[ 8]="RESTORE_EBX_EAX"
 BefehlTyp [ 8]="RESTORE" 
           
 BefehlLang[ 9]=5
 BefehlName[ 9]="LOAD_EAX_CONST"
 BefehlTyp [ 1]="LOAD"

 BefehlLang[10]=5           
 BefehlName[10]="LOAD_EBX_CONST"
 BefehlTyp [10]="LOAD"

 BefehlLang[11]=1           
 BefehlName[11]="LOAD_EAX_EBX"
 BefehlTyp [11]="LOAD"

 BefehlLang[12]=1               
 BefehlName[12]="LOAD_EBX_EAX"
 BefehlTyp [12]="LOAD"

 BefehlLang[13]=1                                                                                   
 BefehlName[13]="ADD_EAX_EBX"
 BefehlTyp [13]="LOAD"

 BefehlLang[14]=1               
 BefehlName[14]="NEG_EAX" 
 BefehlTyp [14]="NEG"
 
 BefehlLang[15]=1                 
 BefehlName[15]="SUB_EAX_EBX" 
 BefehlTyp [15]="SUB"
 
 BefehlLang[16]=1               
 BefehlName[16]="DIV_EAX_EBX"
 BefehlTyp [16]="DIV"
 
 BefehlLang[17]=1               
 BefehlName[17]="MUL_EAX_EBX" 
 BefehlTyp [17]="MUL"
 
 BefehlLang[18]=1                                                       
 BefehlName[18]="LT_EAX_EBX"
 BefehlTyp [18]="LT"
 
 BefehlLang[19]=1             
 BefehlName[19]="GT_EAX_EBX"
 BefehlTyp [19]="GT"
 
 BefehlLang[20]=1                 
 BefehlName[20]="LE_EAX_EBX"
 BefehlTyp [20]="LE"
 
 BefehlLang[21]=1               
 BefehlName[21]="GE_EAX_EBX"
 BefehlTyp [ 1]="GE"
 
 BefehlLang[22]=1                 
 BefehlName[22]="EQ_EAX_EBX"
 BefehlTyp [22]="EQ"
 
 BefehlLang[23]=1               
 BefehlName[23]="NE_EAX_EBX"
 BefehlTyp [23]="NE"
 
 BefehlLang[24]=1                                               
 BefehlName[24]="PUSH_EAX" 
 BefehlTyp [24]="PUSH"
   
 BefehlLang[25]=1               
 BefehlName[25]="PUSH_EBX" 
 BefehlTyp [25]="PUSH"
 
 BefehlLang[26]=1                                                   
 BefehlName[26]="POP_EAX"
 BefehlTyp [26]="POP"
 
 BefehlLang[27]=1                   
 BefehlName[27]="POP_EBX"
 BefehlTyp [27]="POP"
 
 BefehlLang[28]=5                                                 
 BefehlName[28]="CALL_INT"
 BefehlTyp [28]="CALL_INT"
 
 BefehlLang[29]=5                   
 BefehlName[29]="JMP_CONST" 
 BefehlTyp [29]="JMP"
   
 BefehlLang[30]=5               
 BefehlName[30]="JZ_CONST"
 BefehlTyp [30]="JZ"
 
 BefehlLang[31]=1                   
 BefehlName[31]="RET"   
 BefehlTyp [31]="RET"
                     
 BefehlLang[32]=5
 BefehlName[32]="CAll"
 BefehlTyp [32]="CALL"

     
 Inst_AsmBefehl "MOV"    ,MOV_EAX_EBX      ,RegisterEAX  ,RegisterEBX        ,1   
 Inst_AsmBefehl "MOV"    ,MOV_EBX_EAX      ,RegisterEBX  ,RegisterEAX        ,1 

 Inst_AsmBefehl "MOV"    ,MOV_EAX_Const    ,RegisterEAX  ,Direkt             ,5   
 Inst_AsmBefehl "MOV"    ,MOV_EBX_Const    ,RegisterEBX  ,Direkt             ,5
 Inst_AsmBefehl "MOV"    ,MOV_EAX_Const    ,RegisterEAX  ,CMarke             ,5   
 Inst_AsmBefehl "MOV"    ,MOV_EBX_Const    ,RegisterEBX  ,CMarke             ,5

 Inst_AsmBefehl "RESTORE",RESTORE_EAX_CONST,RegisterEAX  ,Immediate          ,5
 Inst_AsmBefehl "RESTORE",RESTORE_EBX_CONST,RegisterEBX  ,Immediate          ,5
 Inst_AsmBefehl "RESTORE",RESTORE_EAX_CONST,RegisterEAX  ,CMarke             ,5
 Inst_AsmBefehl "RESTORE",RESTORE_EBX_CONST,RegisterEBX  ,CMarke             ,5
 Inst_AsmBefehl "RESTORE",RESTORE_EAX_CONST,RegisterEAX  ,VarInt             ,5
 Inst_AsmBefehl "RESTORE",RESTORE_EBX_CONST,RegisterEBX  ,VarInt             ,5

 Inst_AsmBefehl "RESTORE",RESTORE_EAX_EBX  ,RegisterEAX  ,RegisterIndirektEBX,1
 Inst_AsmBefehl "RESTORE",RESTORE_EBX_EAX  ,RegisterEBX  ,RegisterIndirektEAX,1
         
 Inst_AsmBefehl "LOAD"   ,LOAD_EAX_EBX     ,RegisterEAX  ,RegisterIndirektEBX,1               
 Inst_AsmBefehl "LOAD"   ,LOAD_EBX_EAX     ,RegisterEBX  ,RegisterIndirektEAX,1
 
 Inst_AsmBefehl "LOAD"   ,LOAD_EAX_CONST   ,RegisterEAX  ,CMarke             ,5                 
 Inst_AsmBefehl "LOAD"   ,LOAD_EBX_CONST   ,RegisterEBX  ,CMarke             ,5
 Inst_AsmBefehl "LOAD"   ,LOAD_EAX_CONST   ,RegisterEAX  ,VarInt             ,5                 
 Inst_AsmBefehl "LOAD"   ,LOAD_EBX_CONST   ,RegisterEBX  ,VarInt             ,5             
 Inst_AsmBefehl "LOAD"   ,LOAD_EAX_CONST   ,RegisterEAX  ,Immediate          ,5                 
 Inst_AsmBefehl "LOAD"   ,LOAD_EBX_CONST   ,RegisterEBX  ,Immediate          ,5

                                                               
 Inst_AsmBefehl "ADD"    ,ADD_EAX_EBX      ,RegisterEAX  ,RegisterEBX        ,1                 
 Inst_AsmBefehl "NEG"    ,NEG_EAX          ,RegisterEAX  ,KeinParameter      ,1                     
 Inst_AsmBefehl "SUB"    ,SUB_EAX_EBX      ,RegisterEAX  ,RegisterEBX        ,1                 
 Inst_AsmBefehl "DIV"    ,DIV_EAX_EBX      ,RegisterEAX  ,RegisterEBX        ,1                 
 Inst_AsmBefehl "MUL"    ,MUL_EAX_EBX      ,RegisterEAX  ,RegisterEBX        ,1                 
                                         
 Inst_AsmBefehl "LT"     ,LT_EAX_EBX       ,RegisterEAX  ,RegisterEBX        ,1               
 Inst_AsmBefehl "GT"     ,GT_EAX_EBX       ,RegisterEAX  ,RegisterEBX        ,1                 
 Inst_AsmBefehl "LE"     ,LE_EAX_EBX       ,RegisterEAX  ,RegisterEBX        ,1               
 Inst_AsmBefehl "GE"     ,GE_EAX_EBX       ,RegisterEAX  ,RegisterEBX        ,1               
 Inst_AsmBefehl "EQ"     ,EQ_EAX_EBX       ,RegisterEAX  ,RegisterEBX        ,1               
 Inst_AsmBefehl "NE"     ,NE_EAX_EBX       ,RegisterEAX  ,RegisterEBX        ,1               
                                                                       
 Inst_AsmBefehl "PUSH"   ,Push_EAX         ,RegisterEAX  ,KeinParameter      ,1                     
 Inst_AsmBefehl "PUSH"   ,Push_EBX         ,RegisterEBX  ,KeinParameter      ,1                                                                                             
 Inst_AsmBefehl "POP"    ,POP_EAX          ,RegisterEAX  ,KeinParameter      ,1                     
 Inst_AsmBefehl "POP"    ,POP_EBX          ,RegisterEBX  ,KeinParameter      ,1
                                                                                         
 Inst_AsmBefehl "CALLINT",Call_Int         ,Direkt       ,KeinParameter      ,5                     
 Inst_AsmBefehl "JMP"    ,JMP_CONST        ,Immediate    ,KeinParameter      ,5                     
 Inst_AsmBefehl "JZ"     ,JZ_CONST         ,Immediate    ,KeinParameter      ,5
 Inst_AsmBefehl "JMP"    ,JMP_CONST        ,CMarke       ,KeinParameter      ,5                     
 Inst_AsmBefehl "JZ"     ,JZ_CONST         ,CMarke       ,KeinParameter      ,5                       
 Inst_AsmBefehl "RET"    ,Ret              ,KeinParameter,KeinParameter      ,5                           
 Inst_AsmBefehl "CALL"   ,Call             ,Immediate    ,KeinParameter      ,5
 Inst_AsmBefehl "CALL"   ,Call             ,CMarke       ,KeinParameter      ,5
 
End Function

Function Inst_AsmBefehl(BefehlName$,BefehlNr,Parameter1Typ,Parameter2Typ,Befehllang)
 AsmBefehlTyp.AsmBefehlTypTyp = New AsmBefehlTypTyp
 AsmBefehlTyp\Befehl$=BefehlName$
 AsmBefehlTyp\BefehlNr=BefehlNr
 AsmBefehlTyp\Parameter1Typ=Parameter1Typ
 AsmBefehlTyp\Parameter2Typ=Parameter2Typ
 AsmBefehlTyp\lang=Befehllang
End Function


;#ImmediateInt
;#ImmediateByte

;DirektInt

;RegisterEAX
;RegisterEBX

;@registerindirektEAX
;@registerindirektEBX



Function Kompiliere_ASM()



 For AsmBefehl.AsmBefehlTyp=Each AsmBefehlTyp
  ;Print BefehlName[AsmBefehl\BefehlNr]

  ;Print AsmBefehl\Parameter2Typ
  If AsmBefehl\Parameter1Typ=Direkt Then
   PokeByte Task\Speicher,AsmBefehl\Position+1,Int(AsmBefehl\Parameter1$)
  ElseIf AsmBefehl\Parameter1Typ=Immediate Then
   PokeByte Task\Speicher,AsmBefehl\Position+1,Int(AsmBefehl\Parameter1$)
  ElseIf AsmBefehl\Parameter1Typ=CMarke Then
   For Marke=Each MarkeTyp
    If Upper$(Marke\Name$)=Upper$(Mid$(AsmBefehl\Parameter1$,2)) Then
     PokeByte Task\Speicher,AsmBefehl\Position+1,Marke\Adresse 
    End If 
   Next
  ElseIf AsmBefehl\Parameter1Typ=VarInt Then
   For Variable = Each VariableTyp
     If Upper$(AsmBefehl\Parameter1$)=Upper$(Variable\Name$) Then   
      PokeByte Task\Speicher,AsmBefehl\Position+1,Variable\Adresse
     End If
   Next

  ElseIf AsmBefehl\Parameter2Typ=Direkt Then
   PokeByte Task\Speicher,AsmBefehl\Position+1,Int(AsmBefehl\Parameter2$)
  ElseIf AsmBefehl\Parameter2Typ=Immediate Then
   PokeByte Task\Speicher,AsmBefehl\Position+1,Int(AsmBefehl\Parameter2$)
  ElseIf AsmBefehl\Parameter2Typ=CMarke Then
   For Marke=Each MarkeTyp
    If Upper$(Marke\Name$)=Upper$(Mid$(AsmBefehl\Parameter2$,2)) Then
     PokeByte Task\Speicher,AsmBefehl\Position+1,Marke\Adresse 
    End If 
   Next
  ElseIf AsmBefehl\Parameter2Typ=VarInt Then

   For Variable = Each VariableTyp
    If Upper$(AsmBefehl\Parameter2$)=Upper$(Variable\Name$) Then   
     PokeByte Task\Speicher,AsmBefehl\Position+1,Variable\Adresse 
    End If
   Next
  End If     
 Next
End Function




Function AsmZeile(Zeile$)
 Befehl$=Trim$(Upper$(Mid$(Zeile$,1,Instr(Zeile$+" "," ")-1)))

 Local ParameterS$[8]
 Parameter$=Mid$(Zeile$,Instr(Zeile$+" "," ")+1)
 ParameterLang=Len(Parameter$)
 For Pos=1 To ParameterLang
  Select Mid$(Parameter$,Pos,1)
   Case " "
    If Len(ParameterS[ParameterNr])>0 Then
     ParameterNr=ParameterNr+1
    End If
   Case ";"
    Exit 
   Default
    If ParameterNr=8 Then
     Return ;Error
    End If
    ParameterS[ParameterNr]=ParameterS[ParameterNr]+Mid$(Parameter$,Pos,1)
  End Select
 Next

 Parameter1$=ParameterS[0]
 Parameter2$=ParameterS[1]
 Parameter3$=ParameterS[2]




 If Len(ParameterS[ParameterNr])=0 Then
  ParameterNr=ParameterNr-1
 End If     
 
 If     Befehl$="DB"            Then

  Zeilelang=Len(Zeile$)
  Start=Instr(Zeile$+" "," ")



  If Start=0 Then
   Return
  End If



  For POS=Start To Zeilelang

       
 
   Select Mid$(Zeile$,Pos,1)
    Case " "
     If ZeichenAn=True Then
       PokeByte Task\Speicher,Assembler\Position,Asc(Mid$(Zeile$,Pos))
       Assembler\Position=Assembler\Position+1
       ZahlenStrByte$=""
      Else
       If Len(ZahlenStrByte$)>0 Then
        ByteZahl=Int(ZahlenStrByte$)
        If ByteZahl>255 Then
         Return ;ERROR
        End If
        PokeByte Task\Speicher,Assembler\Position,ByteZahl
        Assembler\Position=Assembler\Position+1     
        ZahlenStrByte$=""
       End If
     End If 
    Case ","
     If ZeichenAn=True Then
       PokeByte Task\Speicher,Assembler\Position,Asc(Mid$(Zeile$,Pos))
       Assembler\Position=Assembler\Position+1
       ZahlenStrByte$=""
      Else
       If Len(ZahlenStrByte$)>0 Then
        ByteZahl=Int(ZahlenStrByte$)
        If ByteZahl>255 Then
         Return ;ERROR
        End If
        PokeByte Task\Speicher,Assembler\Position,ByteZahl
        Assembler\Position=Assembler\Position+1     
        ZahlenStrByte$=""
       End If 
     End If
    Case "'"
     If ZeichenAn=True Then
      PokeByte Task\Speicher,Assembler\Position,ZahlenStrByte$
      Assembler\Position=Assembler\Position+1     
      ZahlenStrByte$=""
     End If
     ZeichenAn=True-ZeichenAn
    Case "0","1","2","3","4","5","6","7","8","9"
     If ZeichenAn=True Then
       PokeByte Task\Speicher,Assembler\Position,Asc(Mid$(Zeile$,Pos))
       Assembler\Position=Assembler\Position+1
      Else
       zahlenstrByte$=zahlenstrByte$+Mid$(Zeile$,Pos,1)
     End If
    Case ";"
     If ZeichenAn=False Then
     ;ERROR
     Return
     End If
     PokeByte Task\Speicher,Assembler\Position,Asc(Mid$(Zeile$,Pos))
     Assembler\Position=Assembler\Position+1
     ZahlenStrByte$=""
    Default
     If ZeichenAn=True Then

       PokeByte Task\Speicher,Assembler\Position,Asc(Mid$(Zeile$,Pos))
       Assembler\Position=Assembler\Position+1
       ZahlenStrByte$=""

      Else
       Return ;ERROR
     End If 
   End Select
  Next
 
  If ZahlenStrByte$<>"" Then
   PokeByte Task\Speicher,Assembler\Position,Int(ZahlenStrByte$)
   Assembler\Position=Assembler\Position+1     
   ZahlenStrByte$=""
  End If 


 
 ElseIf Befehl$="DW"            Then
  Zeilelang=Len(Zeile$)
  Pos=Instr(Zeile$+" "," ")-1

  If Start=0 Then
   Return
  End If

  For POS=Start To Zeilelang
   Select Mid$(Zeile$,Pos)
    Case ";"
     If (ZahlenStrDB$)>0 Then
       Zahlshort=Int(ZahlenStrDB$)
       PokeShort Task\Speicher,Assembler\Position,Zahlshort
       ZahlenStrDB$=""
      Else
     End If
     Return 
    Case " "
     If (ZahlenStrDB$)>0 Then
       Zahlshort=Int(ZahlenStrDB$)
       PokeShort Task\Speicher,Assembler\Position,Zahlshort
       ZahlenStrDB$=""
      Else
     End If
    Case ","
     If (ZahlenStrDB$)>0 Then
       Zahlshort=Int(ZahlenStrDB$)
       PokeShort Task\Speicher,Assembler\Position,Zahlshort
       ZahlenStrDB$=""
      Else
     End If 
    Case "0","1","2","3","4","5","6","7","8","9"
     ZahlenStrDB$=ZahlenstrDB$+Mid$(Zeile$,Pos)
    Default
   End Select
  Next

  If (ZahlenStrDB$)>0 Then
   Zahlshort=Int(ZahlenStrDB$)
   PokeShort Task\Speicher,Assembler\Position,Zahlshort
   ZahlenStrDB$=""
  End If 

 ElseIf ISMarke(Befehl$)=True Then
  Marke=New MarkeTyp
  Marke\Name$= MarkeName$(Befehl$)
  Marke\Adresse=Assembler\Position
 ElseIf Befehl$="VAR"           Then

  If ISVariable(Upper$(Parameter1$))=False Then
   Return ;ERROR
  End If

  For Variable=Each VariableTyp
   If Upper$(Variable\Name$)=Upper$(Parameter1$) Then
    Return ;ERROR
   End If
  Next



  If Len(Parameter2$)=0 Or Parameter2$="?" Then
   Variable=New VariableTyp
   Variable\Name$=Upper$(Parameter1$)
   Variable\Adresse=Assembler\Position
   Variable\Wert=0
   Return
  End If


  If Parameter2$<>"=" Then
   Return ;ERROR
  End If   
 

  Variable=New VariableTyp
  Variable\Name$=Upper$(Parameter1$)
  Variable\Adresse=Assembler\Position
  Variable\Wert=Int(Parameter3$)
  PokeInt Task\Speicher,Assembler\Position,Variable\Wert
  Assembler\Position=Assembler\Position+4

  Return
 

 ElseIf Befehl$=";"             Then
  Return
 ElseIf Befehl$="INCLUDE$"      Then
 ElseIf ISMarke(Befehl$)=True Then
  Marke=New MarkeTyp
  Marke\Name$= MarkeName$(Befehl$)
  Marke\Adresse=Assembler\Position
  Return
 Else
  ASM Befehl$,Upper$(Parameter1$),Upper$(Parameter2$)
 End If   
End Function


Function ASM(Befehl$,Parameter1$="",Parameter2$="")
 Befehl$=Upper(Befehl$)



 If     Parameter1$="@EAX"    Then
  Parameter1Typ=RegisterIndirektEAX

 ElseIf Parameter1$="@EBX"    Then
  Parameter1Typ=RegisterIndirektEBX

 ElseIf Parameter1$="EAX"     Then
  Parameter1Typ=RegisterEAX

 ElseIf Parameter1$="EBX"     Then
  Parameter1Typ=RegisterEBX

 ElseIf Parameter1$=""        Then
  Parameter1Typ=KeinParameter

 ElseIf ISInt(Parameter1$)  Then
  Parameter1Typ=Direkt

 ElseIf ISMarke(Parameter1$)Then
  Parameter1Typ=CMarke
 ElseIf ISVariable(Upper$(Parameter1$))=True Then
  Parameter1Typ=VarInt
 ElseIf Parameter1$=";"       Then
  Parameter1$="" 
 End If 


 If     Parameter2$="@EAX"    Then
  Parameter2Typ=RegisterIndirektEAX

 ElseIf Parameter2$="@EBX"    Then
  Parameter2Typ=RegisterIndirektEBX

 ElseIf Parameter2$="EAX"     Then
  Parameter2Typ=RegisterEAX

 ElseIf Parameter2$="EBX"     Then
  Parameter2Typ=RegisterEBX

 ElseIf Parameter2$=""        Then
  Parameter2Typ=KeinParameter

 ElseIf ISInt(Parameter2$)  Then
  Parameter2Typ=Direkt

 ElseIf ISMarke(Parameter2$)Then
  Parameter2Typ=CMarke
 ElseIf ISVariable(Upper$(Parameter2$))=True Then
  Parameter2Typ=VarInt
 ElseIf Parameter2$=";"       Then
  Parameter2$=""
 End If
 

 For AsmBefehlTyp=Each AsmBefehlTypTyp

  If Upper$(Befehl$)=Upper$(AsmBefehlTyp\Befehl$) Then

   If Parameter1Typ=AsmBefehlTyp\Parameter1Typ Then
    If Parameter2Typ=AsmBefehlTyp\Parameter2Typ Then
      AsmBefehl=New AsmBefehlTyp
      AsmBefehl\Parameter1$=Parameter1$
      AsmBefehl\Parameter2$=Parameter2$
      AsmBefehl\Parameter1Typ=Parameter1Typ
      AsmBefehl\Parameter2Typ=Parameter2Typ
      AsmBefehl\Position=Assembler\Position
      AsmBefehl\BefehlNr=AsmBefehlTyp\BefehlNr
      PokeByte Task\Speicher,Assembler\Position,AsmBefehl\BefehlNr   
      Assembler\Position=Assembler\Position+AsmBefehlTyp\lang
      Return
    End If
   End If
  End If
 Next   
End Function

Function ISVariable(S$)
 Slen=Len(S)
 If Slen>0 Then
  For P=1 To Slen
   ASCII=Asc(Mid$(S$,P,1))
   If Ascii>64 And Ascii<92 Then
    ElseIf Ascii=220 Then ;ü   
    ElseIf Ascii=196 Then ;ä
    ElseIf Ascii=214 Then ;ö
    Else
     Return False
   End If
  Next
  Return True
 End If
End Function

Function MarkeName$(Marke$)
 Return Mid$(Marke$,2)
End Function

Function ISMarke(S$)
 Slen=Len(S)
 If Mid$(S$,1,1)<>":" Then Return False
 If Slen>0 Then
  For P=2 To Slen
   ASCII=Asc(Mid$(S$,P,1))
   If Ascii>64 And Ascii<92 Then
    ElseIf Ascii=220 Then ;ü   
    ElseIf Ascii=196 Then ;ä
    ElseIf Ascii=214 Then ;ö
    Else
     Return False
   End If
  Next
  Return True
 End If
End Function

Function ISInt(S$)
 Slen=Len(S$)
 For P=1 To Slen
  If Instr("0123456789",Mid$(S$,P,1))=0 Then Return False
 Next
 If Slen=0 Then
  Return False
 End If 
 Return True
End Function

Function Exist_Datei(Datei$)
 If FileType(datei)=1 Then
   Return True
  Else
   Return False
 End If 
End Function

Function Upper$(S$)
 Slen=Len(S)
 If Slen>0 Then
  For P=1 To Slen
   ASCII=Asc(Mid$(S$,P,1))
   If Ascii>96 And Ascii<123 Then
     Ascii=Ascii-32
    ElseIf Ascii=252 Then ;ü
     Ascii=220     
    ElseIf Ascii=228 Then ;ä
     Ascii=196 
    ElseIf Ascii=246 Then ;ö
     Ascii=214
   End If
   R$=R$+Chr$(ASCII)
  Next
  Return R$
 End If
End Function

Function Lower$(S$)
 Slen=Len(S)
 If Slen>0 Then
  For P=1 To Slen
   ASCII=Asc(Mid$(S$,P,1))
   If Ascii>64 And Ascii<92 Then
     Ascii=Ascii+32
    ElseIf Ascii=220 Then ;ü
     Ascii=252     
    ElseIf Ascii=196 Then ;ä
     Ascii=228 
    ElseIf Ascii=214 Then ;ö
     Ascii=246
   End If
   R$=R$+Chr$(ASCII)
  Next
  Return R$
 End If
End Function

Task=New TaskTyp

Inst_Assembler
Assembler=New AssemblerTyp
Assembler\Position=0
Task\Speicher=CreateBank(200)

asmZeile "Jmp :C"
asmzeile "var t = 5"
AsmZeile "MOV EAX 1000"
asmzeile ":Z"
asmzeile "DB 'Das ist ein Test.'"
asmzeile ":C"
AsmZeile "MOV EAX :Z"
AsmZeile "CALLINT 3"
AsmZeile "LOAD EAX T"
Asmzeile "Mov EBX 1"
Asmzeile "EQ EAX EBX"
AsmZeile "SUB EAX EBX"
AsmZeile "RESTORE EAX t"
Asmzeile "JZ :C"
Asmzeile "CALLINT 2"

DateiNr=WriteFile("Comp.txt")


Kompiliere_ASM
;WaitKey
Task=First TaskTyp
WriteBytes Task\Speicher,DateiNr,0,199

Run_VM

WaitKey

+---------------------------------------+
| Quelltext Programmiersprache          |
+---------------------------------------+
                   |
                   |   (Compiler)
                   V

+---------------------------------------+
| VM Assembler Quelltext                |
+---------------------------------------+
                   |
                   |   (VM Assembler)
                   V

+--------------------------------------+
| P-Code                               |
+--------------------------------------+
        |                    | 
        |                    |
        V                    V 

+-----------------+  +-----------------+
|                 |  | Umsetzung von   |
| VM (ausführen)  |  | P-Code zu       |
|                 |  | Assembler       |
|                 |  | Quelltext       |
+-----------------+  +-----------------+   
                              |
                              | 
                              V

                     +-----------------+                               
                     | NASM            |
                     +-----------------+