IncludeIGlobals
endofcode: 
IncludeUGlobals
end_of_program:
    

For example \{ is treated as single symbol, but during processing of the macroinstruction becomes the } symbol.

For example \{ is treated as single symbol, but during processing of the macroinstruction becomes the { symbol.

;win32wxp.inc
macro allow_nesting
{ macro pushd value
  \{ match ,value \\{
      pushx equ \\}
     match pushx =invoke proc,pushx value \\{
      invoke proc
      push eax
      pushx equ \\}
     match pushx,pushx \\{
      pushd <value>
      pushx equ \\}
     restore pushx \}
...
    

 
match =pushx =invoke proc,pushx value 
    

match =pushx,pushx
    

match =something ...,something ...\{
...
something equ
\}
match =something ...,something ...\{
...
something equ
\}
...
purge something
    

match pushx,pushx    

match any,pushx    

macro ifndef name { match =name, name { }

Some cryptic macro sample just for the fun of it:

Code:

include 'win32ax.inc'

macro AddAPI param { match (name),param \{ macro name [params] \\{ \\common match (args),params \\\{ invoke name,args \\\} match =dd any,params \\\{ name dd any \\\} \\} \} }

.code

  start:

        AddAPI(MessageBox);
        AddAPI(ExitProcess);

        MessageBox(HWND_DESKTOP,"Hi! I'm the example program!","Win32 Assembly",MB_OK);

        ExitProcess(0);

.end start    

This label will be also attached at the beginning of every name starting with dot in the contents of macroinstruction.

If somewhere inside the definition of structure the name consisting of a single dot it found, it is replaced by the name of the label for the given instance of structure and this label will not be defined automatically in such case, allowing to completely customize the definition.

struc foo
{ label .
  .x dd ? }
a foo    

label a
.x dd ? ; wrong explanation     

label a
a.x dd ?    

struc foo { .x dd ? }
a foo    

a: a.x dd ?    

macro idata arg
{
  __IData equ __IData,   ;add one ',' to __IData, initial "__IData" before ','s will be used to call macro
  macro __IDataBlock     ;begin macro (or overload old one) which holds data inside "idata" block
  arg
}

macro udata arg
{
  __UData equ __UData,
  macro __UDataBlock
  arg
}

;include all "idata"-defined blocks
macro IncludeIData
{
  macro __IData dummy,[n]  ;create macro which will be invoked, [n] makes sure macro's forward will
  \{                       ;be preprocessed for each ',' added to __IData
    \forward
       __IDataBlock        ;use the macro with data
       purge __IDataBlock  ;and remove it so previous macro becomes avilable
  \}
  match I, __IData \{ I \} ;and now unroll __IData macro (just "__IData" wouldn't do, replaced equate isn't
                           ;preprocessed anymore and so it wouldn't beheave as macro usage)
  purge __IData            ;__Idata macro is not needed anymore
}


;include all "udata"-defined blocks
macro IncludeUData         ;... same as IncludeIData but it is whole in virtual to count size and define labels
{                          ;and then required space is reserved
  macro __UData dummy,[n]
  \{
    \common
       \local ..begin, ..size
       ..begin = $
       virtual at $
    \forward
       __UDataBlock
       purge __UDataBlock
    \common
       ..size = $ - ..begin
       end virtual
       rb ..size
   \}
  match U, __UData
  \{
    U
  \}
  purge __UData
}    

;This file contains a test version of hllToFunc macro.
;Use(Initialize): 
;hllToFunc MessageBox,ExitProcess
;Test string:
;ExitProcess(<MessageBox(0,"Bear","Good Morning.",0)>)
macro hllToFunc [func]
{
        macro func      [sParam]
        \{
                \common
                define status 0
                match =0 (),status sParam                       ;call with no args
                \\{
                        call [func]
                        define status 1
                \\}
                match =0 (args),status sParam           ;we have string like (arguments).
                \\{
                        macro push_args [arg]                   ;we define push_args macro.
                        \\\{
                                \\\reverse                                      ;change common to reverse.
                                define status2 0
                                match =0 func(),status2 arg     ;no arguments?
                                \\\\{
                                        call [func]
                                        push eax
                                        define status2 1
                                \\\\}
                                match =0 func(args?),status2 arg        ;argument is a return function value?
                                \\\\{
                                        hllToFunc func                  ;slow? recursion.
                                        arg                                             ;function will be execute.
                                        purge func
                                        push eax                                ;push return arg from function.
                                        define status2 1
                                \\\\}
                                match =0,status2                        ;we have simple argument?
                                \\\\{
                                        pushd arg;only in test version!!! in real version it will be push_ex macro.
                                \\\\}
                        \\\}
                        push_args args
                        purge push_args                                 ;kill mecro.
                        call [func]
                        define status 1
                \\}
                match =0 =dd some?,status sParam        ;we inside macro import?
                \\{
                        func sParam                                             ;we do nothing.
                        define status 1
                \\}
                match =0,status
                \\{
                        unknown syntax.
                \\}
        \}
}
    

GetLastError(GetLastError(GetLastError(GetLastError(GetLastError(GetLastError())))))
    

...
.data
  __int32 a,b

.code
EntryPoint:
    a = 5
    cin << b
    a = sqrt(b)
    cout << a
.end EntryPoint