Comment	~
	X2B.ASM
	A replacement for the Exe2Bin program, which is NOT included with
	PC-DOS 3.3.
	written by Henry T. Nettles, Dec. 21, 1987 -- Feb. 20, 1988
	compiled with MicroSoft Macro Assembler, version 5.0
	The inspiration (and model) for this program was EXE2COM.C, written
	by Chris Dunford.
	The include module, DOS.INC, comes with MASM 5.0
	The subroutine BinToStr is borrowed from the SHOW.ASM program which
	also comes with MASM 5.0
	Some of this code (the command line parser) is borrowed from a program
	by Vernon Buerg (TABS.ASM)
	This program is hereby released to the public domain.

	Usage:  >X2B  [d:][\path\]PROG[.EXE]  [d:][\path\][PROG][.COM]

	The only necessary parameter is the file name of the input file.  A
	drive and/or path may be given if needed.
	If no extension is given, .EXE is assumed.  If no ouput file is
	given, then the same file name with an extension of .COM is used.
	WARNING: If a drive and/or path is given for the input file, and
	no ouput file is given, then the input drive and/or path will be
	used for the ouput (not the default directory).

	This program works on my computer, on the files I have tried it on.
	However, extensive testing has not been performed, and I assume no
	responsibility whatever for the program.  I would be interested in
	bug reports, and if anyone improves the code it would be nice to
	receive a copy.  I can be reached at:

			22547 Braken Carter
			Katy, Texas 77449-3619

Toad Hall Tweak, 15 Oct 89
- Converted to .COM format
- General tightening
- Moved EXE header buffer, filename buffers to dynamic space at code end
  (to reduce program size)
- Changed BinToStr procedure so it carries parms directly in AX/DI
  instead of the slow pushes.
- Removed some unnecessary local variables

Comment	ends	~

RECSIZE		equ	512
CMDTAIL		equ	80h
CR		equ	0dh
LF		equ	0ah
EOM		equ	'$'
SIZE_OF_HEADER	equ	28

exe_header	STRUC		; what an exe header looks like
exe_sig1	db	0	; EXE file signature: "MZ"
exe_sig2	db	0
excess		dw	0	; image size mod 512 (valid bytes in last page)
pages		dw	0	; # of 512 byte pages in image
relo_ct		dw	0	; count of relocation table entries
hdr_size	dw	0	; size of header in paragraphs
min_mem		dw	0	; min required memory
max_mem		dw	0	; max required memory
xss		dw	0	; stack seg offset in load module
xsp		dw	0	; initial value of sp
cksum		dw	0	; file checksum
xip		dw	0	; initial value of IP
xcs		dw	0	; cs offset in load module
relo_start	dw	0	; offset of first relocatable item
ovl_num		dw	0	; overlay number
exe_header ENDS			; end of structure

CSEG	SEGMENT PARA PUBLIC 'CODE'
	ASSUME	CS:CSEG, DS:CSEG, ES:CSEG

	org	100H

X2B	proc	near
	jmp	Start		;skip over runtime data			v1.1

errflag		db	0	;error flag				v1.1
save_ip		dw	0
handle1		dw	0
handle2		dw	0

msg1	db	'Input File ==>',eom
msg2	db	'  Output File ==>',eom
msg3	db	CR,LF,EOM

author		db	'X2B 1.1  Public Domain Software by Henry T. Nettles'
		db	CR,LF,EOM
code_size_msg	db	'Code Size = '
code_size_str	db	'      ',eom
code_start_msg	db	'  Code Start = '
code_start_str	db	'      ',eom
ip_msg		db	'  Initial IP = '
ip_str		db	'      ',CR,LF,EOM
actual_code_size_msg db	'Size of .Com file = '
actual_code_size_str db	'      ',CR,LF,EOM

code_size dw	0		; amount of code to move to .com file
code_start dw	0

no_file_msg1 db	'USAGE:  >X2B  [d:][\path\]file[.exe] [d:][\path\][file][.com]'
	     db	CR,LF,EOM
