BlitzBasic Portal Worklogs - Simple Script Max

Bugs vs Coolo: 1 : 0

coolo — Tue, 22 Dec 2009 15:45:18 +0100

Hallo,
es gibt nun zwei Dinge zu Berichten. Zuerst die Traurige Nachricht: Ich finde jetzt in letzter Zeit immer mehr Bugs. Diese sind allerdings schätze ich recht harmlos.

Nunja beginnen wir mal.
Arrays sind im Moment sehr anfällig. Unter anderem haben sie Probleme Strings und Floats zu speichern, weswegen weiß ich nicht.
Der Garbage Collector hat auch große Probleme mit Arrays, da der nicht die Arrays durchkauern kann. Wobei ich ja Reference Counting und Mark and Sweep verwende. Reference Counting funktioniert ohne Probleme, allerdings die Mark and Sweep implementation nicht.

Der nächste große Bug Punkt ist die Rekursion. Diese funktioniert nicht richtig. Ich dachte ich habe das Problem gelöst, allerdings war das nur eine Teillösung. Da muss ich mir weiter den Kopf zerbrechen.

Ich hoffe ich werde bald die Probleme Entbuggen.

Der nächste Punkt ist die IDE. Diese funktioniert einwandfrei und außreichend schnell. Sie hat außerdem eine Rückgängig/Wiederholen Funktion sowie Syntax highlighting.

Jetzt ist auf meiner effektiven ToDo Liste (Also keine Bugs) nurmehr die API zu finden .

Endspurt!

coolo — Fri, 11 Dec 2009 15:03:56 +0100

Hallo,

ja es ist soweit die OOP funktioniert tadellos und beherrscht die kompliziertesten Konstrukte. Rekursion sei dank .

Das heißt auf meiner ToDo Liste sind nurmehr zwei Einträge bis zur Veröffentlichung.
API: Diese braucht noch einige Funktionen, ich will auf keinen Fall so eine schreckliche API wie in Lua. Es soll alles leicht zugänglich sein und ohne Probleme funktionieren.

IDE: Diese soll recht simpel sein, aber doch mit Syntax Highlighting.

Eventuell werde ich noch eine Syntaxüberprüfung implementieren. Diese wird allerdings nicht jeden Furz anzeigen, da die Sprache recht dynamisch ist.

Natürlich müssen noch zahlreiche Käfer gefunden werden. Unter anderem hat der Garbage Collector Probleme mit den neuen Arrays. Dieser Bug wird hoffentlich bald gefixt sein.

Tja für die Version zwei ist aufjedenfall ein BB/GLBasic Port auf der Liste, sowie eine Private/Public/Protected und evtl. ein Debugger.

MfG
Coolo

Normale Arrays Ahoi!

coolo — Sun, 06 Dec 2009 11:56:54 +0100

Neuer Tag neues Glück!

Tja was habe ich Gemacht? Hauptsächlich wurden die normalen Arrays, ab jetzt "Blöcke" genannt implementiert. Diese sind sehr schnell und auch leichter zu Debuggen. Der Nachteil ist, dass diese nicht in ihrer Größe verändert werden können, ohne das Inhalt verloren geht.

Code: [AUSKLAPPEN]

Local EinArray:Int
Dim(*EinArray,10,10,100)
EinArray[5,9,99]["Hallo Welt"]=200 //Mischen von Assoziativen und normalen Arrays
Print(EinArray[5,9,99]["Hallo Welt"])

Local AnderesArray:Int
AnderesArray[10,]=0 //Definiere ein normales Array, ohne Dim
//(Der Beistrich ist nur dazu da um anzumerken, dass es
//normales Array ist, sonst denkt der Parser es ist ein
//assoziatives Array...)
//AndresArray[5,1]=0 würde auch gehen, bzw AnderesArray[4,5]
AnderesArray[2]=100
Print (AnderesArray[2])

//Mehrere Dimensionen auch möglich
Local MehrDim:Int
MehrDim[4,][7,][9,][6,][2,]=0 //Ja da haben wir 5 Dimensionen!
MehrDim[1][2][3][4][1]=10
Print(MehrDim[1][2][3][4][1])

