;****************************************************************************
;*
;*  ========================================================================
;*
;*    The contents of this file are subject to the SciTech MGL Public
;*    License Version 1.0 (the "License"); you may not use this file
;*    except in compliance with the License. You may obtain a copy of
;*    the License at http://www.scitechsoft.com/mgl-license.txt
;*
;*    Software distributed under the License is distributed on an
;*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
;*    implied. See the License for the specific language governing
;*    rights and limitations under the License.
;*
;*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
;*
;*    The Initial Developer of the Original Code is SciTech Software, Inc.
;*    All Rights Reserved.
;*
;*  ========================================================================
;*
;* Language:    NetWide Assembler (NASM) or Turbo Assembler (TASM)
;* Environment: Any Intel Environment
;*
;* Description: Macros to provide memory model independant assembly language
;*              module for C programming. Supports the large and flat memory
;*              models.
;*
;*              The defines that you should use when assembling modules that
;*              use this macro package are:
;*
;*                  __LARGE__   Assemble for 16-bit large model
;*                  __FLAT__    Assemble for 32-bit FLAT memory model
;*                  __NOU__     No underscore for all external C labels
;*                  __NOU_VAR__ No underscore for global variables only
;*
;*              The default settings are for 16-bit large memory model with
;*              leading underscores for symbol names.
;*
;*              The main intent of the macro file is to enable programmers
;*              to write _one_ set of source that can be assembled to run
;*              in either 16 bit real and protected modes or 32 bit
;*              protected mode without the need to riddle the code with
;*              'if flatmodel' style conditional assembly (it is still there
;*              but nicely hidden by a macro layer that enhances the
;*              readability and understandability of the resulting code).
;*
;****************************************************************************

; Include the appropriate version in here depending on the assembler. NASM
; appears to always try and parse code, even if it is in a non-compiling
; block of a ifdef expression, and hence crashes if we include the TASM
; macro package in the same header file. Hence we split the macros up into
; two separate header files.

ifdef __NASM_MAJOR__

;============================================================================
; Macro package when compiling with NASM.
;============================================================================

; Turn off underscores for globals if disabled for all externals

%ifdef  __NOU__
%define __NOU_VAR__
%endif

; Define the __WINDOWS__ symbol if we are compiling for any Windows
; environment

%ifdef  __WINDOWS16__
%define __WINDOWS__         1
%endif
%ifdef  __WINDOWS32__
%define __WINDOWS__         1
%define __WINDOWS32_386__   1
%endif

; Macros for accessing 'generic' registers

%ifdef  __FLAT__
%idefine _ax    eax
%idefine _bx    ebx
%idefine _cx    ecx
%idefine _dx    edx
%idefine _si    esi
%idefine _di    edi
%idefine _bp    ebp
%idefine _sp    esp
%idefine _es
%idefine UCHAR  BYTE        ; Size of a character
%idefine USHORT WORD        ; Size of a short
%idefine UINT   DWORD       ; Size of an integer
%idefine ULONG  DWORD       ; Size of a long
%idefine BOOL   DWORD       ; Size of a boolean
%idefine DPTR   DWORD       ; Size of a data pointer
%idefine FDPTR  FWORD       ; Size of a far data pointer
%idefine NDPTR  DWORD       ; Size of a near data pointer
%idefine CPTR   DWORD       ; Size of a code pointer
%idefine FCPTR  FWORD       ; Size of a far code pointer
%idefine NCPTR  DWORD       ; Size of a near code pointer
%idefine FPTR   NEAR        ; Distance for function pointers
%idefine DUINT  dd          ; Declare a integer variable
%idefine intsize 4
%idefine flatmodel 1
%else
%idefine _ax    ax
%idefine _bx    bx
%idefine _cx    cx
%idefine _dx    dx
%idefine _si    si
%idefine _di    di
%idefine _bp    bp
%idefine _sp    sp
%idefine _es    es:
%idefine UCHAR  BYTE        ; Size of a character
%idefine USHORT WORD        ; Size of a short
%idefine UINT   WORD        ; Size of an integer
%idefine ULONG  DWORD       ; Size of a long
%idefine BOOL   WORD        ; Size of a boolean
%idefine DPTR   DWORD       ; Size of a data pointer
%idefine FDPTR  DWORD       ; Size of a far data pointer
%idefine NDPTR  WORD        ; Size of a near data pointer
%idefine CPTR   DWORD       ; Size of a code pointer
%idefine FCPTR  DWORD       ; Size of a far code pointer
%idefine NCPTR  WORD        ; Size of a near code pointer
%idefine FPTR   FAR         ; Distance for function pointers
%idefine DUINT  dw          ; Declare a integer variable
%idefine intsize 2
%endif
%idefine invert ~
%idefine offset
%idefine use_nasm