open_fail_msg  db 'ERROR: Open of input file failed!',CR,LF,EOM
create_fail_msg	db 'ERROR: Create of output file failed!',CR,LF,EOM
disk_full_msg  db 'ERROR: The disk is full!',CR,LF,EOM
Bad_Read_msg   db 'I/O Error on Read!',CR,LF,EOM
bad_write_msg  db 'I/O Error on Write!',CR,LF,EOM
seek_error_msg db 'I/O Error on Seek!',CR,LF,EOM

badsig_msg     db 'Invalid EXE File Signature',CR,LF,EOM
hasrelo_msg    db 'EXE has relocatable items',CR,LF,EOM
has_ss_msg     db 'EXE has stack segment',CR,LF,EOM
bad_ip_msg     db 'IP not 0 or 100h',CR,LF,EOM
too_big_msg    db 'Exe file is too big to convert to COM file',CR,LF,EOM
mul_err_msg    db 'Overflow on multiply',CR,LF,EOM


Start:					;v1.1

;****************************************************************************
;*	Get two file names from command line
;*	This portion of code was borrowed from TABS.ASM by Vernon Buerg
;****************************************************************************

	xor	al,al			;handy 0			v1.1
	mov	FNAME1,al		;insure both dynamic filename	v1.1
	mov	FNAME2,al		; buffers are 0			v1.1

	mov	si,CMDTAIL		; DS:SI points to command line
	sub	bp,bp			;Indicates first or second name
	sub	ch,ch			;The PSP may contain one or two
	or	cl,[si]			; filenames separated by blanks v1.1
	jz	GetF5			; First byte of cmdline should not be 0

	mov	di,offset FNAME1	;ES:DI points to fname1		v1.1
	Inc	si			; point to next char from command line
					; (assume that 1st char is a blank)

GetF1:	Lodsb				;Copy command line to file names
					; AL will contain character pointed
					; to by DS:SI
	cmp	AL,' '			; skip leading blanks
	jne	GetF2			; not a blank -- jump

	or	bp,bp			; or until the length is zero
	jz	GetF4			;If a second blank is found,
	 mov	ax,2400h		; append zero and dollar sign
	 stosw				; mov AX to ES:DI
	 mov	di,offset FNAME2	;ES:DI now points to 2d filename v1.1
	 jmp	short GetF4

GetF2:	cmp	AL,Cr			;Is it CR, end of line?
	je	GetF5			; yes, end of command

	stosb				; no, save in name
	mov	bp,di			; and indicate data copied
GetF4:	loop	GetF1

GetF5:	mov	ax,2400h		;Append zero and dollar	sign
	stosw

	mov	dx,offset author	;tell them who we are		v1.1
	mov	ah,9			;display string
	int	21H

;***************************************************************************
;*	DISPLAY THE TWO FILE NAMES FROM COMMAND LINE
;***************************************************************************
	mov	si,offset FNAME1	;point to fname1 		v1.1
	xor	al,al			;handy 0			v1.1
	cmp	al,[si]			;did user enter at least 1 file name? v1.1
	jnz	L1			; is ok, we have a file name
	 jmp	No_File1

L1:
	mov	di,si	;offset fname1	; check fname1 for extension	v1.1
	mov	cx,-1
	cld				; direction of search = forward
	repnz	scasb			; search through file name for '\0'
	not	cx			; CX = length including '\0'
	mov	dx,cx			;save length in DX a sec	v1.1
	mov	di,si	;offset fname1	;point back to fname1 start	v1.1
	mov	al,'.'
	repnz	scasb			; search for period in file name
	jz	L1a			; found the period, must have ext

	mov	ax,si	;offset fname1	; no period, must add .EXE for user v1.1
	add	ax,dx	;fname1_len	;				v1.1
	dec	ax			;
	mov	di,ax			; di points to '\0' at end of file name
	mov	ax,'E.'	;452eh		; ".E" backwards		v1.1
	stosw
	mov	ax,'EX'	;4558h		; "XE" backwards		v1.1
	stosw
	mov	ax,2400h		; append zero and dollar sign
	stosw