Das besondere an diesen ist, dass Asoziative und normale Arrays vermischt werden können. Es sind aber leider nur maximale 4 Array Dimensionen in Normalen Arrays möglich. Dieses Manko lässt sich mit Arrays of Arrays leicht lösen, ist allerdings ein wenig langsamer...

Tja was gibt es sonst noch zu erzählen?
ForEach funktioniert nun auch, aber dies ist grottenlangsam und deswegen werden nur maximal ein Dimensionale Assoziative Arrays unterstützt.

Als nächstes muss unbedingt die OOP wieder laufen.

MfG
Coolo

Assoziative Arrays²

coolo — Sat, 05 Dec 2009 15:58:35 +0100

Hallo,
in den letzten Tagen wars etwas still um Simple Script Max. In der Tat habe ich mit Motivationsschwankungen zu kämpfen, aber letzlich hat der Wille gesiegt \o/.

Assoziative Arrays:
Code: [AUSKLAPPEN]

Local MeinArray:Int
//Dim(*MeinArray) //Nicht mehr notwendig
//Dim(*MeinArray[-10]) //Auch nicht notwendig
MeinArray[-10][-5*2]=100000
MeinArray[-10]["Hallo Welt"]=99
Print (MeinArray[-10][-10] * MeinArray[-10]["Hallo Welt"])
Print (EineFunk(MeinArray)[10]) //Jahaa das funkt endlich :)

Function EineFunk(EineInt:Int)
Local EinArray:Int
EinArray[10]=100
Return (EinArray)
EndFunction

Diese Arrays sind extrem flexibel, da die Arrays On The Fly deklariert werden können.

Die Arrayblöcke kommen als nächstes dran, danach wird die OOP endlich wieder auf Vordermann gebracht .

MfG
Coolo

Alles neu!

coolo — Thu, 03 Dec 2009 06:58:46 +0100

Hoi und guten morgen *gähn*.

Da mir in letzter Zeit sehr viele Bugs aufgefallen sind bezüglich OOP Instanzzugreifsystem und Arrays in Klassen, habe ich mich entschieden diese zwei Dinge völlig neu zu schreiben. Das kann sehr lange dauern.

Dazu habe ich mir überlegt die Syntax für die Arrays neu zu erstellen. Dies wäre: Code: [AUSKLAPPEN]

Local MeinArray:Array // Es soll ein Array sein
MeinArray=New MeinArray(Int) // Keine Dimensionen heißt, dass es ein assoziatives Array ist es ist vom Datentyp Int
MeinArray["Hallo Welt"]=New MeinArray(Int) //Unterarray erzeugen, Es ist vom Datentyp Int
MeinArray["Hallo Welt"][-100]=1000

Das Ziel ist auch, dass folgende Konstrukte erlaubt werden: Code: [AUSKLAPPEN]

Print (MeinArray[10][-10][100]("Ein Parameter")["Das ist das rückgabe Array"]) //MeinArray enthällt einen Funk Ptr

Außerdem habe ich mir das Konzept der "Speicherblöcke" überlegt. Speicherblöcke sind im Grunde genommen ganz normale Arrays, nur dass diese eine feste größe haben (Also die normalen Arrays). Diese werden ähnlich implementiert:
Code: [AUSKLAPPEN]

Local MeinBlock:Array
MeinBlock=New Array(Int,3,4) //3,4 Dimensionen, mit Dimensionen heißt, dass es ein Block ist
MeinBlock[2][1]=100
Print(MeinBlock[2][1])

Der Vorteil dieser ist natürlich, dass sie um einiges schneller sind als die normalen Arrays.

Diese Dinge stehen allerdings noch in der Konzeptphase.

Außerdem ist nun das "=" ein ganz normaler Operator. Das heißt, dass folgende Dinge ohne Probleme möglich sind: Code: [AUSKLAPPEN]

Local MeineVar1:Int
Local MeineVar2:Int
MeineVar1=(MeineVar2=100)*4

MeineVar1 ist 400
MeineVar2 ist 100

Vielen Dank für das Lesen

Kleine Dinge.

coolo — Sun, 29 Nov 2009 08:03:52 +0100

Hallo,

ich hab in den letzten Tagen eher kleinere (aber sehr praktische Sachen) gemacht.

