Scriptsprache: Wie die Befehle "zwischenspeichern"

Übersicht BlitzBasic Allgemein

Neue Antwort erstellen

 

ke^kx

Betreff: Scriptsprache: Wie die Befehle "zwischenspeichern"

 BeitragMi, Aug 24, 2005 20:46
Antworten mit Zitat
Benutzer-Profile anzeigen
Also, das Problem ist folgendes:

Ich bin gerade dabei mir zu überlegen, wie ich die Scriptsprache, die ich Proggen will aufbauen soll. Und da ich die Befehle nicht live von der Festplatte ausführen will, überlege ich mir gerade wie ich Sie anständig "zwischenspeichere". Ich dachte mir, dass ich die Befehle in gruppen einteile (Schleife, Function ...) die wird mit einem Buchstaben festgelegt. und Dann gibt es für jeden Befehl noch eine Zahl, welcher Befehl aus der Gruppe ist, und nachfolgend ein paar werte, die Parameter.

Als Lösung wollte ich auf Banks zugreifen, da diese ja schneller sein sollen als Dims (oder?). Dort wollte ich dann direkt die Werte Speichern (geht auch mit unterschiedlich vielen Werten, je nach befehl, da der Befehl ja immer gleich deklariert wird.).

Oder kann ich auch Types benutzen? Würde das einen größeren Unterschied von der Geschwindigkeit machen, so das es sich lohnt dafür auf die flexiblität der Types zu verzichten?

Danke für die Hilfe,
Jiriki
http://i3u8.blogspot.com
Asus Striker II
Intel Core2Quad Q9300 @ 2,5 GHz (aber nur zwei Kerne aktiv aufgrund der Instabilität -.-)
Geforce 9800 GTX
2GB RAM
 

Florian

 BeitragMi, Aug 24, 2005 21:01
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich würde Bank benutzen.

Ich habe ein fastfertige BlitzBasicVM.
Ich hoffe du kannst es gebrauen.


Update
BlitzBasic: [AUSKLAPPEN] 

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

 Local ParameterS$[1]
 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=2 Then
     Return ;Error
    End If 
    ParameterS[ParameterNr]=ParameterS[ParameterNr]+Mid$(Parameter$,Pos,1)
  End Select 
 Next
 ASM Befehl$,ParameterS[0],ParameterS[1]
Function



BlitzBasic: [AUSKLAPPEN] 


Type TaskTyp
 Field Speicher
 Field SpeicherByte

 Field EIP        
 Field ZERO 

 ;Register
 Field EAX     
 Field EBX

 Field StackZeiger 
  
End Type 

Global Task.TaskTyp

;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 SLT_EAX_EBX                 =  18 ;* <
Const SGT_EAX_EBX                 =  19 ;* >
Const SLE_EAX_EBX                 =  20 ;* <=
Const SGE_EAX_EBX                 =  21 ;* >=
Const SEQ_EAX_EBX                 =  22 ;* <>
Const SNE_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

;Für Assembler
Const RegisterEAX=1 
Const RegisterEBX=2 
Const Intwert=3     
Const Varrialbel=4   
Const Marke=5       
Const KeinParameter=6

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

Type AsmBefehlTyp
 Field BefehlNr
 ;Field Befehl$
 ;Field Lang
 Field Position
 Field Parameter1$
 Field Parameter1Typ%
 Field Parameter2$
 Field Parameter2Typ%
End Type

Type NameAsmTyp
 Field Name$
 Field Typ
 Field Gefunden
 Field Adresse
 Field Wert 
End Type 

Type AssemblerTyp
 Field Position
End Type 
 
Global AsmBefehlArt.AsmBefehlArtTyp
Global AsmBefehl.AsmBefehlTyp
Global NameAsm.NameAsmTyp
Global Assembler.AssemblerTyp

 

Inst_Assembler
Assembler =New AssemblerTyp

