GLScriptBasic

Previous topic - Next topic

Kitty Hello

This project is totally awesome. The only problem is, that coolo said he has some tiny bug and can't be bothered to try and fix it. And the code seems so compex, that noone dared to play with it so far. I really want to encourage you to do so. It's really a cool idea.

Albert

If I understood correctly (via google translate) there are some bugs when you using arrays. I'm didn't plan to use arrays, so it will ok for me :)
I tried to understand the code yesterday to BYREF, but I didn't make it too far, the code is far too difficult.

metzzo

Hey Leute!

Ich wollte nur mal kurz anmerken, dass ich an GLBasicScript (2) arbeite. Dies ist ein kompletter Rewrite, der versucht die alten Fehler zu umgehen.

Veränderungen gegenüber der alten Version:
1) 4 Pass Compiler: Eines der Hauptprobleme an der alten Version war, dass es ein Singlepass Compiler war. Hierdurch war es zwar sehr schnell, allerdings war es sehr schwer zu debuggen und viele (einfache) Sachen waren vergleichsweise umständlich zu implementieren.
Die Durchläufe:
- Lexer: Alles in Tokens zerteilen (done)
- Analyser: Alle GLOBAL/FUNCTION/TYPE/CONSTANT/SUB/WHATEVER suchen und registrieren (hier werden bereits Syntaxfehler angezeigt) (done)
- Parser: Einen abstrakten Syntaxbaum erstellen und Syntaxfehler finden (sollten sehr genaue Beschreibungen liefern)
- Generator: Erstellt aus dem Syntaxbaum den Zielcode
2) Compilerbackend ist generisch: Nun erstellt EINE Funktion den Zielcode. Diese ist als CALLBACK deklariert, wodurch man ohne weiteres andere Outputs anvisieren kann (JavaScript, ...). Früher war Codegenerierung mit Codeparsing vermischt.
3) Virtuelle Maschine schneller und optimiert: Die VM wird zu 95% in C++ geschrieben, wodurch ich void* verwenden kann. Die alte Version der VM war in GLB geschrieben. Hauptproblem daran war, dass GLB keine generischen Datentypen anbietet, welche beliebige Daten speichern können (also ein void* Pedant), wodurch das alles viel komplizierter wurde (vorallem die Stackimplmentierung)
4) Abstrakter Syntaxbaum: Im Gegensatz zur alten Version wird nun ein echter AST erstellt, wodurch sogar diverse Optimierungen möglich sind.
5) Mehr Erfahrung: Ich habe in der Zwischenzeit an einem anderen Compiler gearbeitet (der bereits von der Syntax her fertig ist, allerdings habe ich keine Motivation mehr den weiter zu machen)
6) Ich mag Kekse.

Aktueller Stand? Analysing und Lexing funktioniert bereits fehlerfrei, Parsing ist auch schon recht fortgeschritten und die Codegeneration ist genau so fortgeschritten, wie das Codeparsing. Allerdings ist die VM noch in den Kinderschuhen, diese kann lediglich Werte auf den Stack pushen. Aber gut Ding braucht weil :D

Konzept? Dasselbe wie früher (annähernd komplette GLBasicsyntax Unterstützung), allerdings wird auch JavaScript als Output möglich sein (GLBasic im Browser \o/).

Bis jetzt funktioniert dieses Beispielprogramm:
Code (glbasic) Select
STDOUT 2+4*8
LOCAL i, j, k
i = 204*(2+2)
STDOUT i


NATIVE FUNCTION STDOUT: Output$ //Um die nativen GLBasic Funktionen reinzuholen
NATIVE FUNCTION STDERR: Error$

Kontrollstrukturen kommen als letztes. Variablen->Arrays->Types->Funktionen->Kontrollstrukturen->Rest
Kompiliert zwar, führt aber nicht aus.

