I'm currently doing this, to make accessing function arguments easier.

Code:

define Arg1 ebp+8 define Arg2 Arg1+4 define Arg3 Arg2+4

But then when it's used in the code, Only Arg1 works. Arg1 is correctly evaluated as ebp+8. However when Arg2 is evaluated in the actual program code, it is evaluated as literally Arg1+4. It doesn't recursively then evaluate Arg1 in order to get the correct interpretation of Arg2, which should be ebp+12. The result when FASM looks at Arg2 is that it sees the literal text Arg1+4 and has no idea what Arg1 is at this point, thinking it should be a label in the code (like if it were defined with "Arg1:"), and this causes it to give the error "undefined symbol 'Arg1'" when compiling. Please fix this bug.

It will work with EQU:

Code:

Arg1 equ ebp+8 Arg2 equ Arg1+4 Arg3 equ Arg2+4

But you might want to add brackets to ensure you get what you want because they are textual equates.

revolution wrote:

But you might want to add brackets to ensure you get what you want because they are textual equates.

For this reason it would be better to not use preprocessor at all for this purpose, just regular labels:

Code:

label Arg1 at ebp+8 label Arg2 at Arg1+4 label Arg3 at Arg2+4

Alternatively, if you needed preprocessor's variables in order to be able to re-define them, they can be used to be just "links" to actual assembly-time symbols:

Code:

struc redefinable value {         local a         label a at value         . equ a } Arg1 redefinable ebp+8 Arg2 redefinable Arg1+4 Arg3 redefinable Arg2+4

PS. With fasmg plain "=" could be used for the same purpose. It was never allowed in fasm 1, though it was not really because of any technical limitation.

Tomasz Grysztar wrote:

Code: label Arg1 at ebp+8 label Arg2 at Arg1+4 label Arg3 at Arg2+4

Pretty sure that won't work. A label is used to define a fixed value, a numerical constant. A function argument is based on ebp, which is a register (its value is only known at runtime, not at compile time), and thus is not a numerical constant. Using a label would work as a numerical constant, while what I need is a string constant, so that when it is compiled it converts that string constant into the literal string I want in the pre-process stage, and then the string I want gets assembled correctly in the assembly stage.

Ben321 wrote:

Pretty sure that won't work. A label is used to define a fixed value, a numerical constant. A function argument is based on ebp, which is a register (its value is only known at runtime, not at compile time), and thus is not a numerical constant. Using a label would work as a numerical constant, while what I need is a string constant, so that when it is compiled it converts that string constant into the literal string I want in the pre-process stage, and then the string I want gets assembled correctly in the assembly stage.

In fasm any label can have a value being a linear polynomial with register terms. When such label is used in an instruction, fasm generates corresponding addressing mode.