; Convert all jumps to near jumps, since NASM does not so this automatically

%idefine jo     jo near
%idefine jno    jno near
%idefine jz     jz near
%idefine jnz    jnz near
%idefine je     je near
%idefine jne    jne near
%idefine jb     jb  near
%idefine jbe    jbe near
%idefine ja     ja  near
%idefine jae    jae near
%idefine jl     jl  near
%idefine jle    jle near
%idefine jg     jg  near
%idefine jge    jge near
%idefine jc     jc  near
%idefine jnc    jnc near
%idefine js     js  near
%idefine jns    jns near

%ifdef  DOUBLE
%idefine    REAL    QWORD
%idefine    DREAL   dq
%else
%idefine    REAL    DWORD
%idefine    DREAL   dd
%endif

; Boolean truth values (same as those in debug.h)

%idefine False      0
%idefine True       1
%idefine No         0
%idefine Yes        1
%idefine Yes        1

; Macro to be invoked at the start of all modules to set up segments for
; later use. Does nothing for NASM.

%imacro header 1
%endmacro

; Macro to begin a data segment

%imacro begdataseg 1
%ifdef __GNUC__
segment .data public class=DATA use32 flat
%else
%ifdef flatmodel
segment _DATA public align=4 class=DATA use32 flat
%else
segment _DATA public align=4 class=DATA use16
%endif
%endif
%endmacro

; Macro to end a data segment

%imacro enddataseg 1
%endmacro

; Macro to begin a code segment

%imacro begcodeseg 1
%ifdef __PIC__
%ifdef __LINUX__
        extern _GLOBAL_OFFSET_TABLE_
%else
        extern __GLOBAL_OFFSET_TABLE_
%endif
%endif
%ifdef __GNUC__
segment .text public class=CODE use32 flat
%else
%ifdef flatmodel
segment _TEXT public align=16 class=CODE use32 flat
%else
segment %1_TEXT public align=16 class=CODE use16
%endif
%endif
%endmacro

; Macro to begin a near code segment

%imacro begcodeseg_near 0
%ifdef __GNUC__
segment .text public class=CODE use32 flat
%else
%ifdef flatmodel
segment _TEXT public align=16 class=CODE use32 flat
%else
segment _TEXT public align=16 class=CODE use16
%endif
%endif
%endmacro

; Macro to end a code segment

%imacro endcodeseg 1
%endmacro

; Macro to end a near code segment

%imacro endcodeseg_near 0
%endmacro

; Macro for an extern C symbol. If the C compiler requires leading
; underscores, then the underscores are added to the symbol names, otherwise
; they are left off. The symbol name is referenced in the assembler code
; using the non-underscored symbol name.

%imacro cextern 2
%ifdef  __NOU_VAR__
extern %1
%else
extern _%1
%define %1 _%1
%endif
%endmacro

%imacro cexternfunc 2
%ifdef  __NOU__
extern %1
%else
extern _%1
%define %1 _%1
%endif
%endmacro

; Macro for a public C symbol. If the C compiler requires leading
; underscores, then the underscores are added to the symbol names, otherwise
; they are left off. The symbol name is referenced in the assembler code
; using the non-underscored symbol name.

%imacro cpublic 1
%ifdef  __NOU_VAR__
global %1
%1:
%else
global _%1
_%1:
%define %1 _%1
%endif
%endmacro

; Macro for an global C symbol. If the C compiler requires leading
; underscores, then the underscores are added to the symbol names, otherwise
; they are left off. The symbol name is referenced in the assembler code
; using the non-underscored symbol name.