So sieht die Funktion aus, welche dann die OpCodes erzeugt.
Code (glbasic) Select
CALLBACK FUNCTION Generate$: expr AS Expr
//STDOUT "Generating token: "+expr.token.Text$+" in Line "+expr.token.LineContent$+" type: "+expr.Typ+"\n"
LOCAL Text$ = ""
SELECT expr.Typ
CASE EXPR_IS_SCOPE
CurrentScope = expr.ID
Text$ = Text$ + "//startscope\n"
LOCAL Size% = 0
FOREACH Vari IN expr.Varis[]
INC Size, GetDatatypeSize(Exprs[Vari].datatype)
NEXT
Text$ = Text$ + "alloc " + Size + "\n"
FOREACH Ex IN expr.Exprs[]
Text$ = Text$ + Generate$(Exprs[Ex])
NEXT
Text$ = Text$ + "//endscope"
CASE EXPR_IS_OPERATOR
Text$ = Text$ + Generate$(Exprs[expr.Left])
Text$ = Text$ + Generate$(Exprs[expr.Right])
Text$ = Text$ + Operators[expr.Op].Name$
CASE EXPR_IS_INT
Text$ = "pushi "+expr.intval
CASE EXPR_IS_FLOAT
Text$ = "pushf "+expr.floatval
CASE EXPR_IS_STR
Text$ = "pushs "+expr.strval$
CASE EXPR_IS_FUNCCALL
FOREACH param IN expr.Params[]
Text$ = Text$ + Generate$(Exprs[param])
NEXT
Text$ = Text$ + "jmpf "+expr.func.ID
CASE EXPR_IS_VARI
Text$ = Text$ + "pushv "+CalculateVariPos(expr.vari)
CASE EXPR_IS_ASSIGN
Text$ = Text$ + "//Value\n"
Text$ = Text$ + Generate$(Exprs[expr.Right])
Text$ = Text$ + "assign "+CalculateVariPos(expr.vari)
CASE EXPR_IS_EMPTY
CASE EXPR_IS_DEBUG
Error("Invalid Expression (generator error)")
DEFAULT
Error("Unknown expression type (generator error)")
ENDSELECT

RETURN Text$ + "\n"
ENDFUNCTION

Wie man sieht, sehr generisch gehalten, weshalb beliebige Zielsprachen möglich sind.

MfG
That's no Bug, that's my project!

http://programming-with-design.at/

Schranz0r

Schön zu hören das du wieder an dem Projekt weiter machst!
Finde ich super, aber vorallem Punkt 6 hört sich gut an :)
I <3 DGArray's :D

PC:
AMD Ryzen 7 3800X 16@4.5GHz, 16GB Corsair Vengeance LPX DDR4-3200 RAM, ASUS Dual GeForce RTX™ 3060 OC Edition 12GB GDDR6, Windows 11 Pro 64Bit, MSi Tomahawk B350 Mainboard

Kitty Hello

Wenn das geht, flipp ich voll aus. Wenn Du Hilfe brauchst, bitte melden. Wenn Du keine Hilfe bracuhst, sag mir wie Du's gemacht hast. ;)

Albert


metzzo

Freut mich zu hören :)

Mittlerweile funktionieren Types, Arrays und Variablen in den Grundzügen. Allerdings wird noch nichts ausgeführt, da die VM noch nicht einmal ansatzweise funktioniert.

Folgender Code wird bereits richtig kompiliert:
Code (glbasic) Select
STDOUT 2+4*8
LOCAL i, j, k
LET i = 204*(2+2) //LET optional
STDOUT i
STDOUT j
STDOUT k

STDOUT "Hallo Welt"
LOCAL arr1[]
DIM arr1[10]
REDIM arr1[14] //Redim \o/
arr1[8] = 99
STDOUT arr1[8]

LOCAL arr2[]
arr2 = arr1 //kopieren
arr1[] = arr2[] //auch kopieren \o/
LOCAL b AS Buch
b.Seite = 200
STDOUT b.Seite
DIM b.Seiten$[100][100]

LOCAL r AS Regal
DIM r.Buecher[100]
r.Buecher[0] = b
r.Buecher[0].Titel$ = "Harry Potter"