Function Inst_Assembler()
 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,IntWert,5   
 Inst_AsmBefehl \"MOV\",MOV_EBX_Const,RegisterEBX,IntWert,5

 Inst_AsmBefehl \"RESTORE\",RESTORE_EAX_CONST,RegisterEAX,IntWert,5 
 Inst_AsmBefehl \"RESTORE\",RESTORE_EBX_CONST,RegisterEBX,IntWert,5 

 Inst_AsmBefehl \"RESTORE\",RESTORE_EAX_CONST,RegisterEAX,Varrialbel,5 
 Inst_AsmBefehl \"RESTORE\",RESTORE_EBX_CONST,RegisterEBX,Varrialbel,5

 Inst_AsmBefehl \"RESTORE\",RESTORE_EAX_EBX ,RegisterEAX,RegisterEBX,1
 Inst_AsmBefehl \"RESTORE\",RESTORE_EBX_EAX ,RegisterEBX,RegisterEAX,1


 Inst_AsmBefehl \"LOAD\",LOAD_EAX_CONST,RegisterEAX,IntWert,5                  
 Inst_AsmBefehl \"LOAD\",LOAD_EBX_CONST,RegisterEBX,IntWert,5            

 Inst_AsmBefehl \"LOAD\",LOAD_EAX_EBX,RegisterEAX,RegisterEBX,1                
 Inst_AsmBefehl \"LOAD\",LOAD_EBX_EAX,RegisterEBX,RegisterEAX,1    

 Inst_AsmBefehl \"LOAD\",LOAD_EAX_CONST,RegisterEAX,Varrialbel,5                  
 Inst_AsmBefehl \"LOAD\",LOAD_EBX_CONST,RegisterEBX,Varrialbel,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 \"SLT\",SLT_EAX_EBX,RegisterEAX,RegisterEBX,1                
 Inst_AsmBefehl \"SGT\",SGT_EAX_EBX,RegisterEAX,RegisterEBX,1                 
 Inst_AsmBefehl \"SLE\",SLE_EAX_EBX,RegisterEAX,RegisterEBX,1                
 Inst_AsmBefehl \"SGE\",SGE_EAX_EBX,RegisterEAX,RegisterEBX,1                
 Inst_AsmBefehl \"SEQ\",SEQ_EAX_EBX,RegisterEAX,RegisterEBX,1                
 Inst_AsmBefehl \"SNE\",SNE_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,IntWert,KeinParameter,5                     

 Inst_AsmBefehl \"JMP\",JMP_CONST,IntWert,KeinParameter,5                      
 Inst_AsmBefehl \"JZ\" ,JZ_CONST,IntWert,KeinParameter,5 
                      
 Inst_AsmBefehl \"JMP\",JMP_CONST,marke,KeinParameter,5                      
 Inst_AsmBefehl \"JZ\" ,JZ_CONST,marke,KeinParameter,5  

 Inst_AsmBefehl \"RET\" ,Ret,KeinParameter,KeinParameter,5                            
 Inst_AsmBefehl \"CALL\",Call,IntWert,KeinParameter,5 
 Inst_AsmBefehl \"CALL\",Call,marke,KeinParameter,5                              
End Function 

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

 Task.TaskTyp=New TaskTyp
Task\Speicher=CreateBank(20000)

Task\StackZeiger=10000


ASM \"JMP\",\":M\",\"\"
ASM \"INT\",\"WERT\",\"10\"
ASM \":M\",\"\",\"\"
ASM \"LOAD\",\"EAX\",\"WERT\"
ASM \"MOV\",\"EBX\",\"33\"
ASM \"CALLINT\",\"1\",\"\"
ASM \"CALLINT\",\"2\",\"\"







Kompiliere_ASM
Run_VM

WaitKey 

Function Kompiliere_ASM()
 For AsmBefehl.AsmBefehlTyp=Each AsmBefehlTyp
  If AsmBefehl\Parameter1Typ=IntWert Then
   PokeByte Task\Speicher,AsmBefehl\Position+1,Int(AsmBefehl\Parameter1$)
  ElseIf AsmBefehl\Parameter1Typ=Marke Then
   For NameAsm.NameAsmTyp = Each NameAsmTyp
    If NameAsm\Typ=Marke Then
     If Mid$(AsmBefehl\Parameter1$,2)=NameAsm\Name$ Then   
      PokeByte Task\Speicher,AsmBefehl\Position+1,NameAsm\Adresse
     End If
    End If 
   Next
  ElseIf AsmBefehl\Parameter1Typ=Varrialbel Then
   For NameAsm.NameAsmTyp = Each NameAsmTyp
    If NameAsm\Typ=Varrialbel Then
     If AsmBefehl\Parameter1$=NameAsm\Name$ Then   
      PokeByte Task\Speicher,AsmBefehl\Position+1,NameAsm\Adresse
     End If
    End If 
   Next
  ElseIf AsmBefehl\Parameter2Typ=IntWert Then
   PokeByte Task\Speicher,AsmBefehl\Position+1,Int(AsmBefehl\Parameter2$)
  ElseIf AsmBefehl\Parameter2Typ=Marke Then
   For NameAsm.NameAsmTyp = Each NameAsmTyp
    If NameAsm\Typ=Marke Then
     If AsmBefehl\Parameter2$=NameAsm\Name$ Then   
      PokeByte Task\Speicher,AsmBefehl\Position+1,NameAsm\Adresse
     End If
    End If 
   Next
  ElseIf AsmBefehl\Parameter2Typ=Varrialbel Then
   For NameAsm.NameAsmTyp = Each NameAsmTyp
    If NameAsm\Typ=Varrialbel Then
     If AsmBefehl\Parameter2$=NameAsm\Name$ Then   
      PokeByte Task\Speicher,AsmBefehl\Position+1,NameAsm\Adresse
     End If
    End If 
   Next
  End If   
 Next 
