libraries@import equ kernel32
procs@kernel32@import equ ExitProcess

macro call param
{
  define target@call param
  match library:proc,param
  \{
     match libs,libraries@import
     \\{
         define libraries@import
         match x =library x , <libs>
         \\\{ restore libraries@import \\\}
         match ,libraries@import
         \\\{
              define libraries@import libs,library
              define procs@\#library\#@import proc
         \\\}
     \\}
     match procs,procs@\#library\#@import
     \\{
         match =procs@\#library\#@import,procs@\#library\#@import \\\{ define procs@\#library\#@import proc \\\}
         define procs@\#library\#@import procs,proc
         match x =proc x , <procs>
         \\\{ restore procs@\#library\#@import \\\}
     \\}
     define target@call [library\#.\#proc]
  \}
  call target@call
}

macro imports
{
  data import
   match libs,libraries@import
   \{
      irp name,libs
      \\{
          \\forward
           \\local _label
           dd RVA name\\#.lookup,0,0,RVA _label,RVA name\\#.address
          \\common
           dd 0,0,0,0,0
          \\forward
           _label db \\`name\\#'.dll',0
                  rb RVA $ and 1
      \\}
      irp name,libs
      \\{
          match procs,procs@\\#name\\#@import
          \\\{
               irp proc,procs
               \\\\{
                     \\\\common
                      name\\#.lookup:
                     \\\\forward
                      \\\\local _label
                      dd RVA _label
                     \\\\common
                      dd 0
                      name\\#.address:
                     \\\\forward
                      name\\#.\\\\#proc dd RVA _label
                     \\\\common
                      dd 0
                     \\\\forward
                      _label dw 0
                             db \\\\`proc,0
                             rb RVA $ and 1
               \\\\}
          \\\}
      \\}
   \}
  end data
}

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

format PE GUI
entry start

section '.code' code readable executable

  start:

        stdcall user32:MessageBoxA,0,_message,_caption,0

        stdcall kernel32:ExitProcess,0

section '.data' data readable writeable

  _caption db 'Win32 assembly program',0
  _message db 'Hello World!',0

section '.idata' data readable writeable

  imports    