TYPE Regal
Buecher[] AS Buch
ENDTYPE

TYPE Buch
Seite%
Titel$
Besitzer$
Seiten$[]
ENDTYPE


NATIVE FUNCTION STDOUT AS void: Output$
NATIVE FUNCTION STDERR AS void: Error$

Kompilierzeit dafür beträgt 30MS (auf einem Atom Netbook!) und das trotz einem 4 pass Compiler.

Mit freundlichen grüßen, aus Kroatien (Urlaub <3) :)
That's no Bug, that's my project!

http://programming-with-design.at/

metzzo

Der Compiler beherrscht nun Funktionen in _Grundzügen_ das heißt, dass es zwar keine bekannten Fehler gibt, aber dass bestimmt noch vier dutzend versteckt im Code liegen.

Außerdem habe ich den JavaScript Codegenerator angefangen, dieser ist bereits auf dem Stand des Compilers und der erzeugte Code funktioniert wunderprächtig!
Aus:
Code (glbasic) Select
STDOUT 2+4*8
LOCAL i, j = 999, k = GetInt()
GLOBAL l = GetInt()
LET i = 204*(2+2) //LET optional
STDOUT i
STDOUT j
STDOUT k


STDOUT "Hallo Welt "+100
LOCAL arr1[]
DIM arr1[10]
REDIM arr1[14] //Redim \o/
arr1[8] = 99
STDOUT arr1[8]

LOCAL arr2[]
arr2 = arr1 //kopieren
arr1[] = arr2[]

LOCAL b AS Buch
b.Seite = 200
STDOUT b.Seite
DIM b.Seiten$[100][100]

LOCAL r AS Regal
DIM r.Buecher[100]
r.Buecher[0] = b
r.Buecher[0].Titel$ = "Harry Potter"
STDOUT r.Buecher[0].Titel$

TYPE Regal:
Buecher[] AS Buch
ENDTYPE

TYPE Buch
Seite%
Titel$
Besitzer$
Seiten$[]
ENDTYPE

testFunktion$ 10, 20, 30
andereTestFunktion 40
GOSUB mySub //GOSUB optional

FUNCTION empty:
ENDFUNCTION

FUNCTION testFunktion$: param1, param2, param3
STDOUT "Ich bin in einer Funktion \o/ "+param1+" "+param2+" "+param3

RETURN "ROFL"
ENDFUNCTION

FUNCTION andereTestFunktion: param4

ENDFUNCTION

SUB mySub:
STDOUT "I'm in SUB!!!"
RETURN
STDOUT "Ich werde nie angezeigt lol!"
ENDSUB

FUNCTION GetInt%:
RETURN 42
ENDFUNCTION

Wird:
Code (glbasic) Select
<html>
<head>
<title>GLBasic</title>
<script type="text/javascript" src="JS/lib.js"></script>
<script type="text/javascript">
function main(){
   var i = 0.0, j = 0.0, k = 0.0, arr1 = new Array(), arr2 = new Array(), b = Buch(), r = Regal();
   STDOUT(2 + 4 * 8);
   i = 204 * 2 + 2;
   STDOUT(i);
   STDOUT(j);
   STDOUT(k);
   STDOUT("Hallo Welt " + 100);
   //DIM(...);
   //REDIM(...);
   arr1[8] = 99;
   STDOUT(arr1[8]);
   arr2 = arr1.slice(0);
   arr1 = arr2.slice(0);
   b.Seite = 200;
   STDOUT(b.Seite);
   //DIM(...);
   //DIM(...);
   r.Buecher[0] = b.clone();
   r.Buecher[0].Titel_Str = "Harry Potter";
   STDOUT(r.Buecher[0].Titel_Str);
   testFunktion$(10, 20, 30);
   andereTestFunktion(40);
   mySub();
   
};
function  testFunktion_Str(param1, param2, param3) {
   STDOUT("Ich bin in einer Funktion \o/ " + param1 + " " + param2 + " " + param3);
   return "ROFL";
   
};
function  andereTestFunktion(param4) {
   
};
function  mySub() {
   STDOUT("I'm in SUB!!!");
   return 0;
   STDOUT("Ich werde nie angezeigt lol!");
   
};
function  GetInt() {
   return 42;
   
};
function Regal() {
   this.clone = function() {
      var other = new Object();
      other.Buecher = this.Buecher.clone();
      return other;
   };
   this.Buecher = new Array();
   return this;
   
};
function Buch() {
   this.clone = function() {
      var other = new Object();
      other.Seite = this.Seite;
      other.Titel_Str = this.Titel_Str;
      other.Besitzer_Str = this.Besitzer_Str;
      other.Seiten_Str = this.Seiten_Str.slice(0);
      return other;
   };
   this.Seite = 0;
   this.Titel_Str = "";
   this.Besitzer_Str = "";
   this.Seiten_Str = new Array();
   return this;
   
};

