je somelabel
mov eax, ebx ; arbitrary instruction
jmp somelabel


label somelabel:
; here it will do some '=' operations based on the jumps' '=' values..

....    

je somelabel
mov eax, ebx
jmp otherlabel


label somelabel:
; here it will do some '=' operations based on the jumps..

....


; some other code here
label otherlabel:
; do some stuff...

jmp somelabel  ; this also sets info ('=' constants) for the somelabel
               ; but somelabel was processed before, or am I wrong, and my constant
               ; is not accessible from anywhere, since it's defined on each jmp
               ; If I declare a constant more than once, it's not accesible from anywhere
               ; how to do this?    

; initial definitions
A = 0 ; A starts counting from 0

macro jmp target
{ if target eq alpha
   A = A + 1
  end if
  jmp target }

macro .end { TOTAL = A } ; at the end of code we summarize gathered information

; start of code:

jmp alpha ; A = 1 now

label alpha
display '0'+TOTAL ; here we need to know the total count

jmp alpha ; A = 2 now

jmp alpha ; A = 3 now

.end ; end of code, the current value of A is used to define TOTAL    

if ~ defined A
 A = 0
else
 A = A+1    

if defined WndProc
  ; when WndProc defined somewhere, here do some additional tasks
end if    

Defining a macro and providing the initialization of its variables, like "A=0" next to it, is a common technique and I don't know why would you like to do it other (less clean) way. The other solution would to put the initialization block inside the macro in the "match" block and use some additinal symbolic constant to ensure the initialization block will be invoked only the first time macro is used.

The "defined" won't work this way - see 2.2.5. I'd recommend to not use it at all when it may cause any self-dependence. It was introduced, with "used" operator, to be applicable rather to the places like:

Code:

if defined WndProc
  ; when WndProc defined somewhere, here do some additional tasks
end if    

label X at bx+5    

if X = bx+5    

if X eq bx+5    

But I need a initialization (different names via concatenation) for each different label target (if the target has been encountered before, it will get incremented).. yeah, I guess the "match" and symbolic constant will work here.

What's difference between "defined" and "used"?

alpha:    

dd alpha    

PS: ran into another small problem (I know I may be doing something wrong).. If I have

Code:

label X at bx+5    

and I want to do

Code:

if X = bx+5    

or

Code:

if X eq bx+5    

first one gives error, second doesn't work.. any way to do this? thx

Then you can do the initialization for the each possible type just next to the macro defition.

macro jmp target
{
  match +, target#__A \{
   target\#_A = target\#_A + 1
  \}
  match =target#__A, target#__A \{
   define target\#__A +
   target\#_A = 0
  \}
}    

First one detects things like:

Code:

alpha:    

while second one detects things like:

Code:

dd alpha    

Well, actually I never before needed such thing, that's why I never though about it. The comparison operators work only with number, for the obvious reason that "bx+5>bp+0" would be undecidable by assembler.

if ~defined A
  A = 0
else
  A = A+1
end if    

Okay, I'll try some other tricks then

macro if_labels_equal label1,label2
{ local result,l,b1,b2
  result = 1
  virtual at 0
      inc byte [label1]
   l: inc byte [label2]
      if $-l <> l
        result = 0
      else
        repeat l
          load b1 byte from %-1
          load b2 byte from l+%-1
          if b1 <> b2
            result = 0
          end if
        end repeat
      end if
  end virtual
  if result
}

label X at bx+5

if_labels_equal X,bx+5
  display '!'
end if    

Oh, I see, I did misunderstood you, even though you wrote it clearly: "for each different label target".
And actually I have misled you, this

Code:

if ~defined A
  A = 0
else
  A = A+1
end if    

is perfectly correct in this case, and is actually very good example of the correct use of "defined" operator - since the "A" is assembly-time variable, and cannot be forward-referenced, and "defined" checks for you whether it can be referenced from the place where you check. So when you check with "defined" just before it is defined for the first time, it cannot be yet access, and "defined" will always return false.
I'm sorry, I was too fast replying, forget what I wrote above about this fact.

Here's some trick that works:

Code:

macro if_labels_equal label1,label2
{ local result,l,b1,b2
  result = 1
  virtual at 0
      inc byte [label1]
   l: inc byte [label2]
      if $-l <> l
        result = 0
      else
        repeat l
          load b1 byte from %-1
          load b2 byte from l+%-1
          if b1 <> b2
            result = 0
          end if
        end repeat
      end if
  end virtual
  if result
}

label X at bx+5

if_labels_equal X,bx+5
  display '!'
end if    

if ~defined A
  A = 0
end if
A = A+1