format MS COFF
include 'win32a.inc'
extrn '__imp__MessageBoxA@16' as MessageBox:dword

section '.text' code readable executable
public demo
demo:
        invoke  MessageBox, NULL, msg, title, MB_OK
        ret

section '.data' data readable writeable
        title db 'Title', 0
        msg db 'Message', 0
    

extrnFuncMacro MessageBox,4    

Revolution, so you say for each API function that is used, one needs to find out its exported name and list it as extrn.

Then one can might as well shun creating an object file and include all that code in one single file. Just not worth the time.

apidef MessageBoxA, 16
apidef ExitProcess, 4
    

format MS COFF
include 'win32a.inc'

macro apicall func,[params] {
    common
    local .count,.here
        if ~ defined func | defined .here
           .here = 1
           .count equ 0
                match q,params\{irp p,q\\{rept 1 r:.count+4 \\\{.count equ r\\\}\\}\}
         match p,.count \{extrn '__imp__'\#`func\#'A@'\#\`p as func:dword\}
  end if
      invoke  func,params
}

section '.text' code readable executable

public demo
demo:
     apicall Function0
   apicall Function1,1
 apicall Function2,1,2
       apicall Function3,1,2,4
     apicall Function4,1,2,3,4
   ret

section '.data' data readable writeable
        title   db 'Title',0
      msg     db 'Message',0    

dumpbin /exports user32.lib | sed -r -n "s/^ +([_@]([A-Za-z_][A-za-z0-9_]*)(@[0-9]+)?)/if used \2\n  extrn '__imp_\1' as \2:dword\nend if/p"    

if used ActivateKeyboardLayout
  extrn '__imp__ActivateKeyboardLayout@8' as ActivateKeyboardLayout:dword
end if
if used AddClipboardFormatListener
  extrn '__imp__AddClipboardFormatListener@4' as AddClipboardFormatListener:dword
end if
if used AdjustWindowRect
  extrn '__imp__AdjustWindowRect@12' as AdjustWindowRect:dword
end if
if used AdjustWindowRectEx
  extrn '__imp__AdjustWindowRectEx@16' as AdjustWindowRectEx:dword
end if
if used AllowSetForegroundWindow
  extrn '__imp__AllowSetForegroundWindow@4' as AllowSetForegroundWindow:dword
end if
if used AnimateWindow
  extrn '__imp__AnimateWindow@12' as AnimateWindow:dword
end if
...    

macro docall name, [arg]
{
common
   local .count, .xname
        .count = 0
reverse
       .count = .count + 4
 push    arg
common
       .xname equ '__imp__'#`name#'@',.count

       extrn .xname as name:dword
      call    name
}
    

version 1.69.00 (Jun 23, 2009)

[+] Extended the syntax of "rept" directive to allow numerical expressions
to be calculated by preprocessor in its arguments.

f0dder, it would end up as something like this: extrn '__imp__funcname@,.count as funcname:dword

revolution's code needs FASM 1.69 and something like that is required because the number must be in string form and in the assembler layer you can't get that.

(the ".count = .count+4" would be assembly layer I guess, but change "=" to "equ" and assembly layer isn't involved?).

revolution: can you explain to me how your code manages to translate a "number" to a "string" so they can be concatenated? Does the rept iteration-argument get treated magically?

format MS COFF
include 'win32a.inc'

macro apicall func,[params] {
    common
    local .count,.here
  .count equ 0
        match q,params \{                 ;if 'params' is empty then skip this block
                irp p,q \\{                      ;iterate through each parameter
                     rept 1 r:.count+4 \\\{      ;evaluate r=.count+4
                                .count equ r    ;set .count=.count+4
                        \\\}
                \\}
  \}
    if ~ defined func | defined .here       ;only allow one definition of extrn func
            .here = 1
           match p,.count \{         ;transfer value of .count into p
                    extrn '__imp__'\#`func\#'A@'\#\`p as func:dword
         \}
    end if
      invoke  func,params                     ;do the call
}

section '.text' code readable executable

public demo
demo:
    apicall Function0                       ;test zero parameters
       apicall Function1,1                     ;test one parameters
        apicall Function2,1,2                   ;test two parameters
        apicall Function3,1,2,4                 ;test three parameters
      apicall Function4,1,2,3,4               ;test four parameters
       apicall Function4,1,2,3,4               ;test multiple calls
        apicall Function4,1,2,3,4               ;test multiple calls
        ret    

But that only ends up defining .count as '0+4+4+4+4+4' without evaluating the value.

If the value of symbolic constant contains other symbolic constants, they are replaced with their values before assigning this value to the new constant.

Ie, instead of the rept and match trick above, you would either use irp or a forward block to do ".count equ .count + 4" (gathering up the symbolic string above). Then, you'd do...
extrn '__imp__'#func'A@'#§.count as func:dword (assuming § is used for evalute-equate-and-replace). Wouldn't that be a lot nicer syntax and effort-wise?

... are the nesting-slashes necessary inside the match block? Or are you adding them just for good measures?