</script>

</head>
<body onLoad="main();">
<textarea name="GLBContent" style="width:100%;height:100%">
</textarea>
</body>
</html>


Außerdem wurden nun die Fehlermeldungen erweitert. Nun motzt der Compiler rum, wenn man eine Funktion doppelt benennt oder wenn man eine Variable verwendet welche nicht existiert (anstatt einfach eine neue Variable implizit zu erstellen) usw.

MfG
That's no Bug, that's my project!

http://programming-with-design.at/

Kitty Hello


metzzo

Heyho!

Der JavaScript Compiler nimmt langsam Form an! Arrays funktionieren bereits prächtig (Arrayboundchecking muss ich noch implementieren, aber das hat eher geringere Priotität). Auch funktionieren nun Dinge wie GLOBAL a = Foo() und auch FUNCTION bar: xyz = Foo() compilerseitig. Allerdings müssen die beiden Codegeneratoren daran noch angepasst werden. Außerdem funktioniert nun CALLBACK \o/, war vergleichsweise einfach zu implementieren, dank dem tollen 4 pass System.

Folgender Code wird bereits erfolgreich in JavaScript / VM Code kompiliert:
Code (glbasic) Select
LOCAL i, j = 999, k = GetInt()
GLOBAL l = GetInt()
LET i = 204*(2+2) //LET optional
STDOUT "i: "+i+"\n"
STDOUT "j: "+j+"\n"
STDOUT "k: "+k+"\n"


STDOUT "Hallo Welt "+100+"\n"
LOCAL arr1[]
DIM arr1[10]
REDIM arr1[14] //Redim \o/
arr1[8] = 99
STDOUT "Array 1 an der Stelle 8: "+arr1[8]+"\n"


LOCAL arr2[]
STDOUT "1--- \n"
arr2 = arr1 //kopieren
STDOUT "2--- \n"
arr1[] = arr2[]
STDOUT "3--- \n"

LOCAL b AS Buch
b.AktuelleSeite = 200
STDOUT "buch Seite: "+b.AktuelleSeite+"\n"
DIM b.Seiten$[100][100]


LOCAL r AS Regal
DIM r.Buecher[100]
r.Buecher[0] = b
r.Buecher[0].Titel$ = "Harry Potter"
STDOUT "Erstes Buch im Regal: "+r.Buecher[0].Titel$+"\n"
DIM r.Buecher[0].Seiten[100]
r.Buecher[0].Seiten[0].Text$ = "lol"


TYPE Regal:
Buecher[] AS Buch
ENDTYPE

TYPE Buch
AktuelleSeite
Titel$
Besitzer$
Seiten$[]
Seiten[] AS Seite
ENDTYPE

TYPE Seite
Alter%
Text$
ENDTYPE

testFunktion$ 10, 20, 30
andereTestFunktion 40
GOSUB mySub //GOSUB optional

FUNCTION empty:
ENDFUNCTION

FUNCTION testFunktion$: param1, param2 = 900, param3 = 400
STDOUT "Ich bin in einer Funktion \\o/ "+param1+" "+param2+" "+param3+"\n"

