macro sz name, [data]{
  common label name
  forward db data
  common .size = $-name
}    

macro sz name, [data]{
  common label name
  forward db data
  common .size = $-name
}    

;(in data section)
sz szStringFooBar, "Foo Bar!",0
;..
;(in the code section)
mov esi, szStringFooBar
mov ecx, szStringFooBar.size
;---------------------------------------------------
;This would give the same ouput as writing:
szStringFooBar db "Foo Bar!",0
;...
mov esi, szStringFooBar
mov ecx, 9 ; the size of the string is 9
;---------------------------------------------------
;one could also write:
;---------------------------------------------------
szStringFooBar db "Foo Bar!",0
 .size = $ - szStringFooBar
;and then make use of:
mov ecx, szStringFooBar.size
    

;Here are a few more valid strings
sz szString, "Hello Dword!",0
sz szString2, "Hello',9,'Dword!",13.10,'there is a tab between Hello and Dword, and this on a new line : )',0
sz szYAS, "YAS means Yet Another String",0
sz szJustSomeValues, 254, 75h,196,35,64h,35h,0
    

org 100h
equate0 = $
equate1 equ $
mov eax, equate0 ; will result in 100h, since the value of $ was 100h at the time it was defined.
org 200h
mov ebx, equate1  ;will be the same as writing "mov ebx, $", since equate1 [b]equ[/b]als $    

MasterLabel:
;...
.sublabel:
; .sublabel can be referenced as .sublabel when you still are under the MasterLabel (if you define another global label)
; if you are under another global label you can still access the local label like this:
SomeOtherMistressLabel:
mov ebx, MasterLabel.sublabel

Please note that declaring for instance a string will create a global label thus:
MasterLabel:
StringThis db 'String',0
.sublabel:
; typing MasterLabel.sublabel will yield an error, because there is no local by the name .sublabel under MasterLabel, but there is one under StringThis (named: StringThis.sublabel), if you put a "." before the StringThis then it'll be local and MasterLabel.sublabe will be legal.
; thus this is how it would look like:
MasterLabel:
.StringThis db 'String',0
.sublabel:
    

It can be used to call indirectly (by the pointer stored in memory) the
procedure using STDCALL convention.
Inside macroinstruction also special operator "#" can be used. This
operator causes two names to be concatenated into one name. It can be useful,
because it's done after the arguments and local names are replaced with their
values. The following macroinstruction will generate the conditional jump
according to the "cond" argument:

macro jif op1,cond,op2,label
{
cmp op1,op2
j#cond label
}

  The "@@" name means anonymous label, you can have defined many of them in
the source. Symbol "@b" (or equivalent "@r") references the nearest preceding
anonymous label, symbol "@f" references the nearest following anonymous label.
These special symbol are case-insensitive.    

2.2.1  Repeating blocks of instructions

"times" directive repeats one instruction specified number of times. It
should be followed by numerical expression specifying number of repeats and
the instruction to repeat (optionally colon can be used to separate number and
instruction). When special symbol "%" is used inside the instruction, it is
equal to the number of current repeat. For example "times 5 db %" will define
five bytes with values 1, 2, 3, 4, 5. Recursive use of "times" directive is
also allowed, so "times 3 times % db %" will define six bytes with values
1, 1, 2, 1, 2, 3.
  "repeat" directive repeats the whole block of instructions. It should be
followed by numerical expression specifying number of repeats. Instructions
to repeat are expected in next lines, ended with the "end repeat" directive,
for example:

    repeat 8
        mov byte [bx],%
        inc bx
    end repeat

The generated code will store byte values from one to eight in the memory
addressed by BX register.
  Number of repeats can be zero, in that case the instructions are not
assembled at all.    

3) The 'forward', 'common', and 'reverse' - why they are required, and are there any other directives for macros? I'm really confused with this directives even though I've gone thru the manual. Pls explain a little.

If after the "macro" directive you enclose some group of arguments' names in
square brackets, it will allow giving more values for this group of arguments
when using that macroinstruction. Any more argument given after the last
argument of such group will begin the new group and will become the first
argument of it. That's why after closing the square bracket no more argument
names can follow. The contents of macroinstruction will be processed for each
such group of arguments separately. The simplest example is to enclose one
argument name in square brackets:

    macro stoschar [char]
     {
        mov al,char
        stosb
     }

This macroinstruction accepts unlimited number of arguments, and each one
will be processed into these two instructions separately. For example
"stoschar 1,2,3" will be assembled as the following instructions:

    mov al,1
    stosb
    mov al,2
    stosb
    mov al,3
    stosb
......
  "forward", "reverse" and "common" directives divide macroinstruction into
blocks, each one processed after the processing of previous is finished. They
differ in behavior only if macroinstruction allows multiple groups of
arguments. Block of instructions that follows "forward" directive is processed
for each group of arguments, from first to last - exactly like the default
block (not preceded by any of these directives). Block that follows "reverse"
directive is processed for each group of argument in reverse order - from last
to first. Block that follows "common" directive is processed only once,
commonly for all groups of arguments. Local name defined in one of the blocks
is available in all the following blocks when processing the same group of
arguments as when it was defined, and when it is defined in common block it is
available in all the following blocks not depending on which group of
arguments is processed.    

macro stoschar [char]
{
   mov al,char
   stosb
}    

macro stoschar [char]
{
forward
   mov al,char
   stosb
}    

macro stoschar [char] {
reverse
   mov al,char
   stosb
}
stoschar 1,2,3
;above would be assembled as:
    mov al,3
    stosb
    mov al,2
    stosb
    mov al,1
    stosb    

    macro stdcall proc,[arg]
     {
      reverse push arg
      common call proc
     }

;can also be written as:
    macro stdcall proc,[arg]  {
      reverse
        push arg
      common
        call proc
     }

stdcall AnyProc, 1,2,3
    

push 3
push 2
push 1
call AnyProc    

Well I'll try to grab that file from board.win32asmcommunity.net.


Just two questions now:

1) why the "..<var-name>" is used?
2) how can I get an interim look of my source file with all macros expanded?

Please help.


In btw, all the best for your competition

symbolic equ $
numerical = $    

db numerical
db numerical    

db symbolic
db symbolic    

db $
db $    

dd symbolic+numerical    

dd $+numerical    

b equ byte
w equ word
d equ dword    

symbolic equ $
symbolic equ symbolic+1    

restore symbolic