XProfan

XProfan X2
WinXP, SP3, Core(TM) i7-3770 @ 3.40GHz

Du musst halt nach ASM auflösen.

So wird z.B. aus einer Variable eine (in dem Fall eher feste) SpeicherAdresse, z.B. eine Adresse im Stack.

Also var a=0
Ich brauche una variabile a, also push 0 und Stackadresse merken im
Kompilierer. Und wenn irgendwo a=22 steht, dann sowas wie (jetzt mal
angenommen 32Bit)

push eax //eax auf stack sichern
push ebx //ebx auf stack sichern
mov eax,AdresseVonAImStack
mov ebx,22
mov [eax],22
pop ebx
pop eax

das kann man naturalmente kürzer, sollte bloß ein Bild werden.

Welche ASM dieser Microkontroller supportati weiß ich nicht.

Ich schätze Schleifen und ifs sind eher Deine Frage.

Also ein if setze ich per xpse nach assembler um sinnbildlich so:

if 10=20
//print
else
//exit
endif

wird zu

push eax
push ebx
mov eax,10
mov ebx,20
cmp eax,ebx
pop eax
pop ebx
jne marke001else
//print
jmp marke001end
marke001else:
//exit
marke001end:
weiterimtext...

das wäre dann ein if.

Schleifen sind auch nur ein if.

while 1<10
//print
wend

ist ja auch nur

marke002loop:
push eax
push ebx
mov eax,1
mov ebx,10
cmp eax,ebx
pop eax
pop ebx
JGE marke002end
//print
jmp marke002loop

Vielleicht hilft es Dir was ich mit xpse erzeuge, einfach mal den asm anschauen.

Danach kannst Du den ASM nach Opcodes auflösen. Schwieriger wird
das nicht als nach ASM aber da musst Du bei den Jumps eben auch
die Sprungweiten beachten die je nach CPU/ OS Grenzen haben.

GDL

Hi,

soweit kapier ich das schonmal.
Mir gehts aber zu allererst mal um das Erkennen und Auswerten der Vorlage.

Extremfall:
If (((a+7)/2)-5)+(14/c) > irgendwas

gibts da irgendeinen algorythmus oder irgendwas um das richtig zu erkennen und dann nach punkt vor strich unter Beachtung der Klammern aufzulösen.

oder stur die Klammern von innen nach aussen abarbeiten?

XProfan X3
Windows7 Xprofan 8,9,10 [...]

Kompilieren Markieren Separieren

Das geht auch gut, schreibe per den Anfang eine Funktion
parseArg(ument) - so wandelt auch xpse "Profan"-Argumente nach ASM:

Beispiel:

a=(10+20)+30

wird zu:

tmp1=10+20 //Klammer vorne+hinten kann immer weggeworfen werden wenn einzige Klammern
a=tmp+30

wird zu

tmp1=10
add tmp1,20
a=tmp
add a,30

ergo finde Klammerauf und nimm alle Zeichen bis zur korrespondierenden
Klammerzu. Einfach Zeichenweise parsen und bei jeder neu geöffneten
Klammer einfach einen Zähler hochzählen und bei einer Klammerzu den Zähler
runtersetzen sodass auch wirklich die korrespondierende Klammer gefunden wird.

So wird aus
((10+20)*(30+40))
dies:
(10+20)*(30+40)

weil die Außenklammern einfach wieder weggeworfen werden können weil
sie korrespondieren.

So brauchst Du einen Klammernauflöser
und mehrere Operatorenauflöser angewandt in der Reihenfolge Punkt, Strich

Das ganze nenne ich gerne falsch Argumenteauflöser.

Nochmal:

a=((10+20)*(30+40))
wird zu dies:
a=(10+20)*(30+40)

weil die Außenklammern einfach wieder weggeworfen werden können weil
sie korrespondieren.

Dann findet der Klammernauflöser wieder eine klammer, ganz vorne die.