RETURN "ROFL"
ENDFUNCTION

CALLBACK FUNCTION andereTestFunktion: param4
STDOUT "Ich bin da"
ENDFUNCTION

FUNCTION andereTestFunktion: param4
STDOUT "ICH BIN DA SO SUPPPPPER"
ENDFUNCTION

SUB mySub:
STDOUT "I'm in SUB!!! \n"
RETURN
STDOUT "Ich werde nie angezeigt lol! \n"
ENDSUB


FUNCTION GetInt%:
RETURN 42
ENDFUNCTION


wird in JS:
Code (glbasic) Select
<html>
<head>
<title>GLBasic</title>
<script type="text/javascript" src="JS/lib.js"></script>
<script type="text/javascript">
function main(){
   var i = 0.0, j = 0.0, k = 0.0, arr1 = GLBArray(), arr2 = GLBArray(), b = Buch(), r = Regal();
   i = 204 * 2 + 2;
   STDOUT("i: " + i + "\n");
   STDOUT("j: " + j + "\n");
   STDOUT("k: " + k + "\n");
   STDOUT("Hallo Welt " + 100 + "\n");
   DIM(arr1, [10], 0.0);
   REDIM(arr1, new Array(14), 0.0);
   arr1.values[8] = 99;
   STDOUT("Array 1 an der Stelle 8: " + arr1.values[8] + "\n");
   STDOUT("1--- \n");
   arr2 = arr1.clone(/* 2 */);
   STDOUT("2--- \n");
   arr1 = arr2.clone(/* 2 */);
   STDOUT("3--- \n");
   b.AktuelleSeite = 200;
   STDOUT("buch Seite: " + b.AktuelleSeite + "\n");
   DIM(Seiten_Str, [100, 100], "");
   DIM(Buecher, [100], Buch());
   r.Buecher.values[0] = b.clone(/* 2 */);
   r.Buecher.values[0].Titel_Str = "Harry Potter";
   STDOUT("Erstes Buch im Regal: " + r.Buecher.values[0].Titel_Str + "\n");
   DIM(Seiten, [100], Seite());
   r.Buecher.values[0].Seiten.values[0].Text_Str = "lol";
   testFunktion_Str(10, 20, 30);
   andereTestFunktion(40);
   mySub();
   
};
function  testFunktion_Str(param1, param2, param3) {
   var param1 = 0.0, param2 = 0.0, param3 = 0.0;
   STDOUT("Ich bin in einer Funktion \\o/ " + param1 + " " + param2 + " " + param3 + "\n");
   return "ROFL";
   
};
function  andereTestFunktion(param4) {
   var param4 = 0.0;
   
};
function  mySub() {
   STDOUT("I'm in SUB!!! \n");
   return 0;
   STDOUT("Ich werde nie angezeigt lol! \n");
   
};
function  GetInt() {
   return 42;
   
};
function Regal() {
   this.Buecher = GLBArray();
   this.clone = function() {
      var other = new Object();
      other.Buecher = this.Buecher.clone();
      return other;
   };
   return this;
   
};
function Buch() {
   this.AktuelleSeite = 0.0;
   this.Titel_Str = "";
   this.Besitzer_Str = "";
   this.Seiten_Str = GLBArray();
   this.Seiten = GLBArray();
   this.clone = function() {
      var other = new Object();
      other.AktuelleSeite = this.AktuelleSeite;
      other.Titel_Str = this.Titel_Str;
      other.Besitzer_Str = this.Besitzer_Str;
      other.Seiten_Str = this.Seiten_Str.clone();
      other.Seiten = this.Seiten.clone();
      return other;
   };
   return this;
   
};
function Seite() {
   this.Alter = 0;
   this.Text_Str = "";
   this.clone = function() {
      var other = new Object();
      other.Alter = this.Alter;
      other.Text_Str = this.Text_Str;
      return other;
   };
   return this;
   
};

</script>
</head>
<body onLoad="main();">

