BlitzBasic Portal Worklogs - FireBasic

Debugger

flona — Wed, 14 Jul 2010 22:07:24 +0200

Nein, das Projekt ist nicht tot, das Wetter ist einfach zu schön .

Die letzten Tage hab ich mich aber mal wieder dazu gezwungen weiterzumachen.
Ergebnis: Ein bisher recht gut gelungener Debugger.
Es hat mich einiges an Zeit gekostet mich in die Materie einzulesen, aber jetzt hats geklappt. Der Debugger ist komplett in die IDE integriert, bzw. mit der IDE identisch. Diese Tatsache macht auch so etwas möglich:

Die einfachsten Befehle wie Schritt usw. funktionieren schon.

Muss mir nur noch überlegen wo ich die Debuglogs anzeigen lasse und wie ich des mit den Variablenwerten anzeigen hinbekomm.

Das solls auch schon wieder gewesen sein.
mfg Florian

P.S.: Viel Spass mit dem schönen Wetter

Version 0.3 Beta

flona — Sun, 21 Feb 2010 13:01:52 +0100

Hi,
Version 0.3 ist fertig.

New
New funktioniert jetzt ähnlich wie in Java.
Code: [AUSKLAPPEN]

Type TTest
Method TTest(Name$)
Notify "Ein Objekt der Klasse TTest wurde von "+Name$+" erstellt!"
EndMethod
EndType

Test:TTest = New TTest("mir")

IDE

