3 replies to this topic

[err0r]

Which assembler should I use?
For windows.

[MeTh0Dz]

MASM TASM FASM, take your pick...

[outsid3r]

MeTh0Dz|Reb0rn said:

MASM TASM FASM, take your pick...

NASM eats that 3 assemblers at same time :D

NASM is a great choice, is considered on of best assemblers or maybe the best, and is portable, also the code is simplier, more closer to machine instructions but doesn't mean that is more harder that others, in fact, it's more acessible in every points. NASM is really great.

[outsid3r]

err0r said:

Which assembler should I use?
For windows.

I wrote a lib with some C like basic IO functions, take a look to get an idea of what is NASM:

%ifndef	_IO

%define	_IO



;BYTE COLOR VALUES

%define	BLACK		00000000b

%define	BLUE		00000001b

%define	GREEN		00000010b

%define	CYAN		00000011b

%define	RED		00000100b

%define	MAGENTA	00000101b

%define	BROWN		00000110b

%define	WHITE		00000111b

%define	GRAY		00001000b

%define	LIGHTBLUE	00001001b

%define	LIGHTGREEN	00001010b

%define	LIGHTCYAN	00001011b

%define	LIGHTRED	00001100b

%define	LIGHTMAGENTA	00001101b

%define	YELLOW		00001110b

%define	LIGHTWHITE	00001111b



	SECTION	.data

txtatt:	db	WHITE

c_x:	dw	0

c_y:	dw	0



	SECTION	.code

itoa:

	push	bp

	mov	bp, sp


	mov	bx, word [bp+4]

	mov	ax, word [bp+6]

.loop:

	mov	dx, 0

	mov	cx, 10

	div	cx


	cmp	ax, 0

	je	.end


	add	dx, 48

	mov	[bx], dx


	inc	bx

	jmp	.loop

.end:

	add	dx, 48

	mov	[bx], dx

	inc	bx

	mov	byte [bx], 0


	push	word [bp+4]

	call	near reverse


	pop	bp

	retn	4



reverse:

	push	bp

	mov	bp, sp


	sub	sp, 5			;alloc 5 bytes

	mov	byte [bp-1], 0		;c

	mov	word [bp-3], 0		;i


	push	word [bp+4]

	call	near strlen

	mov	bx, word [bp+4]

	dec	ax

	mov	word [bp-5], ax		;j

.loop:

	mov	ax, word [bp-3]

	cmp	ax, word [bp-5]

	jae	.end


	mov	si, word [bp-3]

	mov	al, byte [bx+si]

	mov	[bp-1], al		;c = bx[i]


	mov	si, word [bp-5]

	mov	al, byte [bx+si]

	mov	si, word [bp-3]

	mov	[bx+si], al		;bx[i] = bx[j]


	mov	si, word [bp-5]

	mov	al, byte [bp-1]	

	mov	[bx+si], al		;bx[j] = c


	inc	word [bp-3]

	dec	word [bp-5]


	jmp	.loop

.end:

	mov	sp, bp

	pop	bp

	retn	2



strcmp:

	push	bp

	mov	bp, sp


	mov	si, word [bp+6]

	mov	di, word [bp+4]

.loop:

	mov	al, byte [di]

	cmp	al, byte [si]

	jne	.end

	cmp	byte [si], 0

	je	.end


	inc	si

	inc	di


	jmp	.loop

.end:

	mov	al, [si]

	sub	al, byte [di]


	pop	bp

	retn	4



strlen:

	push	bp

	mov	bp, sp

	mov	bx, [bp+4]

	mov	cx, 0

.loop:

	cmp	byte [bx], 0

	je	.end

	inc	bx

	inc	cx

	jmp	.loop

.end:	

	mov	ax, cx

	pop	bp

	retn	2



strcpy:

	push	bp

	mov	bp, sp


	mov	si, [bp+6]

	mov	di, [bp+4]

.loop:

	cmp	byte [si], 0

	je	.end


	mov	al, byte [si]

	mov	byte [di], al


	inc	si

	inc	di

	jmp	.loop

.end:

	mov	byte [di], 0

	pop	bp

	retn	4



cprint:

	push	bp

	mov	bp, sp

	mov	si, [bp+4]