<!--<textarea name="GLBContent" style="width:100%;height:100%">
</textarea>-->
</body>
</html>


Als nächstes sollte ich mich langsam an die VM setzen, diese ist noch kaum angefangen :/

MfG
That's no Bug, that's my project!

http://programming-with-design.at/

Quentin

sieht ja wirklich super aus. Vor allem die Idee, das in JavaScript zu übersetzen, finde ich genial. Wo um alles in der Welt hast du das gelernt?

metzzo

Hey!!

GLBScript hat nun vordefinierte Variablen bekommen. Das heißt, dass LOCALs/GLOBALs/TYPEs/FUNCTIONs(Parameter) vordefinierte Werte haben können (auch Funktionsaufrufe!). Also FUNCTION Foo: Bar = GetInt(); funktioniert genauso wie GLOBAL Foo = Bar().
Nebenbei habe ich auch FUNCTIONs in TYPEs implementiert. Hier gibt es allerdings noch kleinere Probleme, welche noch gelöst werden müssen (vor allem, wenn eine Methode einen TYPE zurückgibt kommt der Expressionparser nicht ganz klar).

Außerdem konzentriere ich mich im Moment vorwiegend auf den JavaScript - Compiler, da - wie ich finde - das mehr Priorität hat, als eine Scriptsprache für GLB.

Folgender Code wird ohne Probleme kompiliert:
Code (glbasic) Select
LOCAL i, j = 999, k = GetInt()

LET i = 204*(2+2) //LET optional
STDOUT "i: "+i+"\n"
STDOUT "j: "+j+"\n"
STDOUT "k: "+k+"\n"

STDOUT (4+4*2) + ": Zahl! \n"

STDOUT "Hallo Welt "+100+"\n"
LOCAL arr1[]
DIM arr1[10]
REDIM arr1[14] //Redim \o/
arr1[8] = 99
STDOUT "Array 1 an der Stelle 8: "+arr1[8]+"\n"

LOCAL arr2[]
STDOUT "1--- \n"
arr2 = arr1 //kopieren
STDOUT "2--- \n"
arr1[] = arr2[]
STDOUT "3--- \n"

LOCAL b AS Buch
b.AktuelleSeite = 200
b.GetTitel$()
b.getBuch()
STDOUT "buch Seite: "+b.AktuelleSeite+"\n"
DIM b.Seiten$[100][100]


LOCAL r AS Regal
DIM r.Buecher[100]
r.Buecher[0] = b.getBuch()
r.Buecher[0].Titel$ = "Harry Potter"
STDOUT "Erstes Buch im Regal: "+r.Buecher[0].Titel$+"\n"
DIM r.Buecher[0].Seiten[100]
r.Buecher[0].Seiten[0].Text$ = "lol"
r.Buecher[0].getBesteSeite().Text$ = "ICH MAG ZÜGE"

TYPE Regal:
Buecher[] AS Buch
ENDTYPE

TYPE Buch:
AktuelleSeite
Titel$
Besitzer$
Seiten$[]
Seiten[] AS Seite
BesteSeite AS Seite

FUNCTION GetTitel$: Param = 200, NoParam$ = "lol"
DIM self.Seiten$[40]
RETURN self.Titel$ + "Param: "+Param + " - " + NoParam$
ENDFUNCTION

FUNCTION getBuch AS Buch:
RETURN self
ENDFUNCTION
FUNCTION getBesteSeite AS Seite:
RETURN self.BesteSeite
ENDFUNCTION
ENDTYPE

TYPE Seite:
Alter%
Text$
ENDTYPE

testFunktion$ 10, 20, 30
testFunktion$ 10, 20
andereTestFunktion 40
andereTestFunktion 80
GOSUB mySub //GOSUB optional
defaultTest

FUNCTION testFunktion$: param1 = GetInt(), param2 = l, param3 = "lolo"
STDOUT "Ich bin in einer Funktion \\o/ "+param1+" "+param2+" "+param3+"\n"