%imacro cglobal 1
%ifdef  __NOU_VAR__
global %1
%else
global _%1
%define %1 _%1
%endif
%endmacro

; Macro for an global C function symbol. If the C compiler requires leading
; underscores, then the underscores are added to the symbol names, otherwise
; they are left off. The symbol name is referenced in the assembler code
; using the non-underscored symbol name.

%imacro cglobalfunc 1
%ifdef __PIC__
global %1:function
%else
%ifdef  __NOU__
global %1
%else
global _%1
%define %1 _%1
%endif
%endif
%endmacro

; Macro to start a C callable function. This will be a far function for
; 16-bit code, and a near function for 32-bit code.

%imacro cprocstatic 1
%push cproc
%1:
%ifdef flatmodel
%stacksize flat
%define ret retn
%else
%stacksize large
%define ret retf
%endif
%assign %$localsize 0
%endmacro

%imacro cprocstart 1
%push cproc
    cglobalfunc %1
%1:
%ifdef flatmodel
%stacksize flat
%define ret retn
%else
%stacksize large
%define ret retf
%endif
%assign %$localsize 0
%endmacro

; This macro sets up a procedure to be exported from a 16 bit DLL. Since the
; calling conventions are always _far _pascal for 16 bit DLL's, we actually
; rename this routine with an extra underscore with 'C' calling conventions
; and a small DLL stub will be provided by the high level code to call the
; assembler routine.

%imacro cprocstartdll16 1
%ifdef  __WINDOWS16__
cprocstart  _%1
%else
cprocstart  %1
%endif
%endmacro

; Macro to start a C callable near function.

%imacro cprocnear 1
%push cproc
    cglobalfunc %1
%1:
%define ret retn
%ifdef flatmodel
%stacksize flat
%else
%stacksize small
%endif
%assign %$localsize 0
%endmacro

; Macro to start a C callable far function.

%imacro cprocfar 1
%push cproc
    cglobalfunc %1
%1:
%define ret retf
%ifdef flatmodel
%stacksize flat
%else
%stacksize large
%endif
%assign %$localsize 0
%endmacro

; Macro to end a C function

%imacro cprocend 0
%pop
%endmacro

; Macros for entering and exiting C callable functions. Note that we must
; always save and restore the SI and DI registers for C functions, and for
; 32 bit C functions we also need to save and restore EBX and clear the
; direction flag.

%imacro enter_c 0
        push    _bp
        mov     _bp,_sp
%ifnidn %$localsize,0
        sub     _sp,%$localsize
%endif
%ifdef  flatmodel
        push    ebx
%endif
        push    _si
        push    _di
%endmacro

%imacro leave_c 0
        pop     _di
        pop     _si
%ifdef  flatmodel
        pop     ebx
        cld
%endif
%ifnidn %$localsize,0
        mov     _sp,_bp
%endif
        pop     _bp
%endmacro

%imacro   use_ebx 0
%ifdef flatmodel
        push    ebx
%endif
%endmacro

%imacro   unuse_ebx 0
%ifdef flatmodel
        pop     ebx
%endif
%endmacro

; Macros for saving and restoring the value of DS,ES,FS,GS when it is to
; be used in assembly routines. This evaluates to nothing in the flat memory
; model, but is saves and restores DS in the large memory model.

%imacro use_ds 0
%ifndef flatmodel
        push    ds
%endif
%endmacro

%imacro unuse_ds 0
%ifndef flatmodel
        pop     ds
%endif
%endmacro

%imacro use_es 0
%ifndef flatmodel
        push    es
%endif
%endmacro

%imacro unuse_es 0
%ifndef flatmodel
        pop     es
%endif
%endmacro

; Macros for loading the address of a data pointer into a segment and
; index register pair. The %imacro explicitly loads DS or ES in the 16 bit
; memory model, or it simply loads the offset into the register in the flat
; memory model since DS and ES always point to all addressable memory. You
; must use the correct _REG (ie: _BX) %imacros for documentation purposes.

%imacro _lds    2
%ifdef flatmodel
        mov     %1,%2
%else
        lds     %1,%2
%endif
%endmacro

