x = x    

y = x
x = y    

if used x
      x = 1
end if
x = x + 1    

x = x    

x = y
y = x    

if used x
  x = 1
end if
x = x + 1    

x = y + 1
y = 3/(x + 1)    

y = 35/(x + 1)
x = y + 1    

Right-hand-side of the assignment contains undefined x, thus directive fails on first pass.

On second (and any subsequent) pass interpreter sees that x is predicted as undefined and fails too

after first pass x is predicted as defined (with default value of 0; here I speculate on FASM behavior)

This example successfully resolves in two passes as follows:

Au contraire, if defined x will fail: x is predicted as defined but it isn't accessible there since it's redefined later by x = x + 1.

x is here forward referenced.

That's strange, you didn't speculate on the fasm's behaviour the same way in the previous example, because it's the same speculative assignment with forward referencing.

x = x; (1)
x = x; (2)    

The problem is, that this example actually does not successfully resolve.

So what? x is not expected to be accessible, because it's value is not used before x is actually defined.

The defined operator can be followed by any expression, usually just by a single symbol name; it checks whether the given expression contains only symbols that are defined in the source and accessible from the current position.

I disagree. There is no definition of x below this directive.

Consider this: Code:

Code:

x = x; (1) 
x = x; (2)    

Yes it does (1.71.06).

C:\>copy con a.asm
if used x
  x = 1
end if
x = x + 1
^Z
        1 file(s) copied.

C:\>fasm a.asm
flat assembler  version 1.71.06  (1126545 kilobytes memory)
error: code cannot be generated.

C:\>    

l_inc wrote:

So what? x is not expected to be accessible, because it's value is not used before x is actually defined.

FASM manual, section 2.2.2 Conditional assembly wrote:

The defined operator can be followed by any expression, usually just by a single symbol name; it checks whether the given expression contains only symbols that are defined in the source and accessible from the current position.

Yes. And IMHO this is a mistake. There is "usage" and there is "definition". This distinction allows to resolve the situation without breaking anything else (as it seems to me). Why should there be "above" and "below"?

No, it does not (1.71.06). :-)

Let's see: x = x (alone) can't be forward reference (there's nothing forward).

Without that x seems to be predicted as unused (since x = x + 1 alone doesn't suffice because it fails)

x = y
y = x    

baldr

Quote:

Let's see: x = x (alone) can't be forward reference (there's nothing forward).

Why not? Right side of the equation is usage/reference and as long as x was not defined before, it's a forward-reference. And the left side is a definition.

A self-reference is the same thing that makes it possible to do recursion in some languages

A function can get different input values, which makes it impossible to define a function by the result of it's execution. On the other hand the result of a specific expression on the right side of a specific equality sign is always same (otherwise the variable on the left side would have an ambiguous value).

Regarding variable definition, I would not compare it to a recursive function definition

I'm also interested, what you think regarding the example with used.

if used x
  x = 1
end if
x = x + 1
db x    

This was merely to illustrate the difference between the self-reference and forward-reference - the latter, by its very name, is referring to something that is defined in later statement.

Whether fasm should allow self-references or not is a topic for a separate discussion.