.loop:

	cmp	byte [si], 0

	je	.end


	mov	ah, 09h

	mov	al, byte [si]

	mov	bh, 0

	mov	bl, byte [txtatt]	

	mov	cx, 1

	int	10h


	mov	ah, 03h

	mov	bh, 0

	int	10h


	mov	ah, 02h

	mov	bh, 0

	inc	dl

	mov	dh, dh

	mov	dl, dl

	int	10h


	inc	si

	jmp	.loop

.end:

	pop	bp

	retn	2



cputc:

	push	bp

	mov	bp, sp

	mov	si, [bp+4]


	mov	ah, 09h

	mov	al, [si]

	mov	bh, 0

	mov	bl, [txtatt]

	mov	cx, 1

	int	10h


	pop	bp

	retn	2



txtcl:

	push	bp

	mov	bp, sp


	mov	ah, [bp+4]		;save new color attrib

	mov	al, [txtatt]		;save current atrib


	shr	al, 4

	shl	al, 4			;discard old text color nibble

	xor	al, ah			;set color nibble  	

	mov	[txtatt], al


	pop	bp

	retn	2



txtbg:

	push	bp

	mov	bp, sp


	mov	ah, [bp+4]		;save new color attrib

	shl	ah, 4			;move LO nibble to HO nibble

	mov	al, [txtatt]		;save current atrib


	shl	al, 4

	shr	al, 4			;discard old bg color bits nibble

	xor	al, ah			;set new bg nibble

	mov	[txtatt], al


	pop	bp

	retn	2



getxy:

	push	bp

	mov	bp, sp


	mov	ah, 03h

	mov	bh, 0

	int	10h


	mov	si, [bp+6]

	mov	byte [si], dl

	mov	si, [bp+4]

	mov	byte [si], dh


	pop	bp

	retn	4



setxy:

	push	bp

	mov	bp, sp


	mov	ah, 02h

	mov	bh, 0

	mov	dh, byte [bp+4]

	mov	dl, byte [bp+6]

	int	10h


	pop	bp

	retn	4



input:

	push	bp

	mov	bp, sp

	mov	si, [bp+4]

.loop:

	mov	ah, 00h

	int	16h


	cmp	al, 1Bh		;if ESC key

	je	.loop

	cmp	al, 09h		;if TAB key

	je	.loop	

	cmp	al, 4800h	;if UP ARROW key

	je	.loop

	cmp	al, 4B00h	;if LEFT ARROW key

	je	.loop

	cmp	al, 5000h	;if DOWN ARROW key

	je	.loop

	cmp	al, 4D00h	;if RIGHT ARROW key

	je	.loop

	cmp	al, 08h		;if BS key

	je	.back_one

	cmp	al, 0Dh		;if RETURN key

	je	.end


	mov	ah, 0Eh

	mov	al, al

	xor	bx, bx

	int	10h


	mov	[si], al

	inc	si


	jmp	.loop

.back_one:

	cmp	byte [si-1], 0

	je	.loop


	mov	ah, 0Eh

	mov	al, al

	xor	bx, bx

	int	10h


	mov	ah, 0Ah

	mov	al, ' '

	xor	bx, bx

	mov	cx, 1

	int	10h


	dec	si

	mov	byte [si], 0


	jmp	.loop

.end:

	mov	byte [si], 0

	pop	bp

	retn	2



getch:

	mov	ah, 00h

	int	16h

	retn



getchar:

	push	bp

	mov	bp, sp

	mov	ah, 00h

	int	16h

	mov	si, [bp+4]

	mov	[si+0], al

	mov	ah, 0Eh

	mov	al, al

	xor	bx, bx

	int	10h

	pop	bp

	retn	2



putch:

	push	bp

	mov	bp, sp

	mov	ah, 0Ah

	mov	al, [bp+4]

	xor	bx, bx

	mov	cx, 1	

	int	10h

	pop	bp

	retn	2



putchar:

	push	bp

	mov	bp, sp


	mov	ah, 0Eh

	mov	al, [bp+4]

	xor	bx, bx

	int	10h

	pop	bp

	retn	2



print:

	push	bp

	mov	bp, sp

	mov	si, [bp+4]

.loop:

	cmp	byte [si], 0

	je	.end

	mov	ah, 0Eh

	mov	al, [si]

	xor	bx, bx

	int	10h

	inc	si

	jmp	.loop

.end:

	pop	bp

	retn	2


%endif	;_IO

NASM also have many great tutorials around the web, there's some:

NASM Manual
PC Assembly Language


And finally, there's also an operating system build purely with NASM code ! named dynatOS, take a look:

Latest News - The DynatOS Project


Regards :)