%imacro   _les  2
%ifdef flatmodel
        mov     %1,%2
%else
        les     %1,%2
%endif
%endmacro

; Macros for adding and subtracting a value from registers. Two value are
; provided, one for 16 bit modes and another for 32 bit modes (the extended
; register is used in 32 bit modes).

%imacro   _add  3
%ifdef flatmodel
        add     e%1, %3
%else
        add     %1, %2
%endif
%endmacro

%imacro _sub    3
%ifdef flatmodel
        sub     e%1, %3
%else
        sub     %1, %2
%endif
%endmacro

; Macro to clear the high order word for the 32 bit extended registers.
; This is used to convert an unsigned 16 bit value to an unsigned 32 bit
; value, and will evaluate to nothing in 16 bit modes.

%imacro clrhi   1
%ifdef  flatmodel
        movzx   e%1,%1
%endif
%endmacro

%imacro sgnhi   1
%ifdef  flatmodel
        movsx   e%1,%1
%endif
%endmacro

; Macro to load an extended register with an integer value in either mode

%imacro loadint 2
%ifdef flatmodel
        mov     e%1,%2
%else
        xor     e%1,e%1
        mov     %1,%2
%endif
%endmacro

; Macros to load and store integer values with string instructions

%imacro LODSINT 0
%ifdef flatmodel
        lodsd
%else
        lodsw
%endif
%endmacro

%imacro STOSINT 0
%ifdef flatmodel
        stosd
%else
        stosw
%endif
%endmacro

; Macros to provide resb, resw, resd compatibility with NASM

%imacro dclb 1
times %1 db 0
%endmacro

%imacro dclw 1
times %1 dw 0
%endmacro

%imacro dcld 1
times %1 dd 0
%endmacro

; Macro to get the addres of the GOT for Linux/FreeBSD shared
; libraries into the EBX register.

%imacro     get_GOT 1
            call    %%getgot
%%getgot:   pop     %1
            add     %1,_GLOBAL_OFFSET_TABLE_+$$-%%getgot wrt ..gotpc
%endmacro

; Macro to get the address of a *local* variable that is global to
; a single module in a manner that will work correctly when compiled
; into a Linux shared library. Note that this will *not* work for
; variables that are defined as global to all modules. For that
; use the LEA_G macro

%macro      LEA_L    2
%ifdef __PIC__
        get_GOT %1
        lea     %1,[%1+%2 wrt ..gotoff]
%else
        lea     %1,[%2]
%endif
%endmacro

; Same macro as above but for global variables public to *all*
; modules.

%macro      LEA_G    2
%ifdef __PIC__
        get_GOT %1
        mov     %1,[%1+%2 wrt ..got]
%else
        lea     %1,[%2]
%endif
%endmacro

; macros to declare assembler function stubs for function structures

%imacro BEGIN_STUBS_DEF 2
begdataseg  _STUBS
%ifdef  __NOU_VAR__
extern %1
%define STUBS_START %1
%else
extern _%1
%define STUBS_START _%1
%endif
enddataseg  _STUBS
begcodeseg  _STUBS
%assign off %2
%endmacro

%imacro   DECLARE_STUB  1
%ifdef __PIC__
        global %1:function
%1:
        get_GOT eax
        mov     eax,[eax+STUBS_START wrt ..got]
        jmp     [eax+off]
%else
%ifdef  __NOU__
        global %1
%1:
%else
        global _%1
_%1:
%endif
        jmp     [DWORD STUBS_START+off]
%endif
%assign off off+4
%endmacro

%imacro   SKIP_STUB  1
%assign off off+4
%endmacro

%imacro DECLARE_STDCALL 2
%ifdef  STDCALL_MANGLE
        global _%1@%2
_%1@%2:
%else
%ifdef STDCALL_USCORE
        global _%1
_%1:
%else
        global %1
%1:
%endif
%endif
        jmp     [DWORD STUBS_START+off]
%assign off off+4
%endmacro

%imacro   END_STUBS_DEF 0
endcodeseg  _STUBS
%endmacro

; macros to declare assembler import stubs for binary loadable drivers

