start:
lea bx,_HEXTABLE
end start

the data actually appears in the exe file but at a` different offset than supplied by "lea" or the listing. as you can tell im new at ass' but none of my 5 books say anything about this sort of thing.

;    THIS FILE READS AND DISPLAYS THE BIOS-PARAMETER-BLOCK 
;    FROM THE BOOT SECTOR OF A FLOPPY DISK







.model small
.data
  
  ; BIOS-Parameter-Block from floppy                                               
                                             
  __SECTOR_BUFFER         DB 512 DUP (0)     ; -a 512 byte array to hold a sector
  __BPB_ASCII_BUFFER      DB 138 DUP (0)     ; -make a routine to copy the BPB 
                                             ; into this,and then go back thru
                                             ; it and convert to ASCII for display
                                             
                                             
  __BYTES_PER_SECTOR      DW 00              ; at offset 0B,the start of BPB
  __SECTORS_PER_CLUSTER   DB 00              ;  
  __RESERVED_SECTORS      DW 00
  __NUMBER_OF_FATS        DB 00
  __ROOT_DIRECTORY_TOTAL  DW 00               ;MAX # OF ENTRIES ALLOWED  
  __SECTORTOTAL_COUNT     DW 00               ;total on this diskette
  __MEDIA_DESCRIPTOR      DB 00
  __SECTORS_PER_FAT       DW 00
  __SECTORS_PER_TRACK     DW 00
  __HEADS_TOTAL           DW 00               ;SIDES ON DISK
  
  __BPB_ENTRY_SIZE        DB 2,1,2,1,2,2,1,2,2,2,1 ;INCOMPLETE
    
  
    SectorsPerFat         DB  "Sectors Per FAT : "


  __BIOS_PARAMETER_OFFSET EQU 0Bh


   _BPS                   EQU "Bytes Per Sector"               
   
   _BUFFER                DW 00
    DBFR_PTR              DW 00
    DBFR_BASEPTR          DW 00

   _TABLE_POINTER         DW 00
   _TABLE_OFFSET          DB 00
   _HEX_TABLE             DB 00h,01h,02h,03h,04h,05h,06h,07h,08h,09h,0ah,0bh,0ch,0dh,0eh,0fh  ;short version,finish as needed
    HEXTBL_BASEPTR        DW 00h
    HEXTBL_PTR            DW 00h
   _ASCII_TABLE           DB 30h,31h,32h,33h,34h,35h,36h,37h,38h,39h,41h,42h,43h,44h,45h,46h  ;displays 0-9 a-f to screen
    ASCII_TABLE_BASEPTR   DW 00h
    ASCII_TABLE_PTR       DW 00h

.code
        org 100h




;*************************************************************************
;                      MY MACROS
;*************************************************************************
SAVE_REGISTERS MACRO
push ax
push bx
push cx
push dx

push ds
push es
ENDM SAVE_REGISTERS

RESTORE_REGISTERS MACRO
pop ax
pop bx
pop cx
pop dx

pop ds
pop es
ENDM RESTORE_REGISTERS

SPLITAX MACRO
xor ah,ah
xor cx,cx
mov ah,al
mov cl,04
shl al,cl
shr ah,cl
shr al,cl
ENDM

SPLITDX MACRO
xor dh,dh
xor cx,cx
mov dh,dl
mov cl,04
shl dl,cl
shr dh,cl
shr dl,cl
ENDM
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;




START:     ;#############       Entry Point       #########################




;##########################################################################

;Entry Point ------>
        
        call READ_BOOT_SECTOR
        call CLEAR_BPB_ASCII_BUFFER
        call FIL_BPB_ASCII_BUFFER

             lea bx,__BPB_ASCII_BUFFER
        call CONVERT_TO_DISPLAYABLE




jmp EXIT_TO_DOS



TESTS PROC

ret
ENDP       
           
           
           ;sector has been read into memory at 0:7c00 so just go there 
                                           ;otherwise read it into a buffer;
           ;and advance to offset 3 and copy it into the high-byte of ax
           ;variable and then increment and read in offset 4 into the 
           ;low-byte of ax,then copy ax into the __BYTES_PER_SECTOR variable

        
        
        
READ_BOOT_SECTOR PROC
;       [reads the boot sector into the sector buffer]

        cli
        xor ax,ax
        xor dx,dx
        mov dl,00h
        int 13h             ;reset Diskette
        
        xor ax,ax
        xor bx,bx
        xor cx,cx
        xor dx,dx
        lea bx,[__SECTOR_BUFFER]

                            ;begin int 13 "read-diskette-sector" call-setup
        
        mov ah,02h          ;select sub function "read-diskette-sector"
        mov al,01h          ;how many sectors to read in
        mov ch,00h          ;track #,0 for boot-sector
        mov cl,01h          ;sector #,starting at 1
        mov dh,0            ;head #
        mov dl,0            ;Drive #
                        
                        ;es:bx=pointer to buffer,has to be done for exe
        int 13h         ;do it eh?
                        ;for now,assume "NO ERRORS"

        ret
ENDP   

CLEAR_BPB_ASCII_BUFFER PROC    
;       [zeros the ascii buffer]

        xor bx,bx
        lea bx,[__BPB_ASCII_BUFFER]
        mov cx,08ah
        
        ZERO_ASCII_BUFFER:  ;  <--------------  from loop
        mov [bx],00h        ;needs a TYPE override?
        inc bx
        loop ZERO_ASCII_BUFFER
ret
ENDP
       
FIL_BPB_ASCII_BUFFER PROC    
;       [copies sector buffer into bpb ascii buffer]

        xor bx,bx       ;
        xor cx,cx
        lea bx,[__SECTOR_BUFFER]
        add bx,0bh                     ;offset to BPB
        mov si,bx
        xor bx,bx
        lea bx,[__BPB_ASCII_BUFFER]
        mov di,bx
        mov cx,08ah
        rep movsb

ret
ENDP

READ_BPB PROC

       ;Copy BPB into a variables as a block "a test"
       ;this should keep alignment with original data
       ;    should i just copy from ascii buffer?

        xor bx,bx       ;
        xor cx,cx
        lea bx,[__SECTOR_BUFFER]
        add bx,0bh                      ;offset to BPB
        mov si,bx
        xor bx,bx
        lea bx,[__BYTES_PER_SECTOR]     ;first item in variable block
        mov di,bx
        mov cx,11h
        rep movsb
ret
ENDP


CONVERT_TO_DISPLAYABLE PROC ;(seg,[bx])      "segment for data,pointer to
;                                         data to be converted"
;                                          -these are written to
;                                         before calling this function


;      [goes to each byte and converts to ascii]
        SAVE_REGISTERS                     ;register MACR0




INITIALIZE_POINTERS_CTD:
        ;DBFR_BASEPTR = __BPB_ASCII_BUFFER  "this was sent to this function in bx"


        mov DBFR_BASEPTR,bx          ;operand type mismatch?
        mov DBFR_PTR,bx

        lea bx,_HEX_TABLE
        mov HEXTBL_BASEPTR,bx        ;initial values,points to beginning of table
        mov HEXTBL_PTR,bx

        lea bx,_ASCII_TABLE
        mov ASCII_TABLE_BASEPTR,bx
        mov ASCII_TABLE_PTR,bx
        ;######################



GET_VALUE_TO_TEST_CTD:

      


LOOP_GET_VALUE_CTD:       ;<-----------------------------------------------------
        xor ax,ax
;       [THIS POINTS TO THE DISPLAY BUFFER POSITION TO CONVERT]
        mov ax,[[DBFR_PTR]]        ;match wasnt found if this loops back here,this should not change yet?
        SPLITAX                  ;setup AX so the "nibbles" can be tested

NEXT_HEX_TEST_CTD:        ;<<--------------------------------------------
;        mov ax,[DBFR_PTR]         ;setup values to compare                              
        
        mov dx,[HEXTBL_PTR]
        SPLITDX
        cmp ax,dx                 ;do the comparison
        je MATCH_CTD              ;match found,also,stays within loop structure

NO_MATCH_CTD:
        inc [HEXTBL_PTR]          ;increment hextable pointer to next value to test
        jmp NEXT_HEX_TEST_CTD     ;display buff pointer stays same,------------>>
                                  ;but hex tries another value 

MATCH_CTD:
        mov ax,HEXTBL_PTR        ;match found,copy *HEXTBL_PTR to *ASCII_TABLE_PTR
        mov ASCII_TABLE_PTR,ax   ;
        mov ax,[ASCII_TABLE_PTR] ;copy value "HERE" into display buffer position,the conversion! 
        mov [DBFR_PTR],ax        ;DONE,setup next test
                          
        mov ax,[HEXTBL_BASEPTR]  ;reset hex table pointer to beginning of table
        mov [HEXTBL_PTR],ax      ;

        inc [DBFR_PTR]           ;move DBFR pointer to next value to convert
                                 ;ASCII pointer doesnt have to be reset since it gets
                                 ;its value when a match is found.
                                 ;falls thru to "next_value...

NEXT_VALUE_CTD:
        loop LOOP_GET_VALUE_CTD ;

RESTORE_REGISTERS
ret
ENDP
;##################################################################################


    
    GET_SIZE:                     
        xor ax,ax                 
        xor bx,bx                        ;__BIOS_PARAMETER_OFFSET use this instead of 0Bh
        xor cx,cx
        lea bp,__BPB_ENTRY_SIZE          ;Get BPB item size to test
        mov cl,[bp]                      ;copies size into cl
        
       ;if 1 byte got this
        mov ch,01h
        cmp ch,cl
        je COPY_DATA_ITEM_AX
        
       ;if 2 bytes goto that
        mov ch,02h
        cmp ch,cl
        je COPY_DATA_ITEM_DX
        
        
   COPY_DATA_ITEM_DX:     
        lea bp,__BPB_ASCII_BUFFER        ;Base address 
        
        mov dl,[bp+_TABLE_OFFSET]        ;copy 1st byte into bufflow
        inc [_TABLE_OFFSET]
        mov dh,[bp+_TABLE_OFFSET]        ;copy 1st byte into buffhigh

        jmp END_COPY_DATA

   COPY_DATA_ITEM_AX:
        lea bp,__BPB_ASCII_BUFFER        ;first item in variable block 
        mov al,[bp+_TABLE_OFFSET]
    END_COPY_DATA:                                      
        
        
        
        mov al,[bp]
        inc bp
        mov bx,02h
        sub ax,bx
        
        
        lea dx,_HEX_TABLE
    
                         ;what were going to test

    


DISPLAY_BPB:
           
           
           jmp ACTIVE_PAGE

           
           

ACTIVE_PAGE:           
      
         ; get Active Display page
           xor ax,ax
           xor bx,bx
           mov ah,0fh
           int 10h
           
           
           xor ax,ax
           xor bx,bx
           mov bl,07h             ; set attribute so it will DISPLAY!
           mov ah,13h             ; sub-func 13 "write string" 
           mov al,01h             ; cursor "stays"
           lea bp,SectorsPerFat   ; text to DISPLAY
           mov cx,18              ; 18 characters
           mov dh,00              ; row 1 of 25,"top of screen"
           mov dl,00h             ; column 1,"left side of screen"
           int 10h

    DIRECT_WRITE:
           push ds
           xor ax,ax
           mov ah,0B8h
           mov al,00h
           mov ds,ax
           lea bp,__SECTORS_PER_FAT
           mov si,bp
           mov di,12h
           movsw
           pop ds
           ;END DIRECT_WRITE:



jmp EXIT_TO_DOS
           
           nop
           nop
           nop
           nop

           xor ax,ax
           xor bx,bx
           mov bl,07h               ;set attribute so it will DISPLAY!
           mov ah,13h               ; sub-func 13 "write string" 
           mov al,01h               ; cursor "stays"
           lea bp,__SECTORS_PER_FAT
           mov cx,01                ; 1 characters
           mov dh,00                ;row 1 of 25,"top of screen"
           mov dl,19                ;column 1,"left side of screen"
           int 10h

jmp EXIT_TO_DOS




;mov bx,0000h
;mov ds,bx
;mov es,bx
;mov bx,7c03h
;mov ah,ds:[bx]


xor ax,ax        
        ;goto the io.sys and msdos.sys sector and test for them,or mine actually
        ;print "this is a boot disk" to screen.,until my own stuff is written.




GET_DISK_MAP:

READ_IO_SYS:

READ_MSDOS_SYS:



jmp EXIT_TO_DOS


EXIT_TO_DOS:
mov ah,4ch
mov al,00h
int 21h

END START    

   format binary as "COM" ; with org $0100, test from DOS
    

   format binary as "BIN" ; without org $0100, boot it