L1a:
	mov	cx,-1			;common code			v1.1
	cmp	byte ptr FNAME2,0	;did user enter 2d file name?	v1.1
					; (should not be 0)		v1.1
	jnz	L2			; fname2 is non-blank, go check	for ext

	mov	si,offset FNAME1	;source is FNAME1		v1.1
	mov	di,si	;offset FNAME1	;into DI for a scasb		v1.1
	mov	al,'.'
	cld
	repnz	scasb			; search fname1 for '.'
	not	cx			; cx has length of fname1 including '.'
	dec	cx			; don't copy the period
	mov	di,offset FNAME2	; let Dest.  Index point to fname2 v1.1
					;SI (source) is already FNAME1	v1.1
	cld				; direction of movement = forward
	rep	movsb			; move chars from [SI] to [DI]
					;   CX has count (# chars to move)
	jmp	short L2a		; go add the ".COM"
;
L2:	mov	di,offset fname2	; check fname2 for extension
	xor	al,al			; zero al
	cld				; direction of search = forward
	repnz	scasb			; search through file name for '\0'
	not	cx			; CX = length including '\0'
	mov	dx,cx			; save the length in DX a sec	v1.1
	mov	di,offset FNAME2		;v1.1
	mov	al,'.'
	repnz	scasb			; search for period in file name
	jz	L2b			; found the period, must have ext

	mov	ax,offset FNAME2		;v1.1
	add	ax,dx	;fname2_len	;add in FNAME2's length		v1.1
	dec	ax			;adjust
	mov	di,ax			; di points to '\0' at end of file name
L2a:	mov	ax,'C.'	;432eh		; ".C" backwards		v1.1
	stosw
	mov	ax,'MO'	;4d4fh		;"OM" backwards			v1.1
	stosw
	mov	ax,2400h		; append zero and dollar sign
	stosw
L2b:
	mov	dx,offset msg1
	mov	ah,9
	int	21H
	mov	dx,offset FNAME1
	mov	ah,9
	int	21H
	mov	dx,offset msg2
	mov	ah,9
	int	21H
	mov	dx,offset FNAME2
	mov	ah,9
	int	21H
	mov	dx,offset msg3
	mov	ah,9
	int	21H

;****************************************************************************
;*	OPEN THE INPUT FILE
;****************************************************************************

	mov	dx,offset FNAME1	;open input file
	mov	ax,3D00H		;open, read only
	int	21H
	jnc	L3			; opened ok
	 jmp	Open_Fail		; no file

L3:	mov	handle1,ax		; save token for file

;****************************************************************************
;*	OPEN THE OUTPUT FILE
;****************************************************************************
	mov	dx,offset FNAME2	;output file name
	xor	cx,cx			;normal attributes
	mov	ah,3CH			;create file
	int	21H
	jnc	L4			; created ok
	 jmp	Create_Fail		; create failed

L4:	mov	handle2,ax		; save token for file

;****************************************************************************
;*	PROCESS THE EXE HEADER
;****************************************************************************
; first we read in the exe header, don't you think?

	mov	dx,offset BUFFER	;read buffer
	mov	cx,SIZE_OF_HEADER
	mov	bx,handle1
	mov	ah,3FH			;read from file/device
	int	21H
	jnc	L5			;read ok
	 jmp	Bad_Read		;read error

L5:	mov	bx,offset buffer	; use DS:BX to address buffer
	cmp	word ptr [bx].exe_sig1,'ZM'	;'MZ' backwards? v1.1
	je	L7			;YEP, OK
	 jmp	BadSig			;no, print error msg, exit	v1.1

L7:
	xor	ax,ax			;handy 0			v1.1

	cmp	[bx].relo_ct,ax			;is relocatable count 0? v1.1
	je	L8				; is ok, no relocatable items
	 jmp	HasRelo				; oops, can't convert

L8:
	cmp	[bx].xss,ax			;is stack segment 0?	v1.1
	je	L9				; is ok, no stack segment
	 jmp	Has_SS

L9:
	cmp	[bx].xsp,ax			;is stack segment offset 0? v1.1
	je	L10				; is okay
	 jmp	Has_SS

L10:
	mov	ax,[bx].xip			; initial value for IP
	or	ax,ax				; should either be 0 or 100h v1.1
	je	L11
	cmp	ax,100h
	je	L11
	 jmp	Bad_IP

L11:	mov	save_ip,ax		; save the IP for later use
;***************************************************************************
;* Compute offset of program image in module, and program size
;*
;* The program size is computed as follows;  it cannot exceed 64k bytes
;*     512 * (# of EXE pages -1 )
;*   + valid bytes in last EXE page
;*   - offset of program image in EXE file
;*
;* Note that if the IP is nonzero, we will skip the first
;* IP bytes of the program image, and copy IP bytes fewer
;* than the actual size
;*
;***************************************************************************

	mov	ax,[bx].hdr_size	; size of the program header
					; expressed in 16 byte paragraphs
	mov	cl,4			; no of times to shift
	shl	ax,cl			; fast multiply by 16
	mov	code_start,ax		; save it

	mov	ax,[bx].pages		;nr of 512-byte pages		v1.1
	dec	ax			; subtract 1
	cmp	ax,128			; is it too big? (128*512 is 64k)
	jle	L12			; no, is ok
	 jmp	Too_Big			; exe file is too big, print error

L12:	mov	cl,9			; number of times to shift left
	shl	ax,cl			; fast multiply by 512
	jno	L13			; jump on no overflow
	 jmp	Mul_Err			; else multiply error

L13:
	mov	cx,[bx].excess		; no. of bytes in last non-full page
	add	ax,cx			; add to result from above
	sub	ax,code_start		; subtract the code start address
	mov	code_size,ax		; save it for later
	mov	di,offset code_size_str	;where to write the Ascii chars	v1.1
	call	BinToStr		;convert code size		v1.1
	mov	dx,offset code_size_msg	;'Code size = xxxx'		v1.1
	mov	ah,9			;display msg
	int	21H

	mov	ax,code_start		;convert code start address	v1.1
	mov	di,offset code_start_str ;where to write the Ascii chars v1.1
	call	BinToStr
	mov	dx,offset code_start_msg	;'Code start = xxxx'	v1.1
	mov	ah,9
	int	21H

	mov	ax,save_ip		;program's IP
	mov	di,offset ip_str	;where to write the Ascii chars	v1.1
	call	BinToStr
	mov	dx,offset ip_msg	;'Initial IP = xxxx'		v1.1
	mov	ah,9
	int	21H

;****************************************************************************
;*	MOVE FILE POINTER TO START OF CODE
;****************************************************************************
;* Add the initial IP to the code start address.  This will give
;* us the file offset, which is the location in the EXE file that we
;* will start copying from
;*
	mov	ax,code_start
	add	ax,save_ip		;add in program's IP		v1.1
	mov	dx,ax			;DX needs it as lower part	v1.1
					;of file offset			v1.1

	mov	bx,handle1		; handle of input file
	xor	cx,cx			; upper	part of	offset		v1.1
	mov	ax,4200h		; move file pointer		v1.1
					;(from start)
	int	21h
	jnc	L14
	 jmp	Seek_Error

L14:
;****************************************************************************
;*	COPY THE CODE TO THE OUTPUT (.COM) FILE
;****************************************************************************
; reduce the code_size by the size of the IP
	mov	ax,code_size		; reduce the code_size
	sub	ax,save_ip		; by the IP size		v1.1
	mov	code_size,ax		; store it away

	mov	di,offset actual_code_size_str	;v1.1
	call	BinToStr		;convert code size

	mov	dx,offset actual_code_size_msg	;'Size of .COM file = xxxx' v1.1
	mov	ah,9
	int	21H
Next:					; process next record
	mov	ax,RECSIZE
	cmp	ax,code_size		; compare code_size to RECSIZE
	jle	L15			; if ax < code_size, use ax as is
	 mov	ax,code_size		;  else use size of remaining code
L15:	mov	cx,ax			; # of bytes to read
	mov	bx,handle1		;  input file
	mov	dx,offset buffer	; where to put it
	mov	ax,3f00h		; read from file/device
	int	21h
	jnc	L16			; read ok
	 jmp	Bad_Read		; ERROR - get out of here

L16:	or	ax,ax			; on return, AX has # of bytes read
	jnz	L17			; if not zero, keep on
	 jmp	Done			; read zero bytes, must be done

L17:
	mov	cx,ax			; nr bytes to write		v1.1
	mov	bx,handle2		;  output file
	mov	dx,offset buffer	; addr of what we are about to write
	mov	ah,40h			; write to file/dev
	int	21h
	jnc	L18			; carry flag not set, no error on write
	 jmp	Bad_Write		; jump if write error

L18:	cmp	ax,cx	;wsize		; AX has # of bytes actually written
	je	L19			; if we wrote all of the bytes
					;    that we wanted to, then keep on
	 jmp	Disk_Full		; did NOT write all of the bytes
					; that I wanted to, disk must be full
L19:	mov	bx,code_size
	xchg	ax,bx			; ax has code_size, bx has bytes written
	sub	ax,bx			; subtract bytes written from code_size
					;   which gives us the number of
	mov	code_size,ax		;   bytes remaining to be copied
	or	ax,ax			; bytes remaining = zero?	v1.1
	je	Done			; yes, we're finished
	 jmp	Next			; no, go read next block

;****************************************************************************
;*	ERROR MESSAGES
;****************************************************************************

No_File1:	mov	dx,offset no_file_msg1
		jmp	short Print_Error
Open_Fail:	mov	dx,offset open_fail_msg
		jmp	short Print_Error
Create_Fail:	mov	dx,offset create_fail_msg
		jmp	short Print_Error
Disk_Full:	mov	dx,offset disk_full_msg
		jmp	short Print_Error
Bad_Read:	mov	dx,offset bad_read_msg
		jmp	short Print_Error
Bad_Write:	mov	dx,offset bad_write_msg
		jmp	short Print_Error
Seek_Error:	mov	dx,offset seek_error_msg
		jmp	short Print_Error
BadSig:		mov	dx,offset badsig_msg
		jmp	short Print_Error
HasRelo:	mov	dx,offset hasrelo_msg
		jmp	short Print_Error
Has_SS:		mov	dx,offset has_ss_msg
		jmp	short Print_Error
Bad_IP:		mov	dx,offset bad_ip_msg
		jmp	short Print_Error
Too_Big:	mov	dx,offset too_big_msg
		jmp	short Print_Error
Mul_Err:	mov	dx,offset mul_err_msg

Print_Error:	mov	ah,9
		int	21h
		not	errflag		;turn error flag on		v1.1
					;(non-zero)

;****************************************************************************
;*	CLOSE INPUT AND OUTPUT FILES
;****************************************************************************

Done:	mov	ax,handle1		;input file handle
	or	ax,ax			; is the handle still zero,
					; as was initially? v1.1
	je	Get_Out			; yes, no files to close
	mov	ah,3eh			; close input file
	mov	bx,handle1
	int	21h

	mov	ax,handle2		;output file handle
	or	ax,ax			; is the handle still zero,
					; as was initially? v1.1
	je	Get_Out			; yes, no output file to close
	mov	ah,3eh			; close output file
	mov	bx,handle2
	int	21h

	cmp	errflag,0		;any errors?			v1.1
	jz	Get_Out			; no
	 mov	dx,offset FNAME2	; yes, delete the output file	v1.1
	 mov	ah,41H			;delete file
	 int	21H

;****************************************************************************
;*	EXIT WITH STATUS CODE
;****************************************************************************

Get_Out:
	mov	ax,4C00H		;terminate, errorlevel 0	v1.1
	int	21H

X2B	endp			;v1.1

; Procedure BinToStr (number,address)
; Purpose   Converts integer to string
; Input     ax = number to convert, di = near address for write	v1.1
; Output    AX has characters written

BinToStr  PROC	near

	sub	  cx,cx			; Clear	counter
	mov	  bx,10			; Divide by 10

; Convert and save on stack backwards

GetDigit:
	sub	  dx,dx			; Clear top
	div	  bx			; Divide to get last digit as remainder
	add	  dl,"0"		; Convert to ASCII
	push	  dx			; Save on stack
	or	  ax,ax			; Quotient 0?
	loopnz  GetDigit		; No? Get another

; Take off the stack and store forward

	neg	  cx			; Negate and save count
	mov	  dx,cx
PutDigit:
	pop	  ax			; Get character
	stosb				; Store it
	loop	  PutDigit
	mov	  ax,dx			; Return digit count

	ret				;				v1.1
BinToStr  ENDP

	even

buffer	label	byte	;recsize dup(?)
FNAME1	equ	buffer + RECSIZE	;64-byte input filename buffer
FNAME2	equ	FNAME1 + 64		;64-byte output filename buffer

CSEG	ENDS
	END	X2B