%imacro BEGIN_IMPORTS_DEF   1
BEGIN_STUBS_DEF %1,4
%endmacro

%imacro   DECLARE_IMP   2
DECLARE_STUB    %1
%endmacro

%imacro   SKIP_IMP   2
SKIP_STUB    %1
%endmacro

%imacro   SKIP_IMP2   1
DECLARE_STUB    %1
%endmacro

%imacro   SKIP_IMP3   1
SKIP_STUB    %1
%endmacro

%imacro   END_IMPORTS_DEF 0
END_STUBS_DEF
%endmacro

else    ; __NASM_MAJOR__

;============================================================================
; Macro package when compiling with TASM.
;============================================================================

; Turn off underscores for globals if disabled for all externals

ifdef   __NOU__
__NOU_VAR__         = 1
endif

; Define the __WINDOWS__ symbol if we are compiling for any Windows
; environment

ifdef   __WINDOWS16__
__WINDOWS__         = 1
endif
ifdef   __WINDOWS32__
__WINDOWS__         = 1
__WINDOWS32_386__   = 1
endif
ifdef   __WIN386__
__WINDOWS__         = 1
__WINDOWS32_386__   = 1
endif
ifdef   __VXD__
__WINDOWS__         = 1
__WINDOWS32_386__   = 1
        MASM
        .386
        NO_SEGMENTS = 1
        include vmm.inc         ; IGNORE DEPEND
        include vsegment.inc    ; IGNORE DEPEND
        IDEAL
endif

; Macros for accessing 'generic' registers

ifdef   __FLAT__
        _ax         EQU eax     ; EAX is used for accumulator
        _bx         EQU ebx     ; EBX is used for accumulator
        _cx         EQU ecx     ; ECX is used for looping
        _dx         EQU edx     ; EDX is used for data register
        _si         EQU esi     ; ESI is the source index register
        _di         EQU edi     ; EDI is the destination index register
        _bp         EQU ebp     ; EBP is used for base pointer register
        _sp         EQU esp     ; ESP is used for stack pointer register
        _es         EQU         ; ES and DS are the same in 32 bit PM
        typedef UCHAR BYTE      ; Size of a character
        typedef USHORT WORD     ; Size of a short
        typedef UINT DWORD      ; Size of an integer
        typedef ULONG DWORD     ; Size of a long
        typedef BOOL DWORD      ; Size of a boolean
        typedef DPTR DWORD      ; Size of a data pointer
        typedef FDPTR FWORD     ; Size of a far data pointer
        typedef NDPTR DWORD     ; Size of a near data pointer
        typedef CPTR DWORD      ; Size of a code pointer
        typedef FCPTR FWORD     ; Size of a far code pointer
        typedef NCPTR DWORD     ; Size of a near code pointer
        typedef DUINT DWORD     ; Declare a integer variable
        FPTR        EQU NEAR    ; Distance for function pointers
        intsize     =   4       ; Size of an integer
        flatmodel   =   1       ; This is a flat memory model
        P386                    ; Turn on 386 code generation
        MODEL       FLAT        ; Set up for 32 bit simplified FLAT model
else
        _ax         EQU ax      ; AX is used for accumulator
        _bx         EQU bx      ; BX is used for accumulator
        _cx         EQU cx      ; CX is used for looping
        _dx         EQU dx      ; DX is used for data register
        _si         EQU si      ; SI is the source index register
        _di         EQU di      ; DI is the destination index register
        _bp         EQU bp      ; BP is used for base pointer register
        _sp         EQU sp      ; SP is used for stack pointer register
        _es         EQU es:     ; ES is used for segment override
        typedef UCHAR BYTE      ; Size of a character
        typedef USHORT WORD     ; Size of a short
        typedef UINT WORD       ; Size of an integer
        typedef ULONG DWORD     ; Size of a long
        typedef BOOL WORD       ; Size of a boolean
        typedef DPTR DWORD      ; Size of a data pointer
        typedef FDPTR DWORD     ; Size of a far data pointer
        typedef NDPTR WORD      ; Size of a near data pointer
        typedef CPTR DWORD      ; Size of a code pointer
        typedef FCPTR DWORD     ; Size of a far code pointer
        typedef NCPTR WORD      ; Size of a near code pointer
        typedef DUINT WORD      ; Declare a integer variable
        FPTR        EQU FAR     ; Distance for function pointers
        intsize     =   2       ; Size of an integer
        P386                    ; Turn on 386 code generation
