Back to home page

DOS ain't dead

Forum index page

Log in | Register

Search:  
Back to the forum
Board view  Mix view

NASM version 2.09 available | A86 (Announce)

posted by ecm Homepage E-mail, Düsseldorf, Germany, 07.09.2010, 22:42

> Still just for fun I thought I would do a quick compare using your
> example:
Okay, but, uhm, you do know it was supposed to be a NASM-only example?

> LABEL is reserved word in MASM, A86, TASM? So A86 will only compiles your
> program if LABEL is fixed, e.g. LABEL1.
NASM allows access to reserved words by prefixing them with '$'. That can be done automatically using macros (so that you can actually use the unprefixed word as label).

> and is 52 bytes [...]
Yup, you could write smaller code! Try this:

        mov ah, 02h
        mov dl, '!'
        int 21h
        retn

Note how this is both less source code and a smaller binary (7 byte). The source code was freed from all the unnecessary red tape. It also makes our user interface less obstructive than ever.

>   mov ah, 9h
Why not "mov ah, 9" then? This is worse than both alternatives!

>   db "Now tell me this isn't more readable!",13,10,"$"
It's not. Why is there a dollar sign behind all your messages? What's that do? I don't get it. /BLAHMODE

> > I don't doubt that you can write simple programs in A86 easily,
> > but so can I in NASM.
 >
> I think it is important to remember you can write complex programs in
> pretty much anything.
How does this program look in A86? Note that here, you can add code to the installation or TSR section as necessary and all the segment arithmetic is automatically fixed up. The vstart option makes the TSR section work as a separate segment, that is, the labels there are addressed as if the section's beginning was at address 0. Besides that, note the relevant size calculations and how actually NASM isn't trying to do the segment setup here; I am doing it. Of course I usually write macros to make such complicated segment setup and access easier, this is the "unrolled" form.

        cpu 8086
        org 100h

        section TRANSIENT

transient:
        mov ah, 52h
        int 21h
        mov ax, word [ es:bx-2 ]
        push cs
        pop es
.loop:
        mov ds, ax
        inc ax
        cmp word [ 1 ], ax
        jne .next
        cmp word [ 3 ], resident_size_p
        jne .next
        mov si, 8
        mov di, residentmcb+8
        mov cx, si
        rep cmpsb
        jne .next

        push ax
        mov ax, 3521h
        int 21h
        pop ax
        cmp bx, handler
        jne .error
        mov bx, es
        cmp ax, bx
        jne .error

        push ds
        lds dx, [ 10h + handler.next ]
        mov ax, 2521h
        int 21h

        pop ds
        mov word [ 1 ], 0

        mov dx, 'U'
        jmp short .exit

.error:
        mov dx, (0FFh<<8)+'!'

.exit:
        mov ah, 02h
        int 21h

        mov ah, 4Ch
        mov al, dh
        int 21h

.next:
        add ax, word [ 3 ]
        cmp byte [ 0 ], 'M'
        je .loop

        mov ax, cs
        add ax, 10h+transient_size_p
        mov ds, ax
        mov ax, 3521h
        int 21h
        mov word [ handler.next +2 ], es
        mov word [ handler.next ], bx
        mov ah, 25h
        mov dx, handler
        int 21h

        mov ax, cs
        mov ds, ax
        add word [ residentmcb + 1 ], ax

        dec ax
        mov es, ax
        mov bl, byte [ es:0 ]
        mov ax, word [ es:3 ]

        sub ax, 10h+transient_size_p+resident_size_p+1
        mov word [ newmcb + 3 ], ax
        mov byte [ newmcb + 0 ], bl

        mov sp, $-$$+100h&~1
        mov word [ es:3 ], 10h+transient_size_p-1
        mov byte [ es:0 ], 'M'

        mov dx, 'I'
        jmp short .exit


        align 16
residentmcb:
        db 'M'
        dw 10h+transient_size_p
        dw resident_size_p
        db 0,0,0
        db "I21HOOK",0

; I'd usually do these equates in a macro
transient_size equ $-transient
transient_size_p equ transient_size+15>>4

        section RESIDENT vstart=0 align=16
resident:

handler:
        ; Do Int21 hook functionality here.
        jmp 0:0
.next:  equ $-4

resident_size equ $-resident
resident_size_p equ resident_size+15>>4

        section NEWMCB align=16
newmcb:
        db 0
        dw 0
        dw 0
        times 3+8 db 0

> Obviously most of the time it makes sense to do
> things the easy way if easier tools exist.
The easiest way (speaking of simple syntax) would be using nothing but db. That doesn't require a complex assembler either. This is an extreme comparison, but my point here is that doing things the easy way isn't what you should prefer most of the time - I usually prefer higher readability of the source code. (This doesn't mean using HLL macros to write your code for you. It means writing real code in a way so it's readable.)

> I can't compare NASM in that regards as to be honest I've not used it for
> Win32.
I've used neither for any real Win32 effort but then again it just doesn't interest me. I don't see why it would be necessary to write for a Win32 platform, DOS programs done right are complex enough.

> > Int21.09 but I don't like it that much.)
 >
> Any particular reason?
It uses a dollar sign as string terminator. That is silly. (It also doesn't allow displaying device names, as they'll often contain dollar signs.)

> Obviously not easy to use ;)
Yeah.. I would assume D86 doesn't work there :-P

> Still for those of us with A86 and A86 formatted
> code/libraries be aware we may occasionally still use it.
I never said anything against that ;-)

---
l

Post reply
 

Complete thread:

Back to the forum
Board view  Mix view
22649 Postings in 2111 Threads, 402 registered users, 823 users online (1 registered, 822 guests)
DOS ain't dead | Admin contact
RSS Feed
powered by my little forum