RETURN "ROFL"
ENDFUNCTION

FUNCTION defaultTest: param1 = 10, param2 = -1, param3 = 22

ENDFUNCTION

CALLBACK FUNCTION andereTestFunktion: param4
STDOUT "Ich bin da, kein Callback"
ENDFUNCTION

FUNCTION andereTestFunktion: param4
STDOUT "ICH BIN DA CaLLBACk"
ENDFUNCTION

SUB mySub:
STDOUT "I'm in SUB!!! \n"
RETURN
STDOUT "Ich werde nie angezeigt lol! \n"
ENDSUB


FUNCTION GetInt%:
RETURN 42
ENDFUNCTION

GLOBAL l = GetInt() //Rückwärtszugriff


in JS:
Code (glbasic) Select
<html>
<head>
<title>GLBasic</title>
<script type="text/javascript" src="JS/lib.js"></script>
<script type="text/javascript">
//init globals, default value!!
var l = 0.0;
//init globals, with custom value!!
function __initGlobals() {
   l = CAST2FLOAT(GetInt())
}
function main(){
   __initGlobals();
   var i = 0.0, j = CAST2FLOAT(999), k = CAST2FLOAT(GetInt()), arr1 = GLBArray(), arr2 = GLBArray(), b = Buch(), r = Regal();
   i = CAST2FLOAT((204 * (2 + 2)));
   STDOUT((("i: " + CAST2STRING(i)) + "\n"));
   STDOUT((("j: " + CAST2STRING(j)) + "\n"));
   STDOUT((("k: " + CAST2STRING(k)) + "\n"));
   STDOUT((CAST2STRING((4 + (4 * 2))) + ": Zahl! \n"));
   STDOUT((("Hallo Welt " + CAST2STRING(100)) + "\n"));
   DIM(arr1, [10], 0.0);
   REDIM(arr1, [14], 0.0);
   arr1.values[8] = CAST2FLOAT(99);
   STDOUT((("Array 1 an der Stelle 8: " + CAST2STRING(arr1.values[8])) + "\n"));
   STDOUT("1--- \n");
   arr2 = arr1.clone();
   STDOUT("2--- \n");
   arr1 = arr2.clone();
   STDOUT("3--- \n");
   b.AktuelleSeite = CAST2FLOAT(200);
   __method__Buch__GetTitel_Str(CAST2FLOAT(200), "lol", b);
   __method__Buch__getBuch(b);
   STDOUT((("buch Seite: " + CAST2STRING(b.AktuelleSeite)) + "\n"));
   DIM(Seiten_Str, [100, 100], "");
   DIM(Buecher, [100], Buch());
   r.Buecher.values[0] = __method__Buch__getBuch(b).clone();
   r.Buecher.values[0].Titel_Str = "Harry Potter";
   STDOUT((("Erstes Buch im Regal: " + r.Buecher.values[0].Titel_Str) + "\n"));
   DIM(Seiten, [100], Seite());
   r.Buecher.values[0].Seiten.values[0].Text_Str = "lol";
   testFunktion_Str(10, 20, 30);
   testFunktion_Str(10, 20, CAST2FLOAT("lolo"));
   andereTestFunktion(40);
   andereTestFunktion(80);
   mySub();
   defaultTest(CAST2FLOAT(10), CAST2FLOAT((0 - 1)), CAST2FLOAT(22));
   
};
function  __method__Buch__GetTitel_Str(Param, NoParam_Str, self) {
   DIM(Seiten_Str, [40], "");
   return ((((self.Titel_Str + "Param: ") + CAST2STRING(Param)) + " - ") + NoParam_Str);
   
};
function  __method__Buch__getBuch(self) {
   return self;
   
};
function  testFunktion_Str(param1, param2, param3) {
   STDOUT((((((("Ich bin in einer Funktion \\o/ " + CAST2STRING(param1)) + " ") + CAST2STRING(param2)) + " ") + CAST2STRING(param3)) + "\n"));
   return "ROFL";
   
};
function  defaultTest(param1, param2, param3) {
   
};
function  andereTestFunktion(param4) {
   STDOUT("ICH BIN DA CaLLBACk");
   
};
function  mySub() {
   STDOUT("I'm in SUB!!! \n");
   return 0;
   STDOUT("Ich werde nie angezeigt lol! \n");
   
};
function  GetInt() {
   return 42;
   
};
function Regal() {
   this.Buecher = GLBArray();
   this.clone = function() {
      var other = new Object();
      other.Buecher = this.Buecher.clone();
      return other;
   };
   return this;
   
};
function Buch() {
   this.AktuelleSeite = 0.0;
   this.Titel_Str = "";
   this.Besitzer_Str = "";
   this.Seiten_Str = GLBArray();
   this.Seiten = GLBArray();
   this.clone = function() {
      var other = new Object();
      other.AktuelleSeite = this.AktuelleSeite;
      other.Titel_Str = this.Titel_Str;
      other.Besitzer_Str = this.Besitzer_Str;
      other.Seiten_Str = this.Seiten_Str.clone();
      other.Seiten = this.Seiten.clone();
      return other;
   };
   return this;
   
};
function Seite() {
   this.Alter = 0;
   this.Text_Str = "";
   this.clone = function() {
      var other = new Object();
      other.Alter = this.Alter;
      other.Text_Str = this.Text_Str;
      return other;
   };
   return this;
   
};

