ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng)/ProfitPress-MegaCDROM2.B6I/PROG/ASSEMBLY/X2B11.ZIP/X2B11.ASM

Assembly Source File | 1989-10-14 | 17.8 KB | 568 lines

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