End Function 

Function ASM(Befehl$,Parameter1$=\"\",Parameter2$=\"\")
 Befehl$=Upper(Befehl$) 
 If Mid$(Befehl$,1,1)=\":\" Then  
  For NameAsm.NameAsmTyp = Each NameAsmTyp
   If Mid$(Befehl$,2)=NameAsm\Name$ Then
    If NameAsm\Typ=Marke Then
     If NameAsm\Gefunden=True Then
      Return  
     End If
     NameAsm\Gefunden=True
     NameAsm\Adresse=Assembler\Position
     Return True  
    End If 
   End If 
  Next 
  NameAsm.NameAsmTyp = New NameAsmTyp
  NameAsm\Name$=Mid$(Befehl$,2)
  NameAsm\Gefunden=True 
  NameAsm\Typ=Marke
  NameAsm\Adresse=Assembler\Position
  Return True   
 End If 
 If Befehl$=\"INT\" Then  
  For NameAsm.NameAsmTyp = Each NameAsmTyp
   If NameAsm\Typ=Varrialbel Then
    If Parameter1$=NameAsm\Name$ Then
     If NameAsm\Gefunden=True Then
      Return  
     End If
     NameAsm\Gefunden=True
     NameAsm\Adresse=Assembler\Position
     NameAsm\wert=Int(Parameter2$)
     PokeInt Task\Speicher,Assembler\Position,NameAsm\wert  
     Assembler\Position=Assembler\Position+4
     Return True  
    End If 
   End If 
  Next
  NameAsm.NameAsmTyp = New NameAsmTyp
  NameAsm\Name$=Parameter1$
  NameAsm\Gefunden=True
  NameAsm\Typ=Varrialbel
  NameAsm\Adresse=Assembler\Position
  NameAsm\wert=Int(Parameter2$)
  PokeInt Task\Speicher,Assembler\Position,NameAsm\wert
  Assembler\Position=Assembler\Position+4
  Return True 
 End If 

 If Upper$(Parameter1$)=\"EAX\" Then
   Parameter1Typ=RegisterEAX
  ElseIf Upper$(Parameter1$)=\"EBX\" Then
   Parameter1Typ=RegisterEBX
  ElseIf Mid$(Parameter1$,1,1)=\":\" Then
   Parameter1Typ=Marke
  ElseIf Parameter1$=\"\" Then
   Parameter1Typ=KeinParameter
  ElseIf IntTest(Parameter1$)=True Then
   Parameter1Typ=Intwert
  ElseIf VarrialbelTest(Parameter1$)=True  Then   
   Parameter1Typ=Varrialbel    
  Else  
 End If 


 If Upper$(Parameter2$)=\"EAX\" Then
   Parameter2Typ=RegisterEAX
  ElseIf Upper$(Parameter2$)=\"EBX\" Then
   Parameter2Typ=RegisterEBX
  ElseIf Mid$(Parameter2$,1,1)=\":\" Then
   Parameter2Typ=Marke
  ElseIf Parameter2$=\"\" Then
   Parameter2Typ=KeinParameter
  ElseIf IntTest(Parameter2$)=True Then
   Parameter2Typ=Intwert  
  ElseIf VarrialbelTest(Parameter2$)=True  Then   
   Parameter2Typ=Varrialbel   
  Else  
 End If


 For AsmBefehlArt.AsmBefehlArtTyp= Each AsmBefehlArtTyp
  If AsmBefehlArt\Befehl$=Befehl$ Then 
   If Parameter1Typ=AsmBefehlArt\Parameter1Typ Then
    If Parameter2Typ=AsmBefehlArt\Parameter2Typ Then 
     AsmBefehl.AsmBefehlTyp=New AsmBefehlTyp
     AsmBefehl\Parameter1$=Parameter1$
     AsmBefehl\Parameter2$=Parameter2$
     AsmBefehl\Parameter1Typ=Parameter1Typ
     AsmBefehl\Parameter2Typ=Parameter2Typ
     ;AsmBefehl\Lang=AsmBefehlArt\Lang
     AsmBefehl\Position=Assembler\Position
     ;AsmBefehl\Befehl$=AsmBefehlArt\Befehl$
     AsmBefehl\BefehlNr=AsmBefehlArt\BefehlNr
     PokeByte Task\Speicher,Assembler\Position,AsmBefehl\BefehlNr
     Assembler\Position=Assembler\Position+AsmBefehlArt\Lang
     Return AsmBefehlArt\BefehlNr 
    End If 
   End If 
  End If 
 Next 
End Function 

Function IntTest(S$)
 Slen=Len(S$)
 For P=1 To Slen
  If Instr(\"0123456789\",Mid$(S$,P,1))=0 Then Return False 
 Next 
 Return True 
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 

Function VarrialbelTest(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>96 And Ascii<123 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 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 SLT_EAX_EBX ; <
    If Task\EAX<Task\EBX Then
      Task\ZERO=True 
     Else 
      Task\ZERO=False  
    End If   
    Task\EIP=Task\EIP+1

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

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

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

   Case SNE_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 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 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

[/syntax]
  • Zuletzt bearbeitet von Florian am So, Aug 28, 2005 21:46, insgesamt einmal bearbeitet
 

ke^kx

 BeitragSa, Aug 27, 2005 21:12
Antworten mit Zitat
Benutzer-Profile anzeigen
Sorry, das ich erst jetzt antworte, hab zu viel TrackMania Sunrise gespielt.

Wie "speicherst" du denn die Befehle? Ich hab ehrlich gesagt nähmlcih nicht die Muse mich jetzt in deinen Code einzuarbeiten *schäm*

Danke für die Hilfe,
Jiriki
http://i3u8.blogspot.com
Asus Striker II
Intel Core2Quad Q9300 @ 2,5 GHz (aber nur zwei Kerne aktiv aufgrund der Instabilität -.-)
Geforce 9800 GTX
2GB RAM
 

Florian

 BeitragSa, Aug 27, 2005 22:07
Antworten mit Zitat
Benutzer-Profile anzeigen
Es stimmt schon das mit dem Laden und speichern muss ich noch ein bauen.

Ich glaube ich bin morgen damit fertig.
Man soll eine ganze zeile laden und speichern können mit Befehl, Parameter ,Marken,var und und.


Es gibt auch eine ein fache möglichkeit:

Wenn das selber ein bauen möchtest:

Du muss doch nicht den ganzen code änderen sondern nur eine Lade und Speicher function ein bauen.

Je Befehl kann zwei Parameter haben.
Wenn du nur in einer Zeile ein Parameter ober ein Befehl hinein schreibst, dann kannst du einfach 3 Zeilen für Befehle,Marke,Var verwenden.

Die Lade Function muss dann an die Function ASM die drei Parameter über geben bis die Input-datei aus gelesen ist.


Dann muss man die Function Kompiliere_ASM aufrufen.
und dann Kannst du die VM starten mit Run_VM.

x-pressive

 BeitragSo, Aug 28, 2005 7:30
Antworten mit Zitat
Benutzer-Profile anzeigen
@Florian: glaube, du hast dich in deinem Code vertippt:

Zitat:

Function VarrialbelTest
• BLITZ SHOWCASE:
PARTICLE CANDY • PARTICLE CANDY FOR iPHONE • SPRITE CANDY • DON'T GET ANGRY! 2-3 • CLICK CLACK XL
 

ke^kx

 BeitragSo, Aug 28, 2005 20:52
Antworten mit Zitat
Benutzer-Profile anzeigen
Ich meinte, ließt du die Befehle direkt aus, um sie dann auszuführen, oder speicherst du sie erst in einem Bank?

Jiriki

F.S. (Forum Scriptum)
Danke, für das Angebot mit dem Code, aber ich schreibe mir lieber einen selber, sonst lernt man ja auch nichts Wink (Ich brauch sonst auch so lange um mich einzuarbeiten)
http://i3u8.blogspot.com
Asus Striker II
Intel Core2Quad Q9300 @ 2,5 GHz (aber nur zwei Kerne aktiv aufgrund der Instabilität -.-)
Geforce 9800 GTX
2GB RAM
 

Florian

 BeitragSo, Aug 28, 2005 21:00
Antworten mit Zitat
Benutzer-Profile anzeigen
Jiriki hat Folgendes geschrieben:

Ich meinte, ließt du die Befehle direkt aus, um sie dann auszuführen, oder speicherst du sie erst in einem Bank?



Ich speichere die Befehle zu erst in einem Bank, um sie später auszuführen.
 

Florian

 BeitragSo, Aug 28, 2005 22:24
Antworten mit Zitat
Benutzer-Profile anzeigen
Update

Ganze zeilen können verarbeitet werden.

BlitzBasic: [AUSKLAPPEN] 


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 VarrialbelTyp
 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 Varrialbel.VarrialbelTyp
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


Task=New TaskTyp

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

AsmZeile \"CALLINT 1\"
AsmZeile \"CALLINT 2\" 

Kompiliere_ASM

Run_VM

WaitKey 

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 
 
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 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 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 

  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
     Return   
    End If  
   Next 
  ElseIf AsmBefehl\Parameter1Typ=VarInt Then 
   For Varrialbel = Each VarrialbelTyp 
     If AsmBefehl\Parameter1$=Varrialbel\Name$ Then    
      PokeByte Task\Speicher,AsmBefehl\Position+1,Varrialbel\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
     Return   
    End If  
   Next 
  ElseIf AsmBefehl\Parameter2Typ=VarInt Then 
   For Varrialbel = Each VarrialbelTyp 
    If AsmBefehl\Parameter2$=Varrialbel\Name$ Then    
     PokeByte Task\Speicher,AsmBefehl\Position+1,Varrialbel\Adresse 
    End If 
   Next
  End If      
 Next 
End Function 




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

 Local ParameterS$[2]
 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=3 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$)
  Pos=Instr(Zeile$+\" \",\" \")-1

  If Start=0 Then
   Return
  End If 

  For POS=Start To Zeilelang
   Select Mid$(Zeile$,Pos)
    Case \" \"
     If ZeichenAn=True Then
       PokeByte Task\Speicher,Assembler\Position,Asc(Mid$(Zeile$,Pos))
       Assembler\Position=Assembler\Position+1
      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
      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=False Then
      PokeByte Task\Speicher,Assembler\Position,ByteZahl
      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) 
     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
    
    Default
     If ZeichenAn=True Then
       PokeByte Task\Speicher,Assembler\Position,Asc(Mid$(Zeile$,Pos))
       Assembler\Position=Assembler\Position+1
      Else
       Return ;ERROR 
     End If  
   End Select 
  Next
  PokeByte Task\Speicher,Assembler\Position,ByteZahl
  Assembler\Position=Assembler\Position+1     
  ZahlenStrByte$=\"\"
 
 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 MarkeTest(Befehl$)=True Then
  Marke=New MarkeTyp
  Marke\Name$= MarkeName$(Befehl$)
  Marke\Adresse=Assembler\Position
 ElseIf Befehl$=\"VAR\"           Then
  If VarrialbelTest(Parameter1$)=False Then
   Return ;ERROR
  End If 
  For Varrialbel=Each VarrialbelTyp
   If Upper$(Varrialbel\Name$)=Upper$(Parameter1$) Then
    Return ;ERROR
   End If 
  Next 

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

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

  Varrialbel=New VarrialbelTyp
  Varrialbel\Name$=Upper$(Parameter1$)
  Varrialbel\Adresse=Assembler\Position
  Varrialbel\Wert=Int(Parameter3$)
  Return 
  

 ElseIf Befehl$=\";\"             Then
  Return 
 ElseIf Befehl$=\"INCLUDE$\"      Then
 ElseIf MarkeTest(Befehl$)=True Then
  Marke=New MarkeTyp
  Marke\Name$= MarkeName$(Befehl$)
  Marke\Adresse=Assembler\Position
  Return 
 Else
  ASM Befehl$,Parameter1$,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 IntTest(Parameter1$)  Then
  Parameter1Typ=Direkt

 ElseIf MarkeTest(Parameter1$)Then
  Parameter1Typ=CMarke
 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 IntTest(Parameter2$)  Then
  Parameter2Typ=Direkt

 ElseIf MarkeTest(Parameter2$)Then
  Parameter2Typ=CMarke
 End If 
  
 If AsmBefehlTyp=Null Then Print \"W\"


 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 VarrialbelTest(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 MarkeTest(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 IntTest(S$)
 Slen=Len(S$)
 For P=1 To Slen
  If Instr(\"0123456789\",Mid$(S$,P,1))=0 Then Return False 
 Next 
 Return True 
End Function 

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

Neue Antwort erstellen


Übersicht BlitzBasic Allgemein

Nach Oben

Gehe zu:

Powered by phpBB © 2001 - 2006, phpBB Group