</script>
</head>
<body onLoad="main();">

<!--<textarea name="GLBContent" style="width:100%;height:100%">
</textarea>-->
</body>
</html>


@Quentin: Grundlegendes Wissen habe ich aus dem Buch: http://www.amazon.de/Grundlagen-Techniken-Compilerbaus-Niklaus-Wirth/dp/3486585819/ref=sr_1_4?ie=UTF8&qid=1313072704&sr=8-4 , alles weitere lernt man nur durch Learning by doing :P

MfG
That's no Bug, that's my project!

http://programming-with-design.at/

Quentin

Ganz erstaunlich!
Ich hatte mich vor etlichen Jahren mal mit den Drachen-Büchern beschäftigt, aber entnervt aufgegeben.

Großes Kompliment!

Kitty Hello

Wow, ist das gut!

metzzo

Heyho!

Die GLBasic Syntax ist fertig implementiert ... naja fast, bis auf Kleinigkeiten (und natürlich bug hunting...)
Also, was habe ich implementiert?
PROTOTYPE, IF - ELSEIF - ELSE - ENDIF, WHILE - WEND, REPEAT - UNTIL, FOR - NEXT, STARDATA - DATA - ENDATA - RESTORE - READ, TRY - CATCH - FINALLY, SELECT - CASE - DEFAULT - ENDSELECT (inkl. die Spompanadeln wie CASE >4; CASE 2 TO 8 Außerdem gehen Mehrfachmöglichkeiten, also CASE 1, 2, 3 und so), Vordefinierte Arraygrößen (habe ich persönlich sehr vermisst, also sowas wie LOCAL array[10][10]), DIM als Expression funktioniert auch also: LOCAL arr[] AS Typblubi= DIM[10][10] AS Typblubi, CONSTANT, diverse Bugs wurden gekillt, und weiß Gott was ich noch vergessen habe. Außerdem habe ich die Variablenverarbeitungsroutine neu geschrieben, weil die alte Version einen mysteriösen Fehler hatte, den ich einfach nicht finden konnte.

Was fehlt noch?
ALIAS, BYREF (Es gibt leider keine Pointer in JavaScript, hier muss ich mir noch etwas überlegen), GOTO (gibt kein GOTO in JavaScript, muss hier auch noch etwas rumexperimentieren) und natürlich die ganzen 2D/3D/4D/Sound/... Funktionen von GLB in HTML5 implementieren.

Codebeispiel gibts im Moment leider keines, weil ich auf meinem Netbook bin...

MfG
That's no Bug, that's my project!

http://programming-with-design.at/