Dann liesst er bis zur korrespondierenden Klammer alles ein, findet also 10+20,
merke 10+20 und 10+20 wird ersetzt in tmpX (X ist ein Zahlenwert der einfach hochzählt, also tmp1, tmp2...)

Ergo

a=(10+20)*(30+40)

wird zu

tmp1=10+20
a=tmp1*(30+40)

dann: noch eine Klammer im Argument? Ja, ergo findet der Klammernauflöser
(30+40) und ersetzt es in (diesmal) tmp2 und merkt 30+40

Ergo:

tmp1=10+20
tmp2=30+40
a=tmp1*tmp2

Noch eine Klammer im Argument? Nein, also ab zum Operatorenauflöser per
Punktrechnung.

Ein Malzeichen in a=tmp1*tmp2? Ja, ergo linkes Argument parsen = tmp1, rechtes
Argument tmp2.

Ergo:

tmp1=10+20
tmp2=30+40
tmp3=tmp1
mul tmp3,tmp2
a=tmp3

Noch ein Punktrechnungsoperator? Nein, ergo weiter zum Operatorenauflöser per
Strichrechnung (arbeitet genau wie der Punktrechnungsoperatorenauflöser):

Ein Plus gefunden? Ja, z.B. in tmp1=10+20. Wieder linkes und rechtes Argument
finden, ergibt links 10 und rechts 20.

ergo, aus:
tmp1=10+20

wird

tmp4=10
add tmp4,20
tmp1=tmp4

Nächste Zeile ist tmp2=30+40, wieder ein Strichrechner gefunden, ergo auflösen:

Aus:
tmp2=30+40

wird

tmp5=30
add tmp5,40
tmp2=tmp5

Dann wird nirgends mehr ein Operator gefunden, ergo kommt heraus:

tmp4=10
add tmp4,20
tmp1=tmp4
tmp5=30
add tmp5,40
tmp2=tmp5
tmp3=tmp1
mul tmp3,tmp2
a=tmp3

Das kann leicht nach ASM gebracht werden, beispiels 32bit asm:

local TMP1:DWORD
local TMP2:DWORD
local TMP3:DWORD
local TMP4:DWORD
local TMP5:DWORD
local A:DWORD
mov TMP4,10
add TMP4,20
push TMP4
pop TMP1
mov TMP5,30
add TMP5,40
push TMP5
pop TMP2
push TMP1
pop TMP3
mov EAX,TMP2
mul TMP3
mov TMP3,EAX
push TMP3
pop A

aber das hatten wir ja oben schon.

Ist mist zu erklären, sorry.

XProfan X2
WinXP, SP3, Core(TM) i7-3770 @ 3.40GHz

GDL

Hallöle,

erstmqal vielen Dank per deine Ausarbeitung.
Schön langsam komme ich dahinter was bei RVK Singlepass1 und Singlepass2 bis ..4 ist.

Ist mist zu erklären, sorry

Ich weiß, tu mich auch schwer die richtigen Fragen zu stellen.
Aber ich beiß mich da jetzt durch.

Grüßle
Georg

XProfan X3
Windows7 Xprofan 8,9,10 [...]

17.02.2015 ▲

GDL

Hallöle David,

komme vorwärts. Variablen aus Code herausfiltern geht schon und die Vektortabellen per die verschiedenen Devices unter Berücksichtigung der Interrupts zu erstellen funzt auch schon.
Bin nun an der "Befehlerkennung" und deren Umsetzung in die Arbeitsregister.
Mühsam ernährt sich das Eichhörnchen.

Grüßle
Georg

Windows7 Xprofan 8,9,10 [...]

26.02.2015 ▲

GDL

Hi,

@David: Danke per die Tips am Tele.

Erste lauffähige Codes gibt es schon.

XProfan X3
Windows7 Xprofan 8,9,10 [...]

14.03.2015 ▲