endif
        invert      EQU not

; Provide a typedef for real floating point numbers

ifdef   DOUBLE
typedef REAL    QWORD
typedef DREAL   QWORD
else
typedef REAL    DWORD
typedef DREAL   DWORD
endif

; Macros to access the floating point stack registers to convert them
; from NASM style to TASM style

st0         EQU     st(0)
st1         EQU     st(1)
st2         EQU     st(2)
st3         EQU     st(3)
st4         EQU     st(4)
st5         EQU     st(5)
st6         EQU     st(6)
st7         EQU     st(7)
st8         EQU     st(8)

; Boolean truth values (same as those in debug.h)

ifndef  __VXD__
False       =       0
True        =       1
No          =       0
Yes         =       1
Yes         =       1
endif

; Macros for the _DATA data segment. This segment contains initialised data.

MACRO   begdataseg name
ifdef   __VXD__
        MASM
VXD_LOCKED_DATA_SEG
        IDEAL
else
ifdef   flatmodel
        DATASEG
else
SEGMENT _DATA DWORD PUBLIC USE16 'DATA'
endif
endif
ENDM

MACRO   enddataseg name
ifdef   __VXD__
        MASM
VXD_LOCKED_DATA_ENDS
        IDEAL
else
ifndef  flatmodel
ENDS    _DATA
endif
endif
ENDM

; Macro for the main code segment.

MACRO   begcodeseg name
ifdef   __VXD__
        MASM
VXD_LOCKED_CODE_SEG
        IDEAL
else
ifdef   flatmodel
        CODESEG
        ASSUME  CS:FLAT,DS:FLAT,SS:FLAT
else
SEGMENT &name&_TEXT PARA PUBLIC USE16 'CODE'
        ASSUME CS:&name&_TEXT,DS:_DATA
endif
endif
ENDM

; Macro for a near code segment

MACRO   begcodeseg_near
ifdef   flatmodel
        CODESEG
        ASSUME  CS:FLAT,DS:FLAT,SS:FLAT
else
SEGMENT _TEXT PARA PUBLIC USE16 'CODE'
        ASSUME CS:_TEXT,DS:_DATA
endif
ENDM

MACRO   endcodeseg name
ifdef   __VXD__
        MASM
VXD_LOCKED_CODE_ENDS
        IDEAL
else
ifndef  flatmodel
ENDS    &name&_TEXT
endif
endif
ENDM

MACRO   endcodeseg_near
ifndef  flatmodel
ENDS    _TEXT
endif
ENDM

; Macro to be invoked at the start of all modules to set up segments for
; later use.

MACRO   header name
begdataseg name
enddataseg name
ENDM

; Macro for an extern C symbol. If the C compiler requires leading
; underscores, then the underscores are added to the symbol names, otherwise
; they are left off. The symbol name is referenced in the assembler code
; using the non-underscored symbol name.

MACRO   cextern name,size
ifdef   __NOU_VAR__
        EXTRN   name:size
else
        EXTRN   _&name&:size
name    EQU     _&name&
endif
ENDM

MACRO   cexternfunc name,size
ifdef   __NOU__
        EXTRN   name:size
else
        EXTRN   _&name&:size
name    EQU     _&name&
endif
ENDM

MACRO   stdexternfunc   name,num_args,size
ifdef   STDCALL_MANGLE
        EXTRN   _&name&@&num_args&:size
name    EQU     _&name&@&num_args
else
        EXTRN   name:size
endif
ENDM

; Macro for a public C symbol. If the C compiler requires leading
; underscores, then the underscores are added to the symbol names, otherwise
; they are left off. The symbol name is referenced in the assembler code
; using the non-underscored symbol name.

MACRO   cpublic name
ifdef   __NOU_VAR__
name:
        PUBLIC  name
else
_&name&:
        PUBLIC  _&name&
name    EQU     _&name&
endif
ENDM

