BlitzBasic Portal Worklogs - OSBasic

Matheparser

DAK — Thu, 05 Nov 2009 03:21:15 +0100

sodale, der matheparser ist jetz endlich auch fertig.

aus
Code: [AUSKLAPPEN]

x=y*(2+v)+1

wird wie gewünscht
Code: [AUSKLAPPEN]

mov ax,0
mov ah,0
mov al,[var_y]
mul bl
mov dx,0
mov bx,1
mov [tmp_matharr+bx],al
mov ah,0
mov bx,1
mov al,[var_tmpmatharr+bx]
mov bl,1
add al,bl
mov bx,2
mov [tmp_matharr+bx],al
mov bx,2
mov al,[tmp_matharr+bx]
mov [var_x],al

ich geb zu, das move ax,0 ist etwas sinnlos, aber zur sicherheit is es nicht böse es drinnen zu haben und ein einzelnes mov einer konstanten in ein register braucht quasi nix an zeit.

als nächstes kommt der syntaxbaum dran und dann endlich die function calls.

zu den function calls noch eines:
ich hätt mir das so gedacht, dass es im grunde 2 arten von calls geben wird.
das erste werden die normalen calls sein, das zweite die makro-calls.
die normalen calls werden so ablaufen, dass die parameter der verkehrten reihenfolge nach auf den stack geschoben werden und dann von der funktion selbst ausgelesen werden (so wies zb auch in c++ und vielen anderen großen programmiersprachen gemacht wird).
die makro-calls rennen so, dass der coder selbst ein fasm-makro schreibt, dass dann von den parametern aus das ganze manuell verarbeitet. das ganze rennt allerdings nur rein-fasm, also nicht mit OSBasiccode sondern hald nur mit inline-fasm. der sinn des ganzen is, dass man so OSBasic um funktionen erweitern kann, auf die man nur mit fasm zugriff hat und/oder rechenzeitkritische programmteile direkt in fasm zu schreiben, um so die performance zu erhöhen.

(falls das ganze unverständlich is, es is 20 nach 3. ich bin komplett hinüber. werds vllt noch mal morgen überarbeiten, den text.)

Tokenizer & Analyser

DAK — Wed, 28 Oct 2009 11:40:56 +0100

sodale... Tokenizer und Analyser sind soweit fertig...

aus
Code: [AUSKLAPPEN]

If test = 1 Then
Print(1+3)
EndIf

wird
Code: [AUSKLAPPEN]

##TOKENIZE##
-----
New Line: if test = 1 then
New Token: if
New Token: (
New Token: test
New Token: =
New Token: 1
New Token: )
New Token: then
-----
New Line: print(1+3)
New Token: print
New Token: (
New Token: 1
New Token: +
New Token: 3
New Token: )
-----
New Line: endif
New Token: endif

und dann
Code: [AUSKLAPPEN]

##ANALYZE##
-----
New Line:
SYNTAX: if
BRACKET: (
VARIABLE: test
OPERATOR: =
NUMBER: 1
BRACKET: )
SYNTAX: then
-----
New Line:
COMMAND: print
BRACKET: (
NUMBER: 1
OPERATOR: +
NUMBER: 3
BRACKET: )
-----
New Line:
SYNTAX: endif

als nächstes kommt der matheparser und der syntaxbaum dran.

danke noch mal an coolo, deine worklogs sind ziemlich ausführlich und verständlich, was das thema angeht.

OSBasic

DAK — Tue, 27 Oct 2009 20:50:42 +0100

Mir war letztens langweilig, also hab ich mir mal FASM angeschaut. Dabei ist mir der Gedanke gekommen, dass es doch 100k Noobs gibt, die in allen möglichen Foren kommen mit "ich möchte ein OS programmieren. Ich kann schon HTML/VisualBasic/BB/..." es aber keine Möglichkeit gibt, was bootbares zu schrieben, ohne irgendein Assembler zu beherrschen.

Deswegen hab ich mich dran gesetzt, und begonnen, eine basicartige Programmiersprache zu schreiben, deren Sinn und Zweck es ist, Billigst-"Betriebssysteme" zu schreiben.

Ich hab fürs Erste einen einfachen Compiler geschrieben, der auf Basis von Left/Mid/... das Input-File in ein FASM-Codefile umwandelt, welches dann mit FASM kompiliert wird.

Der Compiler läuft per Commandline. IDE gibt es noch nicht.

Kompilieren geht ganz einfach: einfach mit cmd in den Programmordner gehen und dort dann eingeben "compiler.exe inputfile.txt outputfile.img", oder einfach die Namen in die make.bat eintragen und diese dann ausführen.

Dieses .img kann dann entweder auf ne Diskette gebrannt werden (CD geht noch nicht, USB-Stick bin ich mir nicht sicher) oder in einer VM geladen werden.

Momentan vorhandene Befehle:
byte variablenname = wert (der Wert kann entweder eine Zahl von 0-255 sein, oder ein String. Für ein Array einfach mehrere Werte getrennt mit Beistrichen eingeben)
word variablenname = wert (das Gleiche wie byte nur mit einem 16Bit-Wert statt einem 8Bit-Wert)
write variable (für variable den variablennamen eines strings angeben)
print variable (das selbe wie write, nur mit einem zeilenumbruch)
setcolor variable/wert (wert = 0-15)
getkey variable (gibt den ASCII-Wert der gedrückten Taste zurück)
waitkey variable (wie getkey, wartet aber auf einen tastendruck)
label labelname (setzt ein label für goto)
goto labelname (springt zu einem label)

asm/endasm (leitet einen inline-asm-block ein oder beendet ihn. dabei ist zu beachten, alle variablen, die mit byte/word gesetzt werden haben den präfix var_ und alle mit label gesetzten labels haben den präfix label_)

als nächstes werde ich den billigcompiler durch einen besseren ersetzten (mit gescheitem lexer und dem ganzen, nach vorbild dessen, was coolo in seinen worklogs schreibt), den asm-part schöner machen, mehr befehle einfügen und, wenn ich mit dem allen fertig bin, iwann vllt eine ide schreiben.

wer testen will, was es jetzt schon gibt: *klick*