Features:
+ Unter XP wird statt der Ribbon einfach eine Menüleiste angezeigt(Für Vista u. Win7 Nutzer: Einfach im Kompatiblitätsmodus XP starten)
+ Neu/Öffnen/Speichern/Speichern unter
+ Suchen/Ersetzen
+ Datei/Ordnerpfad einfügen
+ Auswahl kommentieren
+ Zeilennummern
+ Schnelles Highlighting
+ Anpassbares Quick-Access-Menu
+ Drag & Drop (Man zieht eine oder mehrere Dateien über das Fenster, lässt die Maustaste los und die Dateien werden geladen)
+ Mehrere Dateien können gleichzeitig geöffnet werden(s. Tab's am unteren Fensterrand)
+ Eigenschaften-Dialog:

ToDo:
- Drucken
- Alle ersetzen
- Benutzerdefiniertes Highlighting

Hilfe
...ist mit dabei, allerdings noch nicht fertig.

Download FireBasic 0.3 Beta (rar-Datei) Größe: 938kB

Bitte teilt mir alle Bugs mit, die ihr findet.

Viel Spass damit
mfg Florian

Version 0.3 in Sicht

flona — Mon, 08 Feb 2010 21:37:11 +0100

Hi,
Gleich mal vorweg: Heute gibt es leider noch keine neue Version.
Allerdings hat sich mittlerweile schon wieder einiges getan.

IDE
Es wird mit Version 0.3 eine neue IDE geben, die den langsamen instabilen Vorgänger ablösen wird. Um diese Vorsätze zu verwirklichen musste ich allerdings auf C++ ausweichen. Als Edit-Control fungiert dabei Scintilla, die unter anderem auch in IDEal und Notepad++ zum Einsatz kommt. Die Oberfläche wurde ausserdem durch eine schicke Ribbon-Oberfläche ersetzt. Diese funktioniert allerdings nur unter Vista und Win7. Für XP werde ich also noch eine Menü-Toolbar-Combi schreiben müssen. Was bereits funktioniert:
- Öffnen/Speichern
- Highlighting von Keywords, Standardtypes, Strings, ...
- Auswahl kommentieren
- Suchen/Ersetzen
- Compiler aus der IDE heraus starten
Ich weiß das ist noch nicht besonders viel, aber in jedem Fall besser als die Alte.

Hilfe
Ich hab nun angefangen mithilfe des HTML Help Workshop eine Hilfe zu erstellen. Dokumentiert sind bereits die Standardfunktionen(z.B. Mid, Millisecs, Len, ...) sowie die Klassen TGadget, TWindow und TConsole. Der Rest wird hoffentlich bald dazukommen. Die Hilfe kann dann mit dem Hilfe Symbol aus der IDE heraus aufgerufen werden.

Threads
Mit Version 0.3 wird es Threads in Form einer THREAD.ext geben. Dazu ein Beispiel zur Veranschaulichung:
Code: [AUSKLAPPEN]

Include "THREAD"

start = Millisecs( )
Thread:TThread = TThread.Create( *DoSomething )
Thread.SetPriority( TThread.Lowest )
Thread.WaitFor( )
ende = Millisecs( )
diff = ende-start
Notify diff

Function DoSomething( )
a = 1
Loop 1000000000
a = a*5555555
EndLoop
EndFunction

Denke ich ist relativ selbsterklärend. Es gibt auch noch die Möglichkeit der Funktion die als Thread gestartet wird einen Parameter mitzugeben.

Zu guter letzt noch eine Überlegung: Ich werde wahrscheinlich Konstruktoren so einbauen, wie sie in Java funktionieren. Man müsste also nichtmehr Win:TWindow = TWindow.Create( ... ) , sondern Win:TWindow = New TWindow ( ... ) schreiben. Das natürlich nicht nur für TWindow, sondern auch für alle anderen.
Was haltet ihr von der Idee?

Bis bald

mfg Florian

Version 0.2 Built 8

flona — Thu, 31 Dec 2009 17:01:15 +0100

Kleines Update:
Bin heute mal wieder auf ein paar Bugs gestossen. Ein paar Vergleichsoperatoren funktionierten noch nicht richtig und ein weiterer trat bei negativen Kommazahlen auf: Dort wurde falscher ASM-Code erzeugt, sollte jetzt allerdings behoben sein.
Außerdem wurden der Funktion 'TWindow.Create' zwei neue Default-Parameter verpasst. Ihr kennt das ja man will ein Fenster in der Mitte des Bildschirms erzeugen und muss dazu Breite, Höhe des Desktops abfragen, durch 2 teilen ... . Wird statt X-Pos und Y-Pos nun -1(Default) übergeben richtet sich das Fenster automatisch mittig zu seinem Parent aus. Der Aufruf sieht dann im Moment z.B. so aus: TWindow.Create ( "Titel", , , 200, 100 )

Download FireBasic 0.2 Alpha Built 8 (rar-Datei)

Eine weitere Überlegung von mir war, dass man ja nun das Fenster nichtmehr an der Position -1, -1 positionieren kann. -1, -1 als Breite, Höhe hingegen ergibt keinen Sinn. Deshalb könnte man den Aufruf so TWindow.Create ( "Titel", 200, 100 ) umschreiben. Wenn Breite=Höhe=-1 dann x=Breite, y=Höhe und Position=mittig zum Parent. Ich hoffe ihr versteht was ich meine.
Was haltet ihr davon?

mfg flona

Version 0.2 Built 7

flona — Fri, 18 Dec 2009 18:59:51 +0100

So, die letzte Schulaufgabe vor den Ferien ist geschafft . Deshalb habe mich heute gleich wieder FireBasic gewidmet und die GUI Extension um 2 (genaugenommen 3) neue Klassen erweitert.
Die ersten sind ist TMenu und TMenuItem:
Zitat:

Type TMenu Abstract Final
    Field Handle:INT
    Field Parent:TGadget
    Function Create ( [Parent:TGadget=0] )
    Method AddItem:TMenuItem ( Text$ )
    Method AddMenu:TMenu ( Text$ )
    Method Update ( )
EndType

Zitat:

Type TMenuItem Abstract Final
    Field ID:INT
    Method onCommand ( Pointer )
EndType

In Handle wird das Handle des Menüs gespeichert und in Parent das Fenster auf dem es angezeigt wird.
Die statische Funktion Create erstellt das Menü. Wird kein Parent angegeben handelt es sich um ein Kontextmenü(Wird im Moment allerdings noch nicht unterstützt).
AddItem erzeugt einen normalen Eintrag. Die zusätzliche Klasse war leider aufgrund des Eventsystems von Nöten. AddMenu erzeugt ein Submenü, in dem wiederrum Items und Menüs erzeugt werden können.
Update muss für das Hauptmenü aufgerufen werden, um die Änderunen an dem Menü zu übernehmen.
onCommand verarbeitet einen Klick auf ein Menü.

Die Andere Klasse ist TListView.
Zitat:

Type TListView Extends TGadget Abstract Final
    Function Create ( X, Y, Width, Height, Parent:TGadget[, Style=1] )
    Method InsertColumn ( Text$, Width, Pos )
    Method AddItem ( Text$ )
    Method InsertItem ( Text$, Line )
    Method SetItemText ( Text$, Line, Column )
    Method ClearAll ( )
    Method SelectedItem ( )
    Method onSelChange ( Pointer )
EndType

Die Namen sind eigentlich selbsterklärend.
Hab dem Downloadpaket ein weiteres Beispiel mit Menü und ListView hinzugefügt.

Beide Klassen werden nach und nach noch erweitert werden und sind natürlich im Moment keinesfalls vollständig.

Download FireBasic 0.2 Alpha Built 7 (rar-Datei)

Der Aufruf aus dem vorherigen Beitrag gilt natürlich nach wie vor: Wenn ihr Bugs findet Bitte schicken

Viel Spass damit
mfg Florian

Es ist soweit - Die erste Testversion

flona — Wed, 04 Nov 2009 16:09:44 +0100

Hi, heute ist es soweit
Die erste Testversion von FireBasic ist fertig. Leider die Dokumentation noch nicht, aber ich denke an den beigelegten Beispielen kann man sich die Syntax sehr schnell erschließen.

Ich bitte euch mir alle Bugs die ihr findet zu schicken. ( PM, Comments, E-Mail, ICQ, Skype )
Ist ja auch der Sinn einer Alpha Version

Download FireBasic 0.2 Alpha Built 6 (rar-Datei)
Built 5 zu 6:
- STANDART in STANDARD umbenannt(wie peinlich)
- Konsole bleibt nur offen, wenn ein Fehler aufgetreten ist

Viel Spass damit
mfg Florian

Endspurt - Erste Testversion in Sicht

flona — Sun, 18 Oct 2009 18:37:05 +0200

Lange nichts gehört. Lange hat sich auch nicht viel getan, aber die nächsten Tage / Wochen wird es eine Testversion geben . Einziges Hindernis im Moment: Die fehlende Dokumentation der Befehle. Habe allerdings schon damit angefangen.

Änderungen seit dem letzten Eintrag:
- Das komplette Eventsystem wurde neu geschrieben, welches nun erfreulicherweise tadellos funktioniert.
- ich nun zum x-ten mal eine provisorische IDE geschrieben, deren Syntaxhighlighting noch stark zu wünschen übrig lässt, aber es geht ja vorrangig um FireBasic und nicht um die IDE.
- Etliche Bugs wurden gefixt, sodass die Extensions nun stabil laufen.

Ich suche derzeit nach einem Design für die Website auf der:
- FireBasic heruntergeladen werden kann
- Die Dokumentation zu finden sein wird
- Bugs gemeldet werden können
Wenn jemand eine Design-Idee und ein bisschen freie Zeit hat bitte schreiben . Zurzeit steh ich fantasiemäßig total auf dem Schlauch . Entweder ein Grundgerüst der Seite oder nur eine "Skizze".

mfg Florian

Extensions - Der 2te Versuch

flona — Mon, 07 Sep 2009 21:06:08 +0200

Hi, alle zusammen.
Nach längerer Zeit, in der es nichts außergewöhnliches zu berichten gab, melde ich mich hier mal wieder.

Extensions
Ich musste die Extensions in ihrer geplanten Form ein wenig abwandeln, da ich feststellte, dass der Editor schnell sehr unübersichtlich wurde. Deshalb habe ich nun ein XML ähnliches Format entwickelt, das anschließend in Bytecode kompiliert wird und dann in FireBasic eingebunden werden kann. Dazu ein kleines Beispiel:
Code: [AUSKLAPPEN]

<TYPE="TConsole">
<FIELD="OutputHandle" typ="INT">
<FIELD="InputHandle" typ="INT">
<METHOD="New" typ="INT" alias="FB_TCONSOLE_New">
<ASM>
proc FB_TCONSOLE_New Self:DWORD
invoke AllocConsole
invoke GetStdHandle,STD_OUTPUT_HANDLE
mov ecx,[Self]
mov dword [ecx],eax
invoke GetStdHandle,STD_INPUT_HANDLE
mov ecx,[Self]
mov dword [ecx+4],eax
ret
endp
</ASM>
<DLL="kernel32.dll">
   <FUNCTION="AllocConsole" alias="AllocConsole">
</DLL>
</METHOD>

<METHOD="WriteLn" typ="INT" alias="FB_TCONSOLE_WriteLn">
<PARAMETER="Text" typ="STRING">
<ASM>
proc FB_TCONSOLE_WriteLn Self:DWORD,text:DWORD
sub esp,4
mov eax,esp
push 0
push eax
invoke lstrlen,[text]
push eax
push [text]
mov eax,[Self]
push dword [eax]
call [WriteConsole]
mov [esp],eax
mov eax,[text]
call FB_GC_CRef
sub esp,4
mov ecx,esp
mov eax,[Self]
invoke WriteConsole,[eax],CR,1,ecx,0
add esp,4
pop eax
ret
endp
CR: db 10,0
</ASM>
<DLL="kernel32.dll">
   <FUNCTION="lstrlenA" alias="lstrlen">
   <FUNCTION="GetStdHandle" alias="GetStdHandle">
   <FUNCTION="WriteConsoleA" alias="WriteConsole">
</DLL>
</METHOD>

<METHOD="Input" typ="STRING" alias="FB_TCONSOLE_Input">
<ASM>
proc FB_TCONSOLE_Input Self:DWORD
local stdin:DWORD,oldmode:DWORD
mov eax,[Self]
mov eax,[eax+4]
mov [stdin],eax
lea ecx,[oldmode]
invoke GetConsoleMode,eax,ecx
mov ecx,[oldmode]
or ecx,2
invoke SetConsoleMode,[stdin],ecx
stdcall FB_GC_New,256
push eax
sub esp,4
mov ecx,esp
invoke ReadConsole,[stdin],eax,255,ecx,0
add esp,4
invoke SetConsoleMode,[stdin],[oldmode]
pop eax
ret
endp
</ASM>
<DLL="kernel32.dll">
   <FUNCTION="GetStdHandle" alias="GetStdHandle">
   <FUNCTION="GetConsoleMode" alias="GetConsoleMode">
   <FUNCTION="SetConsoleMode" alias="SetConsoleMode">
   <FUNCTION="ReadConsoleA" alias="ReadConsole">
</DLL>
</METHOD>
</TYPE>

Durch diese Form werden auch wirklich nur verwendete Dll's geladen und nur verwendeter Code wird kompiliert. Die XML-Dateien haben die Dateiendung .extension und die Bytecodeform .ext. Der Converter wird später mitgeliefert werden, was es dem Benutzer ermöglicht seine Codes anderen Leuten zur Verfügung zu stellen. Die Standart-Runtime wird ebenfalls als STANDART.ext gespeichert, wodurch Änderungen sehr schnell übernommen werden können.

CMD
Die GUI habe ich im Moment hinten angestellt, da es dort noch ein paar kleine Bugs aufzuspüren gibt.
Also habe ich mich ein wenig mit der CMD.ext beschäftigt. Ein Teil des Codes habe ich ja bereits oben geschrieben. Der bisherige Umfang ist folgender:
Code: [AUSKLAPPEN]

Type TConsole
Field OutputHandle:INT
Field InputHandle:INT
Method New ( )
Method Write ( Text:STRING )
Method WriteLn ( Text:STRING )
Method Input:STRING ( )
Method SetColor ( Color:INT )
Method SetCursorPosition ( X:INT, Y:INT )
Method SetTitle ( Title:STRING )
Method GetTitle:STRING ( )
EndType

Würde mich über sinnvolle Ergänzungsvorschläge sehr freuen

mfg Florian

FireBasic ist von den Toten auferstanden!

flona — Tue, 09 Jun 2009 11:07:17 +0200

Also der Grund für die lange Auszeit: Fehlende Motivation und keine Zeit.
Der Garbage Collector läuft nun mittlerweile nachdem einige Bugs entfernt wurden relativ stabil.
Die Bugs zu finden war oftmals nicht so ganz einfach Demotivation

Wollen wir nich länger bei der Vergangenheit verharren und wenden und der Gegenwart zu:
Statische Funktionen
Heute habe ich Statische Funktionen eingebaut, also Funktionen, die an einen Type(=Klasse) gebunden sind. Im Vergleich zu Methoden sind sie aber nicht von Objekten abhängig(Kennen die meisten sowieso von BM). Ein kleines Beispiel was FireBasic bisher in dem Bereich kann:
Code: [AUSKLAPPEN]

Type TTest
Const DefVal=1
Field Value
Method GetValue()
Return Self.Value
EndMethod
Method SetValue(NewVal)
Self.Value=NewVal
EndMethod
Method Display()
Notify "Value="+Self.Value
EndMethod
Function Create:TTest()
obj:TTest=New(TTest)
obj.Value=TTest.DefVal
Return obj
EndFunction
EndType

obj:TTest=TTest.Create()
obj.Display()
obj.SetValue(4)
obj.Display()
End

Extensions
Bisher wird beim Start alles initialisiert, von der Windowklasse über den Eventmanager bis zur Socketverbindung.
Nun werde ich den kompletten Quellcode von FireBasic in zusammenhängende Dateien verpacken(ähnlich den Modulen in BlitzMax). So wird es eine GUI.ext, eine TCP.ext, eine CMD.ext und eine FILE.ext geben und was sonst noch so kommt. In diesen Dateinen werden auf ASM-Ebene Initialisierungs-, Haupt- und Deinitalierungscodes gespeichert, sowie Types, Funktionen, Konstanten und zu includierende WinApi Funktionen.
Wird nun eine ext Datei im Programmtext geladen(mit Include), dann wird der Initcode vor der MainFunction und der Deinitcode vor dem End ausgeführt. Der Hauptcode wird ans Ende des Programmes angehängt und die Codes der Funktionen die im Programm aufgerufen werden.
Im Moment arbeite ich an einem kleinen Tool mit dem man diese Dateien erstellen und bearbeiten kann. Wenn ich es hinbekomme werde ich noch eine Funktion in FireBasic einbauen damit man aus normalem Code ext Dateien erzeugen kann.

Kommentare, Vorschläge, Kritik etc. ist wie immer erwünscht

Der Garbage Collector wird kommen

flona — Sun, 05 Apr 2009 19:16:49 +0200

Ferien!!
Soo, Latein und Englisch gehören mal wieder der Vergangenheit an .
Ich hab zwar nebenbei auch mal wieder ein paar kleine Bugs beseitigt, aber das wäre keinen Eintrag wert gewesen . Aber in der Summe hat sich dann doch einiges getan: Ich habe z.B. einige Dinge in externe Dateien ausgelagert, wie die Definitionen der Klassen. Neben ein paar kleinen (nicht nennenswerten) Änderungen, habe ich mir auch ein Grundkonzept für einen Garbage Collector überlegt.

Grundkonzept:
Beim Start des Programms wird eine Globale MemList vom Typ TList erstellt, in der TMemBlock Objekte gespeichert werden. Ein TMemBlock(MemPointer;Counter) Element wird erstellt wenn ein Speicherblock von Windows angefordert wird. MemPointer wird dabei auf die Adresse des Speicherblocks gesetzt und der Counter auf 0. Bei jeder Zuweisung wird in der MemList nach einer Übereinstimmung mit dem vorherigen Wert der Variable und dem neuen Wert gesucht. Wird der neue Wert gefunden, wird der Counter um eins erhöht. Wird der alte Wert gefunden, wird der Counter um eins erniedrigt. Ist der Counter auf 0 wird der Speicher freigegeben. Genauso bei den Parametern: Bei jedem Parameter wird nach einem Eintrag gesucht und evtl. erhöht. Am Ende einer jeden Funktion werden die Pointer auf dem Stack wieder von der Liste gestrichen. So nur mal im groben.
Irgendwie kommt mir das ein wenig kompliziert vor, aber alle anderen Wege die mir einfielen hatten einen Haken .

Ein kleines Beispiel dazu:
abc:Tiwas=New Tiwas
def:Tiwas=abc
abc=0
def=0

Speicherblock anfordern
Neuer Eintrag(MemPointer=Speicher;Counter=0)
Zuweisung => Counter=1 (abc:Tiwas=New Tiwas)
Zuweisung => Counter=2 (def:Tiwas=abc)
Zuweisung => Counter=1 (abc=0)
Zuweisung => Counter=0 => Delete (def=0)

Wenn jemand eine Idee hat wie man den GC besser implementiert, der lasse es mich bitte wissen .

Ansonsten werde ich mich am heutigen Abend an die Umsetzung machen.