Compiler
Csobolyó János
janchika at uze.net
Mon May 5 23:20:59 CEST 2003
Istvan Retaller <istvan.retaller at evoran.hu> 2003.05.05. 22:20:35 +2h-kor
írta:
> 2003.05.05. 20:48:28, Nagy Endre <gumo at lucifer.kgt.bme.hu> wrote:
>
> >> 1. valtozok definialasa (helyfoglalas etc....)
> >> 2. kifejezes kiertekeles (pl
> >> sin(22*xfugveny(123*cos(12)+12)*b+yfugveny(a)) )
> >
> >Az utobbira jol lehet hasznalni a parser generatorokat (pl. bison, yacc).
> >De nemi gondolkodassal szinte tetszoleges nyelven eleg jol meg lehet
> >fogalmazni egy nyelvtant. (Ennek Pongor Gyorgy volt a mestere, o legalabb
> >14 nyelven irt Pascal forditot. Bamulatosan egyszerunek tunt a dolog az
> >eloadasain...)
> >
>
> Szia, Gumo!
> Es meg mindig egyszeru? (Vigyazz, csapdakerdes :))
> Nekem meg az is bonyolitja az eletet, hogy a rendes szintaxissal,
> parameterezessel erkezo forrast RPN-t alkalmazo kodra kell forditani.
nem kell !!!
sot szerintem nem is szabad
megprobalom leirni en hogyan csinaltam
user_sring = (5+A)(16-(2*3))/F(1)
"A" az egy valtozo amiben mondjuk 8 van
az F az egy fugveny ami mondjuk ezt csinalja f(n)=n*2
elkezdek a string elejerol vegig menni:
elso karakter lehetosegek
" novelek egy szamlalat ha paratlan akkor idezojelen belul vagyunk es ugy
tarolunk
vagyis nem formazunk es nem kezelunk muveletet
( - nyito zarojel eltarolom egy minka teruletre (a sebeseg miatt mindig a
feldolgozo rutin cimet tarolom
) - muvelet tarolas a megadot cimmel
+-/* - szinten muvelet tarolas a megadot muvelet cimevel
0...9 es pont szam ertekeles
a..z A...Z es alsovonal (_) ez egy fugyvenyt vagy valtozot takar (konstans
itt mar nem lehet mert az mar ez elot felkell dolgozni
ha szam jott akkor megnezuk hogy az elso ket bajt az 0x vagy 0X vagy 0b vagy
0B ekkor ugyanis decimalis vagy hexa ertek jott ezt egy masik rutin dolgozza
fel
elkezdjuk vegig olvasni a stringet az elso szamtol es taroljuk egy munka
teruletre (amit ha pc-n csinalod celszeru BCD-be rakni mert az oda tudod adni
a koprocinak egy az egybe es ugy kered viisza ahogy csak akarod)
ha tizedse jegy jon akkor bebilen egy bit ha a masodik jo akkor kilep a szam
feldolgozo rutinbol (itt meg nincs hiba jelzes)
az elso nem a szamrendszer karaktereitol eltero karakter eseten kilep a rutin
vissza az user string feldolgozohoz
ha vegzet a szam akkor elrakjuk a verembe a szam feldolgozo ruin cimet
valamint a szamot lebego pontossan illetve integerkent (mas mas a szam
feldolgozo rutin cime)
amikor elrakunk valamit a verembe akkor nezuk mindig hogy mi volt az elozo
elem
pl ha szam utan jon szam akkor hiba
ha + utan minusz akkor - tarolunk (persze csak egyszer megengedheto)
ha )( akkor hiba
stb...
ha valtozo jtt akkor megkeresuk a token tablaban ha nincs akkor hiba
ha van akkor kiveszuk az erteket es sima szamkent taroljuk
fugvenynel a fugveny cimet taroljuk
igy elmeletileg "binarizalva" van a string
most jon kiertekeles
innentol ket veremunk van egy operator es egy operandus
felveszuk az elso elemet
ha ez szorzas vagy osztas akkor hiba
ha szam az elem akkor lerakjuk a szmot a operandus verembe
ha operator vagy fugveny jot akkor vissza fele felldolgozuk a vermet a kiseb
prioritasu muveletig
majd lerakjuk a mostani operatort
a feldolgozas alatt azt ertem hogy kiveszem az operatort
es aktualis es utolso operandussal elvegzem a muveletet majd az eredmeny az
utolso helyen tarolom a vermbe
bla bla bla
nos azt hiszem ez nagyon kuszalodik igy este fele
ugyhogy vege
itt van inkabb a forras (dos-os)
ha van kerdesed akkor azt ted fel
masm 5.1 es microsoft link-el forditva
borland turbo debugerrel debugolva (dos)
ha nincsenek meg ezek eltom kuldeni
az othoni szamod nem irtad csak azt hogy ott lehet hivni
ugyhogy ez ma kimaradt
du itthon vagyok
06-29-340-149
szia
; kifejezes kiertekelo
; A programot elkovette Jan Chika
.386
numtyp_32 equ 000h
numtyp_64 equ 100h
numtyp_dec equ 010h
numtyp_bin equ 020h
numtyp_hex equ 040h
numtyp_int equ 000h
numtyp_flo equ 001h
numtyp_dec_flo equ numtyp_dec or numtyp_flo
numtyp_dec_int equ numtyp_dec or numtyp_int
error_exprn_syntax equ 4001h ; tok nem ertheto
error_exprn_idezojel equ 4002h ; idezjelek szama paratlan
error_exprn_zarojel equ 4003h ; zarjoelek aranya nem egyenlo
error_exprn_missing_op equ 4004h ; hianyzo operator
error_exprn_token_not_found equ 4005h ; keywords not found
error_exprn_sub_without_left equ 4006h ; fugveny utan nincs zarojel
exprn_muvelet equ 100h
exprn_adat equ 200h
exprn_utasitas equ 400h
exprn_start equ 80h
exprn_end equ 81h
exprn_add equ 1 or exprn_muvelet
exprn_sub equ 2 or exprn_muvelet
exprn_mul equ 3 or exprn_muvelet
exprn_div equ 4 or exprn_muvelet
exprn_open equ 5
exprn_close equ 6
exprn_idezojel equ 7
exprn_fugveny equ 8 or exprn_adat
exprn_const equ 9 or exprn_adat
exprn_var equ 10 or exprn_adat
exprn_user_fugveny equ 11 or exprn_muvelet
max_exprn equ 11
size_ex_add equ 8
size_ex_sub equ 8
size_ex_mul equ 8
size_ex_div equ 8
size_ex_open equ 8
size_ex_close equ 8
size_ex_idezojel equ 8
size_ex_fugveny equ 8
size_ex_const equ 20
size_ex_var equ 20
size_ex_user_fugveny equ 20
break macro
int 3
endm
zarojel_test macro
local zj1,zj2
cmp al,'('
jnz zj1
inc dl
zj1:
cmp al,')'
jnz zj2
dec dl
zj2:
endm
upper macro
local no_lower
cmp al,'a'
jb no_lower
cmp al,'z'
ja no_lower
and al,5fh
no_lower:
endm
stack_number equ 1
stack_operator equ 2
stack_left_bracket equ 3
stack_right_bracket equ 4
stack_end equ 5
precedencia_add equ 4
precedencia_sub equ 4
precedencia_mul equ 5
precedencia_div equ 5
precedencia_fugveny equ 6
precedencia_left equ 2
precedencia_right equ 3
precedencia_lowest equ 4
bogar segment para public 'CODE' use16
assume cs:bogar
assume ds:bogar
user_string label byte
db ' (5+8)*(16-(2*3))/2',0
dd 0
work label byte
dd exprn_start,0,12
db 256 dup (0)
temp db 1024 dup (0)
last_esi dd 0
exprn_operand_ptr dd 0
exprn_operand_puffer dd 1024 dup (0)
exprn_operator_ptr dd 0
exprn_operator_puffer label dword
dw 1,1
dd 1000 dup (0)
stsz_integer_data dq 0
stsz_float_data dq 0
tizesek label dword
dd 1.0
dd 10.0
dd 100.0
dd 1000.0
dd 10000.0
dd 100000.0
dd 1000000.0
dd 10000000.0
dd 100000000.0
dd 1000000000.0
dd 10000000000.0
dd 0,0,0,0,0
exprn_tab label dword
dd 0
dd offset ex_add ; exprn_add 1
dd offset ex_sub ; exprn_sub 2
dd offset ex_mul ; exprn_mul 3
dd offset ex_div ; exprn_div 4
dd offset ex_open ; exprn_open 5
dd offset ex_close ; exprn_close 6
dd offset ex_idezojel ; exprn_idezojel 7
dd offset ex_fugveny ; exprn_fugveny 8
dd offset ex_const ; exprn_const 9
dd offset ex_var ; exprn_var 10
dd offset ex_user ; exprn_user_fugveny 11
token struc
token_lenght dd ?
token_str db 16 dup (?)
token_type dd ?
token_exec dd ?
token_data db 8 dup (?)
token ends
token_def macro tok_str,tok_type,tok_exec,token_data
local tok_l1,tok_l2
dd tok_l2-tok_l1
tok_l1 label byte
db tok_str
tok_l2 label byte
db 16 -($-tok_l1) dup (0)
dd tok_type
dd offset tok_exec
ifnb <token_data>
dq token_data
endif
ifb <token_data>
dq 0
endif
endm
end_token macro
db size token dup (-1)
endm
token_tab label byte
token_def 'PI' , exprn_const , numtyp_dec_flo, 3.14159265
token_def 'KORTE' , exprn_var , numtyp_dec_int, 123456
token_def 'INC2' , exprn_fugveny , fugveny_INC
token_def 'INk' , exprn_fugveny , fugveny_INC
token_def 'XY' , exprn_fugveny , fugveny_INC
token_def 'ABS' , exprn_fugveny , fugveny_INC
token_def 'INC' , exprn_fugveny , fugveny_INC
token_def 'DEC' , exprn_fugveny , fugveny_INC
token_def 'COS' , exprn_fugveny , fugveny_INC
end_token
bcd_szam label tbyte
db 100 dup (0)
db 12h,23h,45h,67h,89h,13h,14h,15h,16h,17h,18h,0
akt_operator dd 0
akt_number dd 0
akt_precedencia dd 0
start:
push cs
push cs
pop es
pop ds
mov esi,offset user_string
call exprn_ert
mov edi,[last_esi]
jc exit
mov esi,offset work+12
call exprn
jmp exit
exprn_ert:
mov edi,offset work
add edi,12 ; exprn_start+size+hossz
mov ebp,edi
xor dx,dx ; dh idezojelek, dl zarojelek
xor cx,cx ; ch muvelet
exprn_format_ci_new_token: ;
mov [last_esi],esi
exprn_format_ci: ;
mov al,[esi]
inc esi
cmp al,0
jz exprn_format_v
cmp al,34
jz ef_idezojel
test dh,1
jnz ef_idezojelben ; idezojelben vagyunk
cmp al,'('
jz ef_open
cmp al,')'
jz ef_close
cmp al,'+'
jz ef_add
cmp al,'-'
jz ef_sub
cmp al,'*'
jz ef_mul
cmp al,'/'
jz ef_div
cmp al,' '
jz ef_space
cmp al,'.'
jz ef_szam
cmp al,'0'
jb ef_no_szam
cmp al,'9'
jna ef_szam
ef_no_szam:
; itt most egy valtozot vagy egy fugvenyt talaltunk
push ecx
push edx
call ef_test_token
pop edx
pop ecx
jnc exprn_format_ci_tarolt
; esi token vege, ebx token eleje , eax hiba kod, edi token formazva
stc
jmp exprn_ert_close
ef_idezojelben:
jmp exprn_format_ci
exprn_format_ci_tarolt:
; itt nezuk meg hogy jo-e a muveleti sorendek valamint van-e operator
; ket konstans vagy valtozo illetve fugveny kozot
mov eax,edi
sub eax,ebp
add eax,4
mov [edi],eax
add edi,4
mov eax,ebp
push esi
mov esi,ebp
sub esi,[esi-4]
cmp dword ptr [esi],exprn_start
jz exprn_first ; itt meg nincs elozo muvelet
mov esi,ebp
mov eax,[esi] ; mostani
test eax,exprn_adat
jnz ef_t_adat
ef_sorrend_ok:
pop esi
mov ebp,edi
jmp exprn_format_ci_new_token
ef_t_adat:
; adat jot
; ez elot muveletnek kell lenie
; vagy egy fugvenynek
ef_t_a_ci:
call get_prev_token
cmp ebx,exprn_start
jz ef_t_a_eleje
cmp ebx,exprn_open
jz ef_t_a_ci ; nyito zarojelet atlepjuk visszafele
test ebx,exprn_muvelet ; muvelet volt ez elot
jnz ef_sorrend_ok
cmp ebx,exprn_fugveny
jz ef_sorrend_ok
mov ebx,[last_esi]
pop esi
mov ebp,edi
mov eax,error_exprn_missing_op ; hianyzo muvelei jel ket adat kozot
stc
jmp exprn_ert_close
ef_t_a_eleje:
jmp ef_sorrend_ok
get_prev_token:
sub esi,[esi-4]
mov ebx,[esi]
ret
exprn_first:
; kaki meg kell nezni hogy nem-e sorzassal vagy osztassal kezd
pop esi
mov ebp,edi
jmp exprn_format_ci_new_token
ef_szam:
push ecx
push edx
dec esi
call string_to_szam
mov ecx,exprn_const
mov [edi],ecx
add edi,4
mov [edi],ebx
add edi,4
mov [edi],eax
add edi,4
mov [edi],edx
add edi,4
pop edx
pop ecx
jmp exprn_format_ci_tarolt
ef_test_token:
push edi
dec esi
mov edi,offset temp
xor ebx,ebx
; stringet keresunk
; string lehet betu, szam, alahuzas amennyiben pont ugy specialis eset van
ef_betu_ci:
mov al,[esi+ebx]
cmp al,'_'
jz ef_betu_tarol
upper
cmp al,'A'
jb ef_betu_nem_betu
cmp al,'Z'
jna ef_betu_tarol
ef_betu_nem_betu:
cmp al,'0'
jb ef_betu_ci_v
cmp al,'9'
ja ef_betu_ci_v
ef_betu_tarol:
mov [edi],al
inc edi
inc ebx
jmp ef_betu_ci
ef_betu_ci_v:
xor al,al
mov [edi],al
pop edi
push esi
add esi,ebx
push esi
push edi
; edi-ben a valtozo vagy fugveny neve
mov edi,offset temp
call find_token
pop edi
jc ef_token_not_found
mov eax,[esi+token.token_type]
mov [edi],eax
add edi,4
cmp eax,exprn_fugveny
jz ef_exprn_fugveny
cmp eax,exprn_const
jz ef_exprn_const
cmp eax,exprn_var
jz ef_exprn_var
; kaki elkezelni ha nem megfelelo jon
; pl user fugveny
ef_exprn_var:
mov [edi],esi ; valtozo leiro blokja blok
add edi,4
jmp ef_token_ok
ef_exprn_const:
mov eax,[esi+token.token_exec] ; constans tipusa
mov [edi],eax
add edi,4
mov eax,dword ptr [esi+token.token_data+0] ; constnas also 32 bit
mov [edi],eax
add edi,4
mov eax,dword ptr [esi+token.token_data+4] ; constans felso 32 bit
mov [edi],eax
add edi,4
jmp ef_token_ok
ef_exprn_fugveny:
mov [edi],esi ; fugveny leiroja
add edi,4
; megkeresni hogy zarojel jon-e utana
pop esi
push esi
mov ecx,esi
ef_exprn_fugveny_zj:
mov al,[esi]
inc esi
cmp al,' '
jz ef_exprn_fugveny_zj
cmp al,'('
jz ef_token_ok
mov edi,offset temp
pop esi
pop ebx
mov eax,error_exprn_sub_without_left
stc
ret
ef_token_not_found:
mov edi,offset temp
pop esi
pop ebx
mov eax,error_exprn_token_not_found
stc
ret
ef_token_ok:
pop esi
pop ebx ; dummy
clc
ret
exprn_format_v:
xor eax,eax
clc
jmp exprn_ert_close
exprn_ert_close:
pushf
push eax
mov eax,exprn_end
mov [edi],eax
mov eax,8
add edi,4
mov [edi],eax
add edi,4
pop eax
popf
ret
string_to_szam:
mov ax,[esi]
cmp ax,'x0'
jz stsz_hex
cmp ax,'X0'
jz stsz_hex
cmp ax,'b0'
jz stsz_bin
cmp ax,'B0'
jz stsz_bin
; decimalis szam
xor ebx,ebx
xor ecx,ecx
stsz_dec_scan_ci:
mov al,[esi+ebx]
cmp al,'.'
jz stsz_dec_decimal
cmp al,'0'
jb stsz_dec_scan_v
cmp al,'9'
ja stsz_dec_scan_v
stsz_dec_scan2:
inc ebx
jmp stsz_dec_scan_ci
stsz_dec_decimal:
inc cl
cmp cl,1
jz stsz_dec_scan2
stsz_dec_scan_v:
; ebx = string hossza
;cmp ebx,max_val_lenght
push edi
mov edi,offset bcd_szam
dec ebx
xor eax,eax
mov dword ptr [edi+0],eax
mov dword ptr [edi+4],eax
mov dword ptr [edi+8],eax
mov ecx,ebx
mov edx,ecx
stsz_ci:
xor ah,ah
stsz_cih:
mov al,[esi+ebx]
cmp al,'.'
jz stsz_decimal_h
sub al,'0'
mov ah,al
dec ebx
js stsz_ci_v
stsz_cil:
mov al,[esi+ebx]
cmp al,'.'
jz stsz_decimal_l
sub al,'0'
shl al,4
or ah,al
dec ebx
js stsz_ci_v
mov [edi],ah
inc edi
jmp stsz_ci
stsz_decimal_h:
sub ecx,ebx
or ecx,8000h
dec ebx
js stsz_ci_v
jmp stsz_cih
stsz_decimal_l:
sub ecx,ebx
or ecx,8000h
dec ebx
js stsz_ci_v
jmp stsz_cil
stsz_ci_v:
mov [edi],ah
pop edi
add esi,edx
inc esi
; edx hossz
; ebx tizedes resz
mov ebx,numtyp_dec_int
fbld tbyte ptr [bcd_szam]
cmp ecx,edx
jz stsz_no_decimal
and ecx,0ffh
shl ecx,2
mov ebx,numtyp_dec_flo
fdiv dword ptr [tizesek+ecx]
fstp qword ptr [stsz_float_data]
mov eax,dword ptr [stsz_float_data+0]
mov edx,dword ptr [stsz_float_data+4]
ret
stsz_no_decimal:
fistp qword ptr [stsz_integer_data]
mov eax,dword ptr [stsz_integer_data+0]
mov edx,dword ptr [stsz_integer_data+4]
cmp edx,0
jz stsz_no_decimal_32
or ebx,numtyp_64
stsz_no_decimal_32:
ret
stsz_hex:
add esi,2
xor ebx,ebx
xor edx,edx
xor ecx,ecx
stsz_hex_ci:
mov al,[esi+ebx]
cmp al,'0'
jb stsz_hex_ci_v
cmp al,'9'
jna stsz_hex_szamjegy
cmp al,'a'
jb stsz_hex_no_lower
cmp al,'f'
ja stsz_hex_ci_v
and al,5fh
stsz_hex_no_lower:
cmp al,'A'
jb stsz_hex_ci_v
cmp al,'F'
ja stsz_hex_ci_v
sub al,'A'-10
stsz_hex_tarol:
rcl al,5
rcl edx,1
rcl ecx,1
rcl al,1
rcl edx,1
rcl ecx,1
rcl al,1
rcl edx,1
rcl ecx,1
rcl al,1
rcl edx,1
rcl ecx,1
inc ebx
jmp stsz_hex_ci
stsz_hex_szamjegy:
sub al,'0'
jmp stsz_hex_tarol
stsz_hex_ci_v:
add esi,ebx
mov eax,edx
mov edx,ecx
mov ebx,numtyp_hex
ret
stsz_bin:
add esi,2
xor ebx,ebx
xor edx,edx
xor ecx,ecx
stsz_bin_ci:
mov al,[esi+ebx]
cmp al,'0'
jz stsz_bin_0
cmp al,'1'
jnz stsz_bin_ci_v
stc
jmp stsz_bin_tarol
stsz_bin_0:
clc
stsz_bin_tarol:
rcl edx,1
rcl ecx,1
inc ebx
jmp stsz_bin_ci
stsz_bin_ci_v:
add esi,ebx
mov eax,edx
mov edx,ecx
mov ebx,numtyp_bin
ret
ef_space:
jmp exprn_format_ci_new_token
ef_idezojel:
inc dh
mov ebx,exprn_idezojel
jmp ef_push_operator
ef_open:
mov ebx,exprn_open
jmp ef_push_operator
ef_close:
mov ebx,exprn_close
jmp ef_push_operator
ef_add:
mov ebx,exprn_add
jmp ef_push_operator
ef_sub:
mov ebx,exprn_sub
jmp ef_push_operator
ef_mul:
mov ebx,exprn_mul
jmp ef_push_operator
ef_div:
mov ebx,exprn_div
jmp ef_push_operator
ef_push_operator:
mov [edi],ebx
add edi,4
jmp exprn_format_ci_tarolt
find_token:
mov esi,offset token_tab
mov edx,ebx
ft_ci:
mov ecx,[esi+token.token_lenght]
cmp ecx,-1
jz ft_ci_v
cmp ecx,edx
jz ft_test_token
ft_next:
add esi,size token
jmp ft_ci
ft_ci_v:
stc
ret
ft_test_token:
xor ebx,ebx
ft_test_ci:
mov al,[edi+ebx]
cmp al,[esi+token.token_str+ebx]
jnz ft_test_no
inc ebx
dec ecx
jnz ft_test_ci
clc
ret
ft_test_no:
jmp ft_next
exprn:
xor ebx,ebx
exprn_ci:
mov ebx,[esi]
break
cmp ebx,exprn_end
jz exprn_v
movzx ebx,bl
cmp ebx,max_exprn
ja exprn_v
shl ebx,2
mov eax,[exprn_tab+ebx]
jmp eax
ret
; kaki semi sem jott
exprn_v:
call unstack_all_operator
mov esi,offset exprn_operand_puffer
break
clc
ret
push_the_number:
inc [exprn_operand_ptr]
mov ebx,[exprn_operand_ptr]
shl ebx,4 ; 16 byte egy bejegyzes
mov [exprn_operand_puffer+ebx+0],eax
mov [exprn_operand_puffer+ebx+4],edx
jmp exprn_ci
push_the_operator:
break
inc [exprn_operator_ptr]
mov ebx,[exprn_operator_ptr]
shl ebx,3 ; 8 byte egy bejegyzes
mov eax,[akt_operator]
mov ecx,[akt_precedencia]
shl ecx,16
or eax,ecx
mov [exprn_operator_puffer+ebx],eax
jmp exprn_ci
ex_const:
mov ebx,[esi+4]
mov eax,[esi+8]
mov edx,[esi+12]
add esi,size_ex_const
jmp push_the_number
ex_var:
ex_idezojel:
ex_user:
;kaki
ex_add:
mov [akt_operator],offset exec_add
mov [akt_precedencia],precedencia_add
add esi,size_ex_add
jmp found_operator_muv
ex_sub:
mov [akt_operator],offset exec_sub
mov [akt_precedencia],precedencia_sub
add esi,size_ex_sub
jmp found_operator_muv
ex_mul:
mov [akt_operator],offset exec_mul
mov [akt_precedencia],precedencia_mul
add esi,size_ex_mul
jmp found_operator_muv
ex_div:
mov [akt_operator],offset exec_div
mov [akt_precedencia],precedencia_div
add esi,size_ex_div
jmp found_operator_muv
ex_fugveny:
mov [akt_operator],offset exec_fugveny
mov [akt_precedencia],precedencia_fugveny
add esi,size_ex_fugveny
jmp push_the_operator
ex_open:
mov [akt_operator],offset exec_open
mov [akt_precedencia],precedencia_left
add esi,size_ex_open
jmp push_the_operator
ex_close:
mov [akt_operator],offset exec_close
mov [akt_precedencia],precedencia_right
add esi,size_ex_close
call unstack_all_operator
call unstack_left
and edx,0ffffh
cmp edx,offset exec_fugveny
jz found_fugveny
jmp exprn_ci
found_fugveny:
call unstack_operator
jmp exprn_ci
unstack_left:
mov ebx,[exprn_operator_ptr]
shl ebx,3
mov edx,[exprn_operator_puffer+ebx]
and edx,0ffffh
cmp edx,offset exec_open
jnz unstack_left2
cmp [exprn_operator_ptr],0
jz unstack_left2
dec [exprn_operator_ptr]
sub ebx,8
mov edx,[exprn_operator_puffer+ebx]
ret
unstack_left2:
; kaki zarojel hiba
ret
unstack_all_operator:
mov ebx,[exprn_operator_ptr]
shl ebx,3
mov ecx,[exprn_operator_puffer+ebx]
shr ecx,16
cmp ecx,precedencia_lowest
jb unstack_all_operator_v
call unstack_operator
cmp [exprn_operator_ptr],0
jz unstack_all_operator_v
jmp unstack_all_operator
unstack_all_operator_v:
ret
found_operator_muv:
call unstack_ge_operator
jmp push_the_operator
unstack_ge_operator:
mov eax,[akt_precedencia]
mov ebx,[exprn_operator_ptr]
shl ebx,3
mov ecx,[exprn_operator_puffer+ebx]
shr ecx,16
cmp ecx,eax
jb unstack_ge_operator_v
call unstack_operator
cmp [exprn_operator_ptr],0
jz unstack_ge_operator_v
jmp unstack_ge_operator
unstack_ge_operator_v:
ret
exec_open:
exec_close:
jmp exec_x
unstack_operator:
mov ebx,[exprn_operator_ptr]
shl ebx,3
mov edx,[exprn_operator_puffer+ebx]
and edx,0ffffh ; operator
dec [exprn_operator_ptr]
cmp edx,offset exec_fugveny
jz exec_fugveny
mov ebx,[exprn_operand_ptr]
shl ebx,4
mov ecx,[exprn_operand_puffer+ebx] ; operand 2
sub ebx,16
mov eax,[exprn_operand_puffer+ebx] ; operand 1
break
jmp edx
ret
exec_add:
add eax,ecx
jmp exec_x
exec_sub:
sub eax,ecx
jmp exec_x
exec_mul:
mul ecx
jmp exec_x
exec_div:
xor edx,edx
div ecx
jmp exec_x
exec_fugveny:
mov ebx,[exprn_operand_ptr]
shl ebx,4
mov eax,[exprn_operand_puffer+ebx]
inc eax ; kaki ez csak proba fugveny
mov [exprn_operand_puffer+ebx],eax
ret
exec_x:
mov [exprn_operand_puffer+ebx],eax
dec [exprn_operand_ptr]
ret
fugveny_inc:
ret
exit:
mov ax,4c00h
int 21h
bogar ends
end start
-
More information about the Elektro
mailing list