macro import name,[label,string]
 { common
    name#.lookup:
   forward
    if used label
     if string eqtype ''
      local _label
      dd RVA _label
     else
      dd 80000000h + string
     end if
    end if
   common
    if $ > name#.lookup
     name#.redundant = 0
     dd 0
    else
     name#.redundant = 1
    end if
    name#.address:
   forward
    if used label
     if string eqtype ''
      __import.#label dd RVA _label
     else
      __import.#label dd 80000000h + string
     end if
    end if
   common
    if ~ name#.redundant
     dd 0
    end if
   forward
    if used label & string eqtype ''
    _label dw 0
           db string,0
    label: jmp [__import.#label]
           rb RVA $ and 1
    end if }    

direct-call-to-indirect-jump method

Perhaps the best would be to automatically generate either of them depending on whether the given API is called more than 6 times or not.

; IMPORT_NO_IAT = 0
;
; imp library*,[function*]
; imp.insert

macro imp library*,[function*] {
 common
  match =Import.#library#.Functions,Import.#library#.Functions \{ 
   match a,Import.Libraries \\{ define Import.Libraries a,<library> \\}
   match ,Import.Libraries \\{ define Import.Libraries <library> \\}
   include "%fasminc%\imphinta\"#`library#".inc"
   ;you can comment this line if you want, it's used to include the hints for the calls
  \}
 forward
  match a b c d,function,,, \{
   match e,Import.#library#.Functions \\{
    match =, =, =,,b c d \\\{ define Import.#library#.Functions e,<a>,<`function> \\\}
    match =as =, =, =,,b d \\\{ define Import.#library#.Functions e,<a>,<c> \\\}
   \\}
  \}
}

macro imp.insert { 
 match a,Import.Libraries \{ IMPORT.BUILD.TABLE a \}
 Import.Libraries equ
}

macro IMPORT.BUILD.TABLE [library] {
 common
  local i
  if defined i
   rb 3-(rva $+3) mod 4
   if ~defined IMPORT_NO_IAT
    data 12
     forward
      local u
      if defined u
       label library dword
       label library#.Iat dword
       match a,Import.#library#.Functions \{ IMPORT.FUNCTION.IAT library,a \}
       if $ > library#.Iat
        dd 0
       end if
      end if
     common
    end data
   end if
   data import
    forward
     if defined u
      dd RVA library#.Offset,0,0,RVA library#.Data,RVA library
     end if
    common
     dd 0,0,0,0,0
   end data
  end if
 forward
  local d,e
  if (~defined library#.Offset | defined d)
   if defined IMPORT_NO_IAT & defined u
    label library dword
   end if
   label library#.Offset dword
   match a,Import.#library#.Functions \{ IMPORT.FUNCTION.OFFSET library,a \}
   if $ > library#.Offset
    if ~defined i | defined e
     i = 0
     e = 0
    end if
    u = 0
    dd 0
   end if
   d = 0
  end if
 forward
  if defined u
   library#.Data db `library,0
   rb rva $ mod 2
   match a,Import.#library#.Functions \{ IMPORT.FUNCTION.DATA library,a \}
  end if
}

macro IMPORT.FUNCTION.IAT library*,dummy*,[function*,alias*] {
 forward
  local d
  if used function & (~defined function#.Iat | defined d)
   label function dword
   if alias eqtype ""
    function#.Iat dd RVA function#.Data
   else
    function#.Iat dd 80000000h+alias
   end if
   d = 0
  end if
}

macro IMPORT.FUNCTION.OFFSET library*,dummy*,[function*,alias*] {
 forward
  local d
  if used function & (~defined function#.Offset | defined d)
   if defined IMPORT_NO_IAT
    label function dword
   end if
   if alias eqtype ""
    function#.Offset dd RVA function#.Data
   else
    function#.Offset dd 80000000h+alias
   end if
   d = 0
  end if
}

macro IMPORT.FUNCTION.DATA library*,dummy*,[function*,alias*] {
 forward
  local d
  if used function & alias eqtype "" & (~defined function#.Data | defined d)
   label function#.Data byte
   if defined imphint_#function
    dw imphint_#function
   else
    dw 0
   end if
   db alias,0
   rb rva $ mod 2
   d = 0
  end if
}

Import.Libraries equ    

in file1:
    imp KERNEL32.DLL \
        ,ExitProcess \
        ,GetCurrentThreadId \

    imp USER32.DLL \
        ,AttachThreadInput \
        ,ClientToScreen \
        ,EnumChildWindows \
        ,FindWindowEx as "FindWindowExA" \
        ,GetAsyncKeyState \

in file2:
    imp KERNEL32.DLL \
        ,ExitProcess \ ;Even tho this is defined twice, it will cause no problems
        ,GetModuleFileName as "GetModuleFileNameA" \
        ,GetPrivateProfileInt as "GetPrivateProfileIntA" \
        ,Sleep \
    
in Main file:
    imp.insert
    

;USAGE
;to import items from a dll, use
;
;  import <dllRefName>['('<dllString>')'], <importItemName>[':'<importItemStringOrOrdinal>] [,<importItemName>[':'<importItemStringOrOrdinal>]]*
;
;to declare the import table, use
;
;  .import ;no new section
;
;or
;
;  @import ;new section
;
;or
;
;  @import '('<sectionName>')' ;new section with name
;
;NOTE : '.import' MUST BE USE AFTER ALL 'import'
;
;to reference imported item, use the importItemName, e.g
;
;  format pe gui 4.0
;  import user32('user32.dll'), MessageBox:'MessageBoxA'
;
;  main:
;  push  0 mbTitle mbMessage 0x40
;  call  [MessageBox]
;  ret
;
;  mbMessage db 'Hello World from Fasm', 0
;  mbTitle db 'Test', 0
;
;  .import
;
;lastly, can use 'api' (MUST BE USED BEFORE .import) to import function and call them, e.g
;
;  api u32('user32.dll')::MessageBox('MessageBoxA')
;
;next call to user32.dll function can just use u32
;
; api u32::MessageBoxW
;

macro importListCreate [@listName*] {
  match = @listName#created, @listName#created \{
    define @listName#created
    define @listName
  \}
}

macro importListAdd @listName, [@item] {
common
  ;display `@listName,13,10
  match .item, @item \{
    match , @listName#created \\{
      match , @listName \\\{
        restore @listName
        define @listName .item
        define ..do
      \\\}
      match =..do .prev, ..do @listName \\\{
        restore @listName
        define @listName .prev, .item
      \\\}
      restore ..do
    \\}
  \}
}

macro importListDestroy [@listName*] {match, @listName#created \{restore @listName, @listName#created\}}

importListCreate __dllList
macro importItems @dllRefName, [@itemSpec] {
common
  ;display `@dllRefName, '-'
forward
  ;display `@itemSpec
  match .itemRefName:.itemStr, @itemSpec \{
    match =.itemRefName\#Exist, .itemRefName\#Exist \\{
      define .itemRefName\#Exist
      importListAdd @dllRefName#itemList, .itemRefName, .itemStr
    \\}
    define do
  \}
  match =do .itemRefName, do @itemSpec \{
    match =.itemRefName\#Exist, .itemRefName\#Exist \\{
      define .itemRefName\#Exist
      importListAdd @dllRefName#itemList, .itemRefName, \`.itemRefName
    \\}
  \}
  restore do
  ;display 13,10
}

macro import @dllSpec, [@itemSpec] {
common local dllRefName
  match .dllRefName(.dllStr), @dllSpec \{
    define .dllRefName\#Str .dllStr
    define dllRefName .dllRefName
    define do
  \}
  match =do .dllRefName, do @dllSpec \{
    define .dllRefName\#Str \`.dllRefName
    define dllRefName .dllRefName
  \}
  restore do
  match .dllRefName, dllRefName \{
    match ,.dllRefName\#Exist \\{
      restore .dllRefName\#Str
      importItems .dllRefName, @itemSpec
    \\}
    match =.dllRefName\#Exist,.dllRefName\#Exist \\{
      define .dllRefName\#Exist
      importListAdd __dllList, .dllRefName
      importListCreate .dllRefName\#itemList
      importItems .dllRefName, @itemSpec
    \\}
  \}
  restore dllRefName
}

macro @import @nameSpec {
  match (.name), @nameSpec \{
    section .name data readable
    .import
  \}
  match , @nameSpec \{
    section '.idata' data readable
    .import
  \}
  restore do
}

macro .import {
  match .dllList,__dllList \{buildImportTable .dllList\}
  importListDestroy __dllList
}

macro buildImportTable [@dllRefName] {
common local ..hasImport, ..dllCount
  ..dllCount=0
  align 4
  if ..hasImport
    data import
  end if
forward
      if defined @dllRefName#Used
        dd rva @dllRefName#Oft, 0, 0, rva @dllRefName#Name, rva @dllRefName#Ft
        ..dllCount=..dllCount+1
      end if
common
      if ..dllCount
        dd 5 dup 0
      end if
  if ..hasImport
    end data
  end if
  ..hasImport = ..dllCount
forward
  match .listName, @dllRefName#itemList \{
    match .itemList, .listName \\{buildImportData @dllRefName, .itemList\\}\}
  if defined @dllRefName#Used
    @dllRefName#Name db @dllRefName#Str, 0
  end if
common
  restore @dllRefName#Str, @dllRefName#Exist
  importListDestroy @dllRefName#itemList,  __dllList
}

macro buildImportData @dllRefName, [@itemRefName, @itemStr] {
common local ..itemCount
  ..itemCount=0
  align 4
  @dllRefName#Ft:
forward
  ;display `@itemRefName
  if used @itemRefName
    ;display 'foo'
    if @itemStr eqtype ''
local ..label
      @itemRefName dd rva ..label
    else
      @itemRefName dd 0x80000000 or @itemStr
    end if
    ..itemCount = ..itemCount+1
  end if
common local ..temp
  if $ > @dllRefName#Ft
    @dllRefName#Used=1
    dd 0
    ..itemCount = ..itemCount+1
  end if
  @dllRefName#Oft:
  dd ..itemCount dup 0
  repeat ..itemCount
    load ..temp dword from @dllRefName#Ft+(%-1)*4
    store dword ..temp at @dllRefName#Oft+(%-1)*4
  end repeat
forward
  if used @itemRefName & @itemStr eqtype ''
    ..label dw 0
            db @itemStr, 0
            align 2
  end if
  restore @dllRefName#@itemRefName#Exist
}

macro api @funcSpec, [@arg] {
common
  match .any, @arg \{
reverse
    pushd @arg
common
  \}
  match .dllSpec::.funcSpec, @funcSpec \{
    import .dllSpec, .funcSpec
    match .func:.ignore, .funcSpec \\{
      call [.func]
      define .do
    \\}
    match =.do .func, .do .funcSpec \\{call [.func]\\}
    restore .do
    define do
  \}
  match =do .funcName, do @funcSpec \{call [.funcName]\}
  restore do
}