Unter anderem kann man nun statt dem "->" auch den "." verwenden um auf Klasseninstanzen zuzugreifen.

Außerdem wurde der Bug mt den Lokalen Variablen gefixt. Diese werden sobald eine Funktion aufgerufen wird im "imaginären" Stack (Einen richtigen Stack gibt es nicht) gespeichert, und sobald wieder aus der Funktion ausgetreten wird werden wieder die Variablen hineingesetzt.

Nebenbei kann man nun auch statische Variablen deklarieren. Einfach statt "Local" "Static" schreiben.

Man kann nun auch Klassen Attribute vordefinieren "Field MeinFeld:Int = 100".

Jetzt gibt es auch den "this" Zeiger, dieser ist intern nur eine Referenz auf den "self" Zeiger.

Ich bin leider auf ein sehr schlimmes Problem gestoßen:
Folgende Konstrukte funktionieren nicht:
Code: [AUSKLAPPEN]

MeineInstanz->GetIrgendwas(Hallo->was)->Methode() //Gerät in eine Endlos schleife weil der parser denkt "Hallo->was" gehört zu MeineInstanz
MeineReferenz["Hallo Welt"]->Gaga(Bu()[10])->Wasdenn() //Arrays werden völlig ignoriert...

MfG
Coolo

\o/ \o/ \o/ \o/

coolo — Fri, 27 Nov 2009 20:23:39 +0100

Hallo,

puh ich hab in den letzten drei Tagen soviel gemacht, dass ich glatt vergessen hab einen WL Eintrag zu verfassen.

Nundenn hier ist er nun.
Die wichtigste Erneuerung:
Garbage Collector
Dieser ist eine hybride Lösung. Einerseits verwendet er simples Reference Counting (Das was BlitzMax verwender) andererseits auch einen Mark and Sweep Algorithmus.
Reference Counting hat den entscheidenden Nachteil, dass es Cycling Objects nicht erkennt. (Type TTest; Field Val:TTest = Self; EndType)
Darum wurde der Mark and Sweep Algorithmus implementiert, dieser wird alle 10 Sekunden (einstellbar) oder manuell aufgerufen.
Der GC läuft mittlerweile sehr stabil und ohne Probleme.
Code:
[syntax="bmax"]Type TTest
Field Val:TTest2
Field Zahl:Int
EndType

Type TTest2
Field Val:TTest
EndType

Local Test:TTest=New(TTest)
Test->Zahl=100
Local Test2:TTest

Test->Val=New(TTest2)
Test2=Test->Val
Test2->Val=Test

Test=Null
Test2=Null

Collect() //Langsames Collecten[/syntax]

Statische Funktionen/Attribute.
Funktionieren genauso wie in BMax.
[syntax="bmax"]Type TTest
Global Val:Int

Function Test(sdfdf:int, Huhu:int)
Print("In Funktion")
EndFunction
EndType

Local Test:TTest=New(TTest)
Test.Test()
Test.Val=100
Local Test2:TTest=New TTest()
Test2.Test()
TTest.Test()
Print("Statisches Attribut: " + TTest.Val)
[/syntax]

Meine ToDo Liste enthält nurmehr 5 EInträge (einer davon ist allerdings ein sehr hartnäckiger Bug...)

MfG
Coolo

Klassen funktionieren wieder

coolo — Wed, 25 Nov 2009 17:32:01 +0100

Hallo,

nach Stunden des Bug suchens habe ich nun endlich das Klassen System auf den alten Stand gebracht. Das heißt das Referenzsystem ist nun um einiges Stabiler (und schneller...) als das zuvor verwendete Int Handle System.

Außerdem können nun folgende Ausdrücke geparst und ausgeführt werden (Das Beispiel ist eig. sinnlos):
[syntax="bmax"]Test1 CastTo TBaseType CastTo Object CastTo TBaseType CastTo TTest->ToString()[/syntax]

Außerdem habe ich einen furchtbaren Bug im FUnktionssystem gefunden: Rekursive Funktionsaufrufe funktionieren nicht. Um dieses problem zu umgehen habe ich 2 Lösungen parat:

*1. Einen neuen Variablen Deklarationstype implementieren, dieser würde bei jedem Funktionsaufruf im Speicher intern kopiert werden und dann mit dem zu arbeiten.