; Macro for an global C symbol. If the C compiler requires leading
; underscores, then the underscores are added to the symbol names, otherwise
; they are left off. The symbol name is referenced in the assembler code
; using the non-underscored symbol name.

MACRO   cglobal name
ifdef   __NOU_VAR__
        PUBLIC  name
else
        PUBLIC  _&name&
name    EQU     _&name&
endif
ENDM

; Macro for an global C function symbol. If the C compiler requires leading
; underscores, then the underscores are added to the symbol names, otherwise
; they are left off. The symbol name is referenced in the assembler code
; using the non-underscored symbol name.

MACRO   cglobalfunc name
ifdef   __NOU__
        PUBLIC  name
else
        PUBLIC  _&name&
name    EQU     _&name&
endif
ENDM

; Macro to start a C callable function. This will be a far function for
; 16-bit code, and a near function for 32-bit code.

MACRO   cprocstatic name        ; Set up model independant private proc
ifdef flatmodel
PROC    name NEAR
else
PROC    name FAR
endif
LocalSize   = 0
ENDM

MACRO   cprocstart name         ; Set up model independant proc
ifdef flatmodel
ifdef   __NOU__
PROC    name NEAR
else
PROC    _&name& NEAR
endif
else
ifdef   __NOU__
PROC    name FAR
else
PROC    _&name& FAR
endif
endif
LocalSize   = 0
        cglobalfunc name
ENDM

MACRO   cprocnear name          ; Set up near proc
ifdef   __NOU__
PROC    name NEAR
else
PROC    _&name& NEAR
endif
LocalSize   = 0
        cglobalfunc name
ENDM

MACRO   cprocfar name           ; Set up far proc
ifdef   __NOU__
PROC    name FAR
else
PROC    _&name& FAR
endif
LocalSize   = 0
        cglobalfunc name
ENDM

MACRO   cprocend               ; End procedure macro
ENDP
ENDM

; This macro sets up a procedure to be exported from a 16 bit DLL. Since the
; calling conventions are always _far _pascal for 16 bit DLL's, we actually
; rename this routine with an extra underscore with 'C' calling conventions
; and a small DLL stub will be provided by the high level code to call the
; assembler routine.

MACRO   cprocstartdll16 name
ifdef   __WINDOWS16__
cprocstart  _&name&
else
cprocstart  name
endif
ENDM

; Macros for entering and exiting C callable functions. Note that we must
; always save and restore the SI and DI registers for C functions, and for
; 32 bit C functions we also need to save and restore EBX and clear the
; direction flag.

MACRO   save_c_regs
ifdef   flatmodel
        push    ebx
endif
        push    _si
        push    _di
ENDM

MACRO   enter_c
        push    _bp
        mov     _bp,_sp
    IFDIFI  <LocalSize>,<0>
        sub     _sp,LocalSize
    ENDIF
        save_c_regs
ENDM

MACRO   restore_c_regs
        pop     _di
        pop     _si
ifdef   flatmodel
        pop     ebx
endif
ENDM

MACRO   leave_c
        restore_c_regs
        cld
    IFDIFI  <LocalSize>,<0>
        mov     _sp,_bp
    ENDIF
        pop     _bp
ENDM

MACRO   use_ebx
ifdef flatmodel
        push    ebx
endif
ENDM

MACRO   unuse_ebx
ifdef flatmodel
        pop     ebx
endif
ENDM

; Macros for saving and restoring the value of DS,ES,FS,GS when it is to
; be used in assembly routines. This evaluates to nothing in the flat memory
; model, but is saves and restores DS in the large memory model.

MACRO   use_ds
ifndef flatmodel
        push    ds
endif
ENDM

MACRO   unuse_ds
ifndef flatmodel
        pop     ds
endif
ENDM

MACRO   use_es
ifndef flatmodel
        push    es
endif
ENDM

MACRO   unuse_es
ifndef flatmodel
        pop     es
endif
ENDM

; Macros for loading the address of a data pointer into a segment and
; index register pair. The macro explicitly loads DS or ES in the 16 bit
; memory model, or it simply loads the offset into the register in the flat
; memory model since DS and ES always point to all addressable memory. You
; must use the correct _REG (ie: _BX) macros for documentation purposes.

