push dword 640 + (480 shl 16)    

include 'p6.inc'
push dword 640 + (480 shl 16)    

flat assembler  version g.hs4p0
test.asm [2]:
        push dword 640 + (480 shl 16)
macro push [1] macro push_instruction [1] macro parse_operand_sequence [18] macro parse_operand_value [31]:
        ns.imm = +op
Processed: @src.imm = ++
Error: invalid expression.    

mov eax, 640 + (480 shl 16)    

push dword 640+(480)shl(16)    

push eax ebx ecx edx    

push (640 + (480 shl 16)) eax ebx ecx edx
push <640 + (480 shl 16)> eax ebx ecx edx    

push dword 640+(480)shl(16)    

In any case, what do you think about my variants? It would be nice to have consistency in how you can do some inline calculations during assembly time. Maybe it is not so hard to implement.

Yeah, but maybe ( and ) is a bit more intuitive. Actually, it was the first thing I've tried when I'd encountered this problem. It was a big surprise for me that push in the default x86 implementation accepts more than one arguments. It could cause some unexpected results, for example, when someone will write something like this: push 1 +3. It will be assembled as 2 pushes without any errors. Maybe it will be more clear when comma will be used as a delimiter, for example, as it is used in the similar situation in the invoke macros. I'm not insisting on it. It's just some thoughts about it.

I'd like to know if any other standard x86 instructions were extended like this one. Are there some notes about it?

#define if while    

proc func uses ebx esi edi,arg1,arg2    

push x * y ;fasm 1 = okay, fasmg = error    

MASM

mov eax, [labelname]
mov eax, [esi]
mov eax, labelname
mov eax, esi    

mov eax, labelname
mov eax, [esi]
mov eax, offset labelname
mov eax, esi    

IIRC it came about because of the MASM proc.

Code:

proc func uses ebx esi edi,arg1,arg2    

So it was easy to just copy the "uses" clause onto the end of a push instruction.

proc WindowProc hwnd,wmsg,wparam,lparam
uses ebx, esi, edi

        mov ebx, 2
        mov esi, 3
        mov edi, 4
        ...
        ret

end proc    

iterate instr, push,pop
        macro instr? op
                local sequence
                sequence equ op --
                while 1
                        match --, sequence
                                break
                        else match car= cdr, sequence
                                redefine sequence cdr
                                match :sz, x86.car
                                        match --, sequence
                                                instr car
                                                break
                                        else match head= tail, sequence
                                                redefine sequence tail
                                                instr car head
                                        end match
                                else
                                        instr car
                                end match
                        end match
                end while
        end macro
end iterate    

Actually, with FASMG you can rewrite almost any part of the standard x86 instructions, so if someone will not like something, it will be possible to change it. So, it is not a big drama when you think that something is wrong and have to be changed. Just change it, with FASMG it is easy

But for my opinion MASM's syntax is a mess of arguments and it is better to introduce a special submacros for the proc which can be used just after the proc definition for automatic preserving of registers (and this proc can be automatically unset outside the proc). For example:

Code:

proc WindowProc hwnd,wmsg,wparam,lparam
uses ebx, esi, edi

        mov ebx, 2
        mov esi, 3
        mov edi, 4
        ...
        ret

end proc    

So, "uses" will change settings of the current proc, it will add "push ebx, esi, edi", and it will pop these registers before ret. It is easy to raise an error when this macros is used not just after the proc definition.

proc WindowProc uses ebx esi edi, hwnd,wmsg,wparam,lparam     

define xpctrgmnt

iterate operator, not,bsf,bsr,string,float,trunc,sizeof,lengthof,elementsof,\
                  byte,word,dword,fword,pword,qword,tbyte,tword,dqword,xword,qqword,yword,dqqword,zword
        define operator?.xpctrgmnt +
end iterate

iterate operator, xor,and,or,shl,shr,bswap,element,scale,metadata,elementof,scaleof,metadataof
        define xpctrgmnt.operator? +
        define operator?.xpctrgmnt +
end iterate

iterate instruction, push,pop
        macro instruction? operand
                local buffer,remaining
                remaining equ operand :
                buffer equ
                while 1
                        match car= cdr, remaining
                                buffer reequ buffer car
                                redefine remaining cdr
                                match any+, :car
                                else match +any, cdr
                                else match any-, :car
                                else match -any, cdr
                                else match any*, :car
                                else match *any, cdr
                                else match any/, :car
                                else match /any, cdr
                                else match any+, :car.xpctrgmnt
                                else match +any, xpctrgmnt.cdr
                                else match any(, :car
                                else match )any, cdr
                                else match collected, buffer
                                        instruction collected
                                        buffer reequ
                                end match
                        else
                                match collected, buffer
                                        instruction collected
                                end match
                                break
                        end match
                end while 
        end macro 
end iterate    

BTW, It is a surprise for me also that FASM1 is able to assemble "push 1 2 3" as three actual pushes without any additional macroses =) I think that it is better to stick to less ambiguous variants, like "one push - one argument" or "comma as a delimiter".