*2. Alle Lokale Variablen werden beim Funktionsaufruf intern kopiert. Dies würde zwar einfacher sein, wäre allerdings um einiges langsamer.

*3. Ein mittelding aus den zwei Varianten. Man definiert eine Rekursive Funktion (Diese darf sich dann selber aufrufen) und die anderen dürfen das nicht. Dies wäre ein gutes Mittelding aus den Varianten.

Ich muss mir überlegen wie ich das nun implementiere. Am liebsten wäre mir natürlich Variante 2. Ich werde schauen was sich da Geschwindigkeits Fresser verbergen.

MfG
Coolo

Tschüss Int Handles, Hallo Referenzen!

coolo — Tue, 24 Nov 2009 07:15:31 +0100

Hallöchen,
gestern habe ich leider vergessen einen Worklog Eintrag zu erstellen. Dies hole ich nun nach.

Das Problem am alten Klassensystem war, dass ich mit Int Handles gearbeitet habe. Dadurch war es zwar kinderleicht sie als Funktionsparameter zu verwenden, oder in Arrays zu speichern. Hatte aber einen gravierenden Nachteil: Einen Garbage Collector mit diesem System zu implementieren ist nahezu unmöglich. Außerdem sind Int handles auch nicht die schnellsten .

Dadurch das nun auch Referenzen unterstützt werden habe ich auch diese verwendet um dieses Problem zu beseitigen.
Im moment arbeiten Klassen _fast_ wie vorher, nur dass es noch Probleme mit dem zurückgeben von Klassen in Funktionen gibt.

Folgender Code war früher praktikabel:
Code: [AUSKLAPPEN]

Type MeineInt
Field Val:Int
EndType
Local MeineInstanz:Int=New(MeineInt) //Man sieht es man konnte Ints verwenden

Solch ein Code ist mittlerweile strikt untersagt.

Nebenbei habe ich nun das letzte Sprachkonstrukt implementiert, das noch ausständig war:
Select - Case - Default - EndSelect
Arbeitet genauso wie in BlitzMax.
Code:
Code: [AUSKLAPPEN]

Select 10
Case 5
Print("Butter")
Case 10
Print("Salami")
Default
Print("Nichts")
EndSelect

MfG
Coolo

Referenzen sind cool!

coolo — Sun, 22 Nov 2009 10:38:54 +0100

Hallo,
in den letzten Stunden habe ich die Funktions und Variablen Referenzen implementiert. Dazu musste ich dem "*" eine neue Fähigkeit beibringen. Dieser Operator gibt die interne ID der Variable/Funktion zurück, somit kann diese dann intern "erkannt" werden und der Referenz zugefügt werden.

Diese Referenzen fungieren als völlig normale Variablen. Sie können sogar Arrays beinhalten, oder ganze Klassen (Diese sind aber von Haus aus schon Referenzen).
Außerdem ist es möglich Referenzen wieder zurückzusetzen, dadurch ist das Debugging um einiges leichter.

Variablen:[syntax="bmax"]Local MeineRef:Ref
Local MeineInt:Int
MeineInt=100
MeineRef=*MeineInt
Print(MeineRef)

Local RefVar:Int[]
RefVar[100]=10
EineFunc(*RefVar)
Unref(*MeineRef) //Nicht nötig aber zum veranschaulichen gut

Function EineFunc(var:Ref)
Print(var[100])
EndFunction[/syntax]

Die Funktions Refernzen funktionieren ebenfalls. Es ist möglich auch Methoden zu referenzieren, es wird aber geraten dies nicht zutun, da es manchmal zu unvorhergesehenen Dinge kommt (Der Self Pointer wird falsch übernommen) warum das so ist weiß ich nicht, aber das wird sich schon irgendwann zeigen.

Funkionen:[syntax="bmax"]Local FuncRef:Ref
FuncRef=*MeineRefFunc
FuncRef(10)
print("Ende")

Function MeineRefFunc(EinPara:int)
Print("In Funktion! "+EinPara)
EndFunction[/syntax]

Nebenbei hab ich einen Bug bei den Globalen Variablen festgestellt, der etwas tiefer im System versteckt ist.

MfG
Coolo