MACRO   _lds    reg, addr
ifdef flatmodel
        mov     reg,addr
else
        lds     reg,addr
endif
ENDM

MACRO   _les    reg, addr
ifdef flatmodel
        mov     reg,addr
else
        les     reg,addr
endif
ENDM

; Macros for adding and subtracting a value from registers. Two value are
; provided, one for 16 bit modes and another for 32 bit modes (the extended
; register is used in 32 bit modes).

MACRO   _add    reg, val16, val32
ifdef flatmodel
        add     e&reg&, val32
else
        add     reg, val16
endif
ENDM

MACRO   _sub    reg, val16, val32
ifdef flatmodel
        sub     e&reg&, val32
else
        sub     reg, val16
endif
ENDM

; Macro to clear the high order word for the 32 bit extended registers.
; This is used to convert an unsigned 16 bit value to an unsigned 32 bit
; value, and will evaluate to nothing in 16 bit modes.

MACRO   clrhi   reg
ifdef   flatmodel
        movzx   e&reg&,reg
endif
ENDM

MACRO   sgnhi   reg
ifdef   flatmodel
        movsx   e&reg&,reg
endif
ENDM

; Macro to load an extended register with an integer value in either mode

MACRO   loadint reg,val
ifdef flatmodel
        mov     e&reg&,val
else
        xor     e&reg&,e&reg&
        mov     reg,val
endif
ENDM

; Macros to load and store integer values with string instructions

MACRO   LODSINT
ifdef flatmodel
        lodsd
else
        lodsw
endif
ENDM

MACRO   STOSINT
ifdef flatmodel
        stosd
else
        stosw
endif
ENDM

; Macros to provide resb, resw, resd compatibility with NASM

MACRO   dclb    count
db  count dup (0)
ENDM

MACRO   dclw    count
dw  count dup (0)
ENDM

MACRO   dcld    count
dd  count dup (0)
ENDM

; Macros to provide resb, resw, resd compatibility with NASM

MACRO   resb    count
db  count dup (?)
ENDM

MACRO   resw    count
dw  count dup (?)
ENDM

MACRO   resd    count
dd  count dup (?)
ENDM

; Macros to declare assembler stubs for function structures

MACRO   BEGIN_STUBS_DEF name, firstOffset
begdataseg  _STUBS
ifdef   __NOU_VAR__
        EXTRN   name:DWORD
STUBS_START =   name
else
        EXTRN   _&name&:DWORD
name    EQU     _&name&
STUBS_START =   _&name
endif
enddataseg  _STUBS
begcodeseg  _STUBS
off = firstOffset
ENDM

MACRO   DECLARE_STUB    name
ifdef   __NOU__
name:
        PUBLIC  name
else
_&name:
        PUBLIC  _&name
endif
        jmp     [DWORD STUBS_START+off]
off = off + 4
ENDM

MACRO   SKIP_STUB    name
off = off + 4
ENDM

MACRO   DECLARE_STDCALL name,num_args
ifdef   STDCALL_MANGLE
_&name&@&num_args&:
        PUBLIC  _&name&@&num_args&
else
name:
        PUBLIC  name
endif
        jmp     [DWORD STUBS_START+off]
off = off + 4
ENDM

MACRO   END_STUBS_DEF
endcodeseg  _STUBS
ENDM

MACRO   BEGIN_IMPORTS_DEF   name
BEGIN_STUBS_DEF name,4
ENDM

ifndef LOCAL_DECLARE_IMP
MACRO   DECLARE_IMP name, numArgs
DECLARE_STUB    name
ENDM

MACRO   SKIP_IMP name
SKIP_STUB       name
ENDM

MACRO   SKIP_IMP2 name, numArgs
DECLARE_STUB    name
ENDM

MACRO   SKIP_IMP3 name
SKIP_STUB       name
ENDM
endif

MACRO   END_IMPORTS_DEF
END_STUBS_DEF
ENDM

MACRO   LEA_L    reg,name
        lea     reg,[name]
ENDM

MACRO   LEA_G    reg,name
        lea     reg,[name]
ENDM

endif