laag-nasm 2.13.03.2

data/vendor/repo.or.cz/nasm/misc/pmw.bat

@@ -0,0 +1,9 @@
+@echo off
+rem some batch file to bind nasm and ndisasm with pmode/w
+rem a mega cool dos extender for watcom done by tran
+rem 
+rem max 8 megs, dpmi stack 256*16=4096, no banner
+pmwlite.exe nasm.exe
+pmwsetup.exe /X8388608 /P256 /B0 nasm.exe
+pmwlite.exe ndisasm.exe
+pmwsetup.exe /X8388608 /P256 /B0 ndisasm.exe

data/vendor/repo.or.cz/nasm/misc/proc32.ash

@@ -0,0 +1,441 @@
+;--------=========xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=========--------
+;
+;   Copyright (C) 1999 by Andrew Zabolotny
+;   Miscelaneous NASM macros that makes use of new preprocessor features
+; 
+;   This library is free software; you can redistribute it and/or
+;   modify it under the terms of the GNU Library General Public
+;   License as published by the Free Software Foundation; either
+;   version 2 of the License, or (at your option) any later version.
+; 
+;   This library is distributed in the hope that it will be useful,
+;   but WITHOUT ANY WARRANTY; without even the implied warranty of
+;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;   Library General Public License for more details.
+; 
+;   You should have received a copy of the GNU Library General Public
+;   License along with this library; if not, write to the Free
+;   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+;
+;--------=========xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=========--------
+
+;   The macros in this file provides support for writing 32-bit C-callable
+;   NASM routines. For a short description of every macros see the
+;   corresponding comment before every one. Simple usage example:
+;
+;	proc	sin,1
+;		targ	%$angle
+;		fld	%$angle
+;		fsin
+;	endproc	sin
+
+%ifndef __PROC32_ASH__
+%define __PROC32_ASH__
+
+[WARNING -macro-selfref]
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Mangle a name to be compatible with the C compiler
+; Arguments:
+;   The name
+; Example:
+;		cname (my_func)
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%ifdef EXTERNC_UNDERSCORE
+		%define	cname(x) _ %+ x
+%else
+		%define	cname(x) x
+%endif
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Import an external C procedure definition
+; Arguments:
+;   The name of external C procedure
+; Example:
+;		cextern	printf
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		cextern	1
+		%xdefine %1 cname(%1)
+	%ifidni __OUTPUT_FORMAT__,obj
+		extern	%1:wrt FLAT
+	%else
+		extern	%1
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Export an C procedure definition
+; Arguments:
+;   The name of C procedure
+; Example:
+;		cglobal	my_printf
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		cglobal	1
+		%xdefine %1 cname(%1)
+		global	%1
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Misc macros to deal with PIC shared libraries
+; Comment:
+;   Note that we have a different syntax for working with and without
+;   PIC shared libraries. In a PIC environment we should load first
+;   the address of the variable into a register and then work through
+;   that address, i.e: mov eax,myvar; mov [eax],1
+;   In a non-PIC environment we should directly write: mov myvar,1
+; Example:
+;		extvar	myvar
+;		GetGOT
+;	%ifdef PIC
+;		mov	ebx,myvar	; get offset of myvar into ebx
+;	%else
+;		lea	ebx,myvar
+;	%endif
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%ifdef PIC
+		cextern	_GLOBAL_OFFSET_TABLE_
+	%macro	GetGOT	0
+		%ifdef .$proc.stkofs
+			%assign .$proc.stkofs .$proc.stkofs+4
+		%endif
+		call	%$Get_GOT
+	%$Get_GOT:
+		pop	ebx
+		add	ebx,_GLOBAL_OFFSET_TABLE_ + $$ - %$Get_GOT wrt ..gotpc
+	%endmacro
+	%macro	extvar	1
+		cextern	%1
+		%xdefine %1 [ebx+%1 wrt ..got]
+	%endmacro
+%else
+	%define	GetGOT
+	%macro	extvar	1
+		cextern	%1
+	%endmacro
+%endif
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Begin a procedure definition
+;   For performance reasons we don't use stack frame pointer EBP,
+;   instead we're using the [esp+xx] addressing. Because of this
+;   you should be careful when you work with stack pointer.
+;   The push/pop instructions are macros that are defined to
+;   deal correctly with these issues.
+; Arguments:
+;   First argument - the procedure name
+;   Second optional argument - the number of bytes for local variables
+;   The following arguments could specify the registers that should be
+;   pushed at beginning of procedure and popped before exiting
+; Example:
+;   proc	MyTestProc
+;   proc	MyTestProc,4,ebx,esi,edi
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		proc	1-3+ 0
+		cglobal	%1
+		%push	%1
+		align	16
+%1:
+		%xdefine %$proc.name %1
+	; total size of local arguments
+		%assign %$proc.locsize (%2+3) & 0xFFFC
+	; offset from esp to argument
+		%assign	%$proc.argofs 4+%$proc.locsize
+	; additional offset to args (tracks push/pops)
+		%assign	.$proc.stkofs 0
+	; offset from esp to local arguments
+		%assign %$proc.locofs 0
+	; Now push the registers that we should save
+		%define %$proc.save %3
+	%if %$proc.locsize != 0
+		sub	esp,%$proc.locsize
+	%endif
+		push	%$proc.save
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Declare an argument passed on stack
+;   This macro defines two additional macros:
+;     first (with the name given by first argument) - [esp+xx]
+;     second (with a underscore appended to first argument) - esp+xx
+; Arguments:
+;   First argument defines the procedure argument name
+;   Second optional parameter defines the size of the argument
+;   Default value is 4 (a double word)
+; Example:
+;		arg	.my_float
+;		arg	.my_double,8
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		arg	1-2 4
+	%ifndef %$proc.argofs
+		%error	"`arg' not in a proc context"
+	%else
+	; Trick: temporary undefine .$proc.stkofs so that it won't be expanded
+		%assign	%%. .$proc.stkofs
+		%undef .$proc.stkofs
+		%xdefine %{1}_ esp+%$proc.argofs+.$proc.stkofs
+		%xdefine %1 [esp+%$proc.argofs+.$proc.stkofs]
+		%assign .$proc.stkofs %%.
+		%assign %$proc.argofs %2+%$proc.argofs
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Declare an local variable
+;     first (with the name given by first argument) - [esp+xx]
+;     second (with  a slash prefixing the first argument) - esp+xx
+; Arguments:
+;   First argument defines the procedure argument name
+;   Second optional parameter defines the size of the argument
+;   Default value is 4 (a double word)
+; Example:
+;		loc	.int_value
+;		loc	.double_value,8
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		loc	1-2 4
+	%ifndef %$proc.locofs
+		%error	"`loc' not in a proc context"
+	%elif %$proc.locofs + %2 > %$proc.locsize
+		%error	"local stack space exceeded"
+	%else
+		%assign	%%. .$proc.stkofs
+		%undef .$proc.stkofs
+		%xdefine %{1}_ esp+%$proc.locofs+.$proc.stkofs
+		%xdefine %1 [esp+%$proc.locofs+.$proc.stkofs]
+		%assign .$proc.stkofs %%.
+		%assign %$proc.locofs %$proc.locofs+%2
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Get the type of given size into context-local variable %$type
+; Arguments:
+;   Size of type we want (1,2,4,8 or 10)
+; Example:
+;		type	4	; gives "dword"
+;		type	10	; gives "tword"
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		type	1
+	%if %1 = 1
+		%define	%$type byte
+	%elif %1 = 2
+		%define	%$type word
+	%elif %1 = 4
+		%define	%$type dword
+	%elif %1 = 8
+		%define	%$type qword
+	%elif %1 = 10
+		%define	%$type tword
+	%else
+		%define %$. %1
+		%error "unknown type for argument size %$."
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Same as `arg' but prepends "word", "dword" etc (typed arg)
+;     first (with the name given by first argument) - dword [esp+xx]
+;     second (with  a slash prefixing the first argument) - esp+xx
+; Arguments:
+;   Same as for `arg'
+; Example:
+;		targ	.my_float	; .my_float is now "dword [esp+xxx]"
+;		targ	.my_double,8	; .my_double is now "qword [esp+xxx]"
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		targ	1-2 4
+	%ifndef %$proc.argofs
+		%error	"`targ' not in a proc context"
+	%else
+		arg	%1,%2
+		type	%2
+		%assign	%%. .$proc.stkofs
+		%undef .$proc.stkofs
+		%xdefine %1 %$type %1
+		%assign .$proc.stkofs %%.
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Same as `loc' but prepends "word", "dword" etc (typed loc)
+;     first (with the name given by first argument) - dword [esp+xx]
+;     second (with  a slash prefixing the first argument) - esp+xx
+; Arguments:
+;   Same as for `loc'
+; Example:
+;		tloc	int_value
+;		tloc	double_value,8
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		tloc	1-2 4
+	%ifndef %$proc.locofs
+		%error	"`tloc' not in a proc context"
+	%else
+		loc	%1,%2
+		type	%2
+		%assign	%%. .$proc.stkofs
+		%undef .$proc.stkofs
+		%xdefine %1 %$type %1
+		%assign .$proc.stkofs %%.
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Finish a procedure
+;   Gives an error if proc/endproc pairs mismatch
+;   Defines an label called __end_(procedure name)
+;   which is useful for calculating function size
+; Arguments:
+;   (optional) The name of procedure
+; Example:
+;   endproc	MyTestProc
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%push	tmp	; trick: define a dummy context to avoid error in next line
+%macro		endproc	0-1 %$proc.name
+	%ifndef %$proc.argofs
+		%error "`endproc' not in a proc context"
+	%elifnidn %$proc.name,%1
+		%define %$. %1
+		%error "endproc names mismatch: expected `%$proc.name'"
+		%error "but got `%$.' instead"
+	%elif %$proc.locofs < %$proc.locsize
+		%error	"unused local space declared (used %$proc.locofs, requested %$proc.locsize)"
+	%else
+%$exit:
+	; Now pop the registers that we should restore on exit
+		pop	%$proc.save
+		%if %$proc.locsize != 0
+		add	esp,%$proc.locsize
+		%endif
+		ret
+__end_%1:
+		%pop
+	%endif
+%endmacro
+%pop
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   A replacement for "push" for use within procedures
+; Arguments:
+;   any number of registers which will be push'ed successively
+; Example:
+;		push	eax,ebx,ecx,edx
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		push	0-*
+; dummy comment to avoid problems with "push" on the same line with a label
+	%rep	%0
+		push	%1
+		%rotate	1
+		%assign .$proc.stkofs .$proc.stkofs+4
+	%endrep
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   A replacement for "pop" for use within procedures
+; Arguments:
+;   any number of registers which will be pop'ed in reverse order
+; Example:
+;		pop	eax,ebx,ecx,edx
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		pop	0-*
+; dummy comment to avoid problems with "pop" on the same line with a label
+	%rep	%0
+		%rotate	-1
+		pop	%1
+		%assign .$proc.stkofs .$proc.stkofs-4
+	%endrep
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Replacements for "pushfd" and "popfd" that takes care of esp
+; Example:
+;		pushfd
+;		popfd
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		pushfd	0
+		pushfd
+		%assign .$proc.stkofs .$proc.stkofs+4
+%endmacro
+%macro		popfd	0
+		popfd
+		%assign .$proc.stkofs .$proc.stkofs-4
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Exit from current procedure (optionally on given condition)
+; Arguments:
+;   Either none or a condition code
+; Example:
+;		exit
+;		exit	nz
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		exit	0-1 mp
+		j%1	near %$exit
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   start an conditional branch
+; Arguments:
+;   A condition code
+;   second (optional) argument - "short" (by default - "near")
+; Example:
+;		if	nz
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		if	1-2 near
+; dummy comment to avoid problems with "if" on the same line with a label
+		%push	if
+		j%-1	%2 %$elseif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   define the "else" branch of a conditional statement
+; Arguments:
+;   optionaly: "short" if jmp to endif is less than 128 bytes away
+; Example:
+;		else
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		else	0-1
+	%ifnctx if
+		%error	"`else' without matching `if'"
+	%else
+		jmp	%1 %$endif
+%$elseif:
+		%define	%$elseif_defined
+	%endif
+%endmacro
+
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+; Summary:
+;   Finish am conditional statement
+; Arguments:
+;   none
+; Example:
+;		endif
+;-----======xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx======-----
+%macro		endif	0
+	%ifnctx if
+		%error	"`endif' without matching `if'"
+	%else
+		%ifndef %$elseif_defined
+%$elseif:
+		%endif
+%$endif:
+		%pop
+	%endif
+%endmacro
+
+%endif ; __PROC32_ASH__

data/vendor/repo.or.cz/nasm/misc/scitech.mac

@@ -0,0 +1,1223 @@
+;****************************************************************************
+;*
+;*  ========================================================================
+;*
+;*    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 __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	__NOU__
+global %1
+%else
+global _%1
+%define	%1 _%1
+%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
+
+; 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	__NOU__
+		global %1
+%1:
+%else
+		global _%1
+_%1:
+%endif
+		jmp     [DWORD STUBS_START+off]
+%assign off off+4
+%endmacro
+
+%imacro DECLARE_STDCALL 2
+%ifdef	STDCALL_MANGLE
+		global _%1@%2
+_%1@%2:
+%else
+%ifdef __GNUC__
+		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	1
+DECLARE_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,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   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
+
+MACRO   DECLARE_IMP	name
+DECLARE_STUB	name
+ENDM
+
+MACRO   END_IMPORTS_DEF
+END_STUBS_DEF
+ENDM
+
+endif