Tak mam rozdelanou verzi, ktera podporuje aspon nekde sjasmplus, ale cim vic toho udelam tim vic vznikne veci co se maji dodelat.
Mam pocit ze jde vsechno taaaaaaaaaaaak strasne pomalu.
A ztracim se v tom.
Co si mysli programator ze pise.
Co si mysli FORTH.
Co si mysli M4.
Co si mysli sjasmplus nebo pasmo.
A vse by to melo ladit.
Staci jenom blbe ABS a premyslim a premyslim...
abs(-1) je 1 nebo 0xFFFF
No je to prece jedna, ale ja nekdy potrebuji 0xFFFF, takze to asi nechci ABS ale & 0xFFFF...?
Ok, takze existuje abs a cislo se znamenkem, ktere interpretuji jako bez znamenka pres masku.
Ted si ohlidat co dela takove UDIV
-50 10 UDIV
Hmmm, je to bez znamenka takze -50 je spatne. Co to znamena, to znamena ze nechci
abs(-50)/abs(10)
ale
(-50 & 0xFFFF)/(10 & 0xFFFF)
To je vec programatora ze zadal 0xFFCE jako -50
sjasmplus tohle asi spolkne.
Koukam co mam v kodu pro sjasmplus...
abs(-50 << 16)/abs(10 << 16)
hmm to by melo fungovat taky.
Ale co UMDIV, kde delenec je dvojslovo (32 bit)
(-50 & 0xFFFFFFFF)/(10 & 0xFFFF)
tady me posuny asi nepomohou.
Vlastne je to asi spatne kdyz sjasmplus je sice 32 bit ale signed. Takze pokud bude znamenkovy bit jedna tak co udela maska? Zase signed?
A co MMUL kde vstup je 2x signed 16bit a vystup signed 32bit
((-50<<16)>>16)*((10<<16)>>16)
Tady me zase nepomuze maska protoze tentokrat potrebuji interpretovat kladne cislo vetsi jako 0x7FFF jako zaporne.
A vysledek neorezavam takze znamenka jsou dulezita.
Ok, takze existuji i nezaporna cisla, ktera chci naopak interpretovat jako jako se znamenkem.
Ted si pridejte pasmo a jak to pocita M4 a mota se me hlava jen v tom co mam delat, natoz jak.
Takze mam tohle rozdelane, ale stejne kdyz zjistim ze jsem v puvodnim kodu po pridani podpory operaci u kterych neznam hodnotu parametru udelal chybu a neosetril, kdy je vstup pointer si hraji s kodem typu.
Ok mam pointer...
To je konec.
Nebo ne? Co kdyz...
Mam...
0*(pointer)
(pointer)*0
0+(pointer)
(pointer)+0
(pointer)-0
(pointer)*1
1*(pointer)
0xFFFF & (pointer)
0xFFFF | (pointer)
0 & (pointer)
0 | (pointer)
(pointer) & 0xFFFF
(pointer) | 0xFFFF
(pointer) & 0
(pointer) | 0
0 / (pointer)
...atd. To je dost veci na hrani.
A co treba
-1*(pointer)
(pointer)*-1
Ze bych fakt pridal token? Lepsi jak nasobit prece! Ok, takze tohle bude PUSH((pointer)) NEGATE
Hele a tohle muzu delat i pro nezname promenne. To vysledny kod nezlepsi, ale ten vzorec bude kratsi. Ok, az na to minus, protoze jsme v podfunkci.
Muj aktualni kod pro sjasmplus (aspon jedna neznama)
Kód:
define({__EVAL_OP_NUM_XXX_SJASMPLUS},{dnl
__{}ifelse(__IS_NUM($2),0,{define({__TEMP_A},{($2)})},{define({__TEMP_A},{eval($2)})}){}dnl
__{}ifelse(__IS_NUM($3),0,{define({__TEMP_B},{($3)})},{define({__TEMP_B},{eval($3)})}){}dnl
ifelse(1,1,{errprint({
$2 $1 $3
}__TEMP_A{ $1 }__TEMP_B{
})}){}dnl
__{}ifelse(dnl
__{}__{}$1:__HEX_HL($2):__IS_NUM(__TEMP_B), {&:0xFFFF:0},{$3},
__{}__{}$1:__HEX_HL($3):__IS_NUM(__TEMP_A), {&:0xFFFF:0},{$2},
__{}__{}$1:__HEX_HL($2),{&:0x0000},{0},
__{}__{}$1:__HEX_HL($3),{&:0x0000},{0},
__{}__{}$1, {&},{__TEMP_A&__TEMP_B},
__{}__{}$1:__HEX_HL($2):__IS_NUM(__TEMP_B), {|:0x0000:0},{$3},
__{}__{}$1:__HEX_HL($3):__IS_NUM(__TEMP_A), {|:0x0000:0},{$2},
__{}__{}$1:__HEX_HL($2),{|:0xFFFF},{0xFFFF},
__{}__{}$1:__HEX_HL($3),{|:0xFFFF},{0xFFFF},
__{}__{}$1, {|},{__TEMP_A|__TEMP_B},
__{}__{}$1, {^},{__TEMP_A^__TEMP_B},
__{}__{}$1:__TEMP_A, {*:0},{0},
__{}__{}$1:__TEMP_B, {*:0},{0},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {*:1:0},{$3},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {*:1:0},{$2},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {*:-1:0},{-($3)},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {*:-1:0},{-($2)},
__{}__{}$1, {*},{((__TEMP_A<<16)>>16)*((__TEMP_B<<16)>>16)},
__{}__{}$1:__TEMP_A, {u*:0},{0},
__{}__{}$1:__TEMP_B, {u*:0},{0},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B),{u*:1:0},{$3},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A),{u*:1:0},{$2},
__{}__{}$1,{u*},{(__TEMP_A&0xFFFF)*(__TEMP_B&0xFFFF)},
__{}__{}$1,{um*},{+(($2)&0xFFFF)*(($3)&0xFFFF)},
__{}__{}$1,{sm*},{+(($2<<16)>>16)*(($3<<16)>>16)},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {/:0:0},{0},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {/:1:0},{$2},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {/:-1:0},{-($2)},
__{}__{}$1, {/},{(__TEMP_A<<16)/(__TEMP_B<<16)},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {u/:0:0},{0},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {u/:1:0},{$2},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {u/:-1:0},{-($2)},
__{}__{}$1,{u/},{(__TEMP_A&0xFFFF)/(__TEMP_B&0xFFFF)},
__{}__{}$1,{um/},{+(($2)&-1)/(($3)&0xFFFF)},
__{}__{}$1,{sm/},{+($2)/(($3<<16)>>16)},
__{}__{}$1, {%},{(__TEMP_A<<16)mod(__TEMP_B<<16)},
__{}__{}$1,{u%},{(__TEMP_A&0xFFFF)/(__TEMP_B&0xFFFF)},
__{}__{}$1,{um%},{+(($2)&-1)%(($3)&0xFFFF)},
__{}__{}$1,{sm%},{+($2)%(($3<<16)>>16)},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {+:0:0},{$3},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {+:0:0},{$2},
__{}__{}$1, {+},{__TEMP_A+__TEMP_B},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {-:0:0},{-($3)},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {-:0:0},{$2},
__{}__{}$1, {-},{__TEMP_A-__TEMP_B},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {u+:0:0},{abs($3)},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {u+:0:0},{abs($2)},
__{}__{}$1,{u+},{(__TEMP_A&0xFFFF)+(__TEMP_B&0xFFFF)},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {u-:0:0},{-abs($3)},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {u-:0:0},{abs($2)},
__{}__{}$1,{u-},{(__TEMP_A&0xFFFF)-(__TEMP_B&0xFFFF)},
__{}{
__{}__{} .error __eval_s16 $1 $2 $3}){}dnl
}){}dnl
Chce to testovat a testovat a .... a jeste doplnit "podlahove deleni"
Ten samy kod pro pasmo
Kód:
dnl # Input:
dnl # operation num_1 xxx
dnl # operation xxx num_2
dnl # Output:
dnl # eval((num1) operation (num2))
define({__EVAL_OP_NUM_XXX_PASMO},{dnl
__{}define({__TEMP_A},{__HEX_HL($2)}){}dnl
__{}define({__TEMP_B},{__HEX_HL($3)}){}dnl
__{}ifelse(substr($1,0,1),{u},,{dnl
__{}__{}ifelse(__HEX_HL($2 & 0x8000),{0x8000},{define({__TEMP_A},eval(__TEMP_A-0x10000))}){}dnl
__{}__{}ifelse(__HEX_HL($3 & 0x8000),{0x8000},{define({__TEMP_B},eval(__TEMP_B-0x10000))}){}dnl
__{}}){}dnl
__{}ifelse(__TEMP_A,{},{define({__TEMP_A},{($2)})},{define({__TEMP_A},{eval($2)})}){}dnl
__{}ifelse(__TEMP_B,{},{define({__TEMP_B},{($3)})},{define({__TEMP_B},{eval($3)})}){}dnl
__{}ifelse(dnl
__{}__{}$1:__HEX_HL($2):__IS_NUM(__TEMP_B), {&:0xFFFF:0},{$3},
__{}__{}$1:__HEX_HL($3):__IS_NUM(__TEMP_A), {&:0xFFFF:0},{$2},
__{}__{}$1:__HEX_HL($2),{&:0x0000},{0},
__{}__{}$1:__HEX_HL($3),{&:0x0000},{0},
__{}__{}$1, {&},{__TEMP_A&__TEMP_B},
__{}__{}$1:__HEX_HL($2):__IS_NUM(__TEMP_B), {|:0x0000:0},{$3},
__{}__{}$1:__HEX_HL($3):__IS_NUM(__TEMP_A), {|:0x0000:0},{$2},
__{}__{}$1:__HEX_HL($2),{|:0xFFFF},{0xFFFF},
__{}__{}$1:__HEX_HL($3),{|:0xFFFF},{0xFFFF},
__{}__{}$1, {|},{__TEMP_A|__TEMP_B},
__{}__{}$1, {^},{__TEMP_A^__TEMP_B},
__{}__{}$1:__TEMP_A, {*:0},{0},
__{}__{}$1:__TEMP_B, {*:0},{0},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {*:1:0},{$3},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {*:1:0},{$2},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {*:-1:0},{-($3)},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {*:-1:0},{-($2)},
__{}__{}$1, {*},{__TEMP_A*__TEMP_B},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {/:0:0},{0},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {/:1:0},{$2},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {/:-1:0},{-($2)},
__{}__{}$1:__SAVE_EVAL($2>=0),{/:1},{+((~($3))>>15)*__ABS($2)/($3)-(($3)>>15)*__ABS($2)/(-($3))},
__{}__{}$1:__SAVE_EVAL($2<0), {/:1},{+(($3)>>15)*__ABS($2)/(-($3))-((~($3))>>15)*__ABS($2)/($3)},
__{}__{}$1:__SAVE_EVAL($3>=0),{/:1},{+((($2)>>15) xor 1)*($2)/__ABS($3)-(($2)>>15)*(-($2))/__ABS($3)},
__{}__{}$1:__SAVE_EVAL($3<0), {/:1},{+(($2)>>15)*(-($2))/__ABS($3)-((~($2))>>15)*($2)/__ABS($3)},
__{}__{}$1, {/},{dnl
__{}__{}__{}+(((($2)|($3))>>15) xor 1)*($2)/($3)dnl
__{}__{}__{}-(((~($2))&($3))>>15)*($2)/(-($3))dnl
__{}__{}__{}-((($2)&(~($3)))>>15)*(-($2))/($3)dnl
__{}__{}__{}+((($2)&($3))>>15)*(-($2))/(-($3))},
__{}__{}$1, {%},{__TEMP_A mod __TEMP_B},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {+:0:0},{$3},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {+:0:0},{$2},
__{}__{}$1, {+},{__TEMP_A+__TEMP_B},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {-:0:0},{-($3)},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {-:0:0},{$2},
__{}__{}$1, {-},{__TEMP_A-__TEMP_B},
__{}__{}$1:__TEMP_A, {u*:0},{0},
__{}__{}$1:__TEMP_B, {u*:0},{0},
__{}__{}$1,{u*},{__TEMP_A*__TEMP_B},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {u/:0:0},{0},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {u/:1:0},{$2},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {u/:-1:0},{-($2)},
__{}__{}$1,{u/},{+($2)/($3)},
__{}__{}$1,{u%},{abs(__TEMP_A) mod __TEMP_B},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {u+:0:0},{abs($3)},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {u+:0:0},{abs($2)},
__{}__{}$1,{u+},{abs(__TEMP_A)+abs(__TEMP_B)},
__{}__{}$1:__TEMP_A:__IS_NUM(__TEMP_B), {u-:0:0},{-abs($3)},
__{}__{}$1:__TEMP_B:__IS_NUM(__TEMP_A), {u-:0:0},{abs($2)},
__{}__{}$1,{u-},{abs(__TEMP_A)-abs(__TEMP_B)},
__{}{
__{}__{} .error __eval_s16 $1 $2 $3}){}dnl
}){}dnl
Zase testovat a testovat... to "podlahove deleni" nevim, to bude strasna silenost...
No a kod pro M4 ktery zna oba parametry, takze vraci misto vzorce cislo
Kód:
dnl # Input: operation num_1 num_2
dnl # Output: eval((num1) operation (num2))
define({__EVAL_OP_NUM_NUM},{dnl
__{}define({__TEMP_A},{__HEX_HL($2)}){}dnl
__{}define({__TEMP_B},{__HEX_HL($3)}){}dnl
__{}ifelse(substr($1,0,1),{u},,{dnl
__{}__{}ifelse(__HEX_HL($2 & 0x8000),{0x8000},{define({__TEMP_A},eval(__TEMP_A-0x10000))}){}dnl
__{}__{}ifelse(__HEX_HL($3 & 0x8000),{0x8000},{define({__TEMP_B},eval(__TEMP_B-0x10000))}){}dnl
__{}}){}dnl
__{}ifelse(dnl
__{}__{}$1, {&}, {define({__TEMP_C},eval(__HEX_HL($2) & __HEX_HL($3)))},
__{}__{}$1, {|}, {define({__TEMP_C},eval(__HEX_HL($2) | __HEX_HL($3)))},
__{}__{}$1, {^}, {define({__TEMP_C},eval(__HEX_HL($2) ^ __HEX_HL($3)))},
__{}__{}$1, {*}, {define({__TEMP_C},eval(__TEMP_A * __TEMP_B))},
__{}__{}$1, {u*}, {define({__TEMP_C},eval(__TEMP_A * __TEMP_B))},
__{}__{}$1, {m*}, {define({__TEMP_C},eval(__TEMP_A * __TEMP_B))},
__{}__{}$1,{um*}, {define({__TEMP_C},eval(__TEMP_A * __TEMP_B))},
__{}__{}$1, {/}, {define({__TEMP_C},eval(__TEMP_A / __TEMP_B))},
__{}__{}$1, {u/}, {define({__TEMP_C},eval(__HEX_HL($2) /__HEX_HL($3)))},
__{}__{}$1,{um/}, {define({__TEMP_C},eval(__HEX_DEHL($2)/__HEX_HL($3)))},
__{}__{}$1,{sm/}, {define({__TEMP_C},eval(($2) / ($3)))},
__{}__{}$1,{fm/}, {define({__TEMP_C},eval(($2) / ($3))){}dnl
__{}__{}__{}__{}__{}__{}define({__REM},eval(($2)%($3))){}dnl
__{}__{}__{}__{}__{}__{}ifelse(__REM,0,{},
__{}__{}__{}__{}__{}__{}eval((__REM ^ ($3)) & 0x8000),{0},{},
__{}__{}__{}__{}__{}__{}{define({__TEMP_C},eval(__TEMP_C-1))})},
__{}__{}$1, {%}, {define({__TEMP_C},eval(__TEMP_A % __TEMP_B))},
__{}__{}$1, {u%}, {define({__TEMP_C},eval(__HEX_HL($2) % __HEX_HL($3)))},
__{}__{}$1,{um%}, {define({__TEMP_C},eval(__HEX_DEHL($2)%__HEX_HL($3)))},
__{}__{}$1,{sm%}, {define({__TEMP_C},eval(($2) % ($3)))},
__{}__{}$1,{fm%}, {define({__TEMP_C},eval(($2) % ($3))){}dnl
__{}__{}__{}__{}__{}__{}ifelse(__TEMP_C,0,{},
__{}__{}__{}__{}__{}__{}eval((__TEMP_C ^ ($3)) & 0x8000),{0},{},
__{}__{}__{}__{}__{}__{}{define({__TEMP_C},eval($3+__TEMP_C))})},
__{}__{}$1, {+}, {define({__TEMP_C},eval(__TEMP_A + __TEMP_B))},
__{}__{}$1, {u+}, {define({__TEMP_C},eval(__HEX_HL($2) + __HEX_HL($3)))},
__{}__{}$1, {-}, {define({__TEMP_C},eval(__TEMP_A - __TEMP_B))},
__{}__{}$1, {u-}, {define({__TEMP_C},eval(__HEX_HL($2) - __HEX_HL($3)))},
__{}{
__{}__{} .error __eval_s16 $1 $2 $3}){}dnl
ifelse(1,1,{errprint({
$0($@)
__TEMP_A:>}__TEMP_A{<
__TEMP_B:>}__TEMP_B{<
__TEMP_C:>}__TEMP_C{<
})}){}dnl
__{}ifelse(dnl
__{}__{}$1,{um*},__HEX_DEHL(__TEMP_C),
__{}__{}$1,{m*},__TEMP_C,
__{}__{}substr($1,0,1),{u},__TEMP_C,
__{}__{}__TO_SIGN(__TEMP_C)){}dnl
}){}dnl
A funkce ktere tohle pouziva
Kód:
define({__EVAL_S16},{dnl
__{}define({__TEMP_A},{__HEX_HL($2)}){}dnl
__{}define({__TEMP_B},{__HEX_HL($3)}){}dnl
__{}ifelse(substr($1,0,1),{u},,{dnl
__{}__{}ifelse(__HEX_HL($2 & 0x8000),{0x8000},{define({__TEMP_A},{eval(__HEX_HL($2)-0x10000)})}){}dnl
__{}__{}ifelse(__HEX_HL($3 & 0x8000),{0x8000},{define({__TEMP_B},{eval(__HEX_HL($3)-0x10000)})}){}dnl
__{}}){}dnl
ifelse(1,1,{errprint({
$0($*)
__TEMP_A:>}__TEMP_A{<
__TEMP_B:>}__TEMP_B{<
})}){}dnl
__{}ifelse(__IS_NUM($2):__IS_NUM($3),{1:1},{dnl
__{}__{}ifelse(dnl
__{}__{}__{}$1, {/mod},{__EVAL_OP_NUM_NUM( %,$2,$3),__EVAL_OP_NUM_NUM( /,$2,$3)},
__{}__{}__{}$1, {u/mod},{__EVAL_OP_NUM_NUM( u%,$2,$3),__EVAL_OP_NUM_NUM( u/,$2,$3)},
__{}__{}__{}$1,{um/mod},{__EVAL_OP_NUM_NUM(um%,$2,$3),__EVAL_OP_NUM_NUM(um/,$2,$3)},
__{}__{}__{}$1,{sm/rem},{__EVAL_OP_NUM_NUM(sm%,$2,$3),__EVAL_OP_NUM_NUM(sm/,$2,$3)},
__{}__{}__{}$1,{fm/mod},{__EVAL_OP_NUM_NUM(fm%,$2,$3),__EVAL_OP_NUM_NUM(fm/,$2,$3)},
__{}__{}__{} {__EVAL_OP_NUM_NUM( $1,$2,$3)}){}dnl
__{}},
__{}__LINKER,{sjasmplus},
__{}{dnl
__{}__{}ifelse(dnl
__{}__{}__{}$1, {/mod},{__EVAL_OP_NUM_XXX_SJASMPLUS( %,$2,$3),__EVAL_OP_NUM_XXX_SJASMPLUS( /,$2,$3)},
__{}__{}__{}$1, {u/mod},{__EVAL_OP_NUM_XXX_SJASMPLUS( u%,$2,$3),__EVAL_OP_NUM_XXX_SJASMPLUS( u/,$2,$3)},
__{}__{}__{}$1,{um/mod},{__EVAL_OP_NUM_XXX_SJASMPLUS(um%,$2,$3),__EVAL_OP_NUM_XXX_SJASMPLUS(um/,$2,$3)},
__{}__{}__{}$1,{sm/rem},{__EVAL_OP_NUM_XXX_SJASMPLUS(sm%,$2,$3),__EVAL_OP_NUM_XXX_SJASMPLUS(sm/,$2,$3)},
__{}__{}__{}$1,{fm/mod},{__EVAL_OP_NUM_XXX_SJASMPLUS(fm%,$2,$3),__EVAL_OP_NUM_XXX_SJASMPLUS(fm/,$2,$3)},
__{}__{}__{} {__EVAL_OP_NUM_XXX_SJASMPLUS( $1,$2,$3)}){}dnl
__{}},
__{}{dnl
__{}__{}ifelse(dnl
__{}__{}__{}$1, {/mod},{__EVAL_OP_NUM_XXX_PASMO( %,$2,$3),__EVAL_OP_NUM_XXX_PASMO( /,$2,$3)},
__{}__{}__{}$1, {u/mod},{__EVAL_OP_NUM_XXX_PASMO( u%,$2,$3),__EVAL_OP_NUM_XXX_PASMO( u/,$2,$3)},
__{}__{}__{}$1,{um/mod},{__EVAL_OP_NUM_XXX_PASMO(um%,$2,$3),__EVAL_OP_NUM_XXX_PASMO(um/,$2,$3)},
__{}__{}__{}$1,{sm/rem},{__EVAL_OP_NUM_XXX_PASMO(sm%,$2,$3),__EVAL_OP_NUM_XXX_PASMO(sm/,$2,$3)},
__{}__{}__{}$1,{fm/mod},{__EVAL_OP_NUM_XXX_PASMO(fm%,$2,$3),__EVAL_OP_NUM_XXX_PASMO(fm/,$2,$3)},
__{}__{}__{} {__EVAL_OP_NUM_XXX_PASMO( $1,$2,$3)}){}dnl
__{}}){}dnl
}){}dnl
A to zase pouziva case pri vkladani tokenu.