MELT.COM - Revision history

Bwl at 11:34, 8 January 2021

2021-01-08T11:34:52Z

2021-01-08T11:30:19Z

2021-01-08T11:27:19Z

2016-08-15T07:24:53Z

‎Or you could rethink it completely

2016-08-15T07:23:37Z

‎Or you could rethink it completely

2016-08-15T04:37:17Z

2016-08-15T04:33:13Z

15 bytes MELT

2016-08-15T00:01:00Z

2016-08-15T00:00:21Z

2016-08-14T22:19:16Z

@@ Line 157: / Line 157: @@
 bytes:
 <syntaxhighlight lang=nasm>
-	les	dx,[si]
+			les		dx,[si]
-	inc	cx
+			inc		cx
 doChar:
-	scasb
+			scasb
-	sbb 	[byte es:di-1],al
+			sbb 	[byte es:di-1],al
-	inc	di
+			inc		di
-	jnz 	doChar
+			jnz 	doChar
-	loop 	doChar
+			loop 	doChar
-	ret
+			ret
 </syntaxhighlight>
@@ Line 173: / Line 173: @@
 bytes:
 <syntaxhighlight lang=nasm>
-	les	dx,[si]
+			les		dx,[si]
-	dec	bx
+			dec		bx
 doChar:
-	scasb
+			scasb
-	sbb 	[es:di+bx],al
+			sbb 	[es:di+bx],al
-	inc	di
+			inc		di
-	jnz 	doChar
+			jnz 	doChar
-	loop 	doChar
+			loop 	doChar
-	ret
+			ret
 </syntaxhighlight>

@@ Line 169: / Line 169: @@
 If we then accept the loss of the last iteration, thereby leaving an occasional "happy face" (0xff) on the screen, we can be even more creative with the addressing and use di+bx, where we decrement bx to -1.
-Alternatives as <CODE>dec si/jnz</CODE> can be used instead of <CODE>loop</CODE> for yet another correct 14 bytes version.
+Alternatives as <CODE>dec si/jns</CODE> can be used instead of <CODE>loop</CODE> for yet another correct 14 bytes version.
 bytes:

@@ Line 148: / Line 148: @@
 			loop 	doChar			; second loop, 255 times
 			ret						; quit
 </syntaxhighlight>

@@ Line 96: / Line 96: @@
 doChar:
 			scasw					; used to advance DI by 2, and as DS high byte (0AFh)
-			cmp 	byte [di],32	; is the current char on screen a "space"?
+			cmp 	byte [di],32	    ; is the current char on screen a "space"?
 			jz		short skip 		; yes, don't decrement
 			dec 	byte [di]		; nope, decrement
@@ Line 117: / Line 117: @@
 doChar:
 			scasw					; used to advance DI by 2, and as DS high byte (0AFh)
-			cmp 	byte [di],al	; is the current char on screen a "null"?
+			cmp 	byte [di],al	    ; is the current char on screen a "null"?
 			jz		short skip 		; yes, don't decrement
 			dec 	byte [di]		; nope, decrement
@@ Line 142: / Line 142: @@
 doChar:
 			scasw					; used to advance DI by 2, and as DS high byte (0AFh)
-			cmp 	byte [di],al	; is the current char on screen a "null"?
+			cmp 	byte [di],al	    ; is the current char on screen a "null"?
-			adc 	byte [di],0ffh		; if not, then decrement
+			adc 	byte [di],0ffh  ; if not, then decrement
 			dec 	dx				; first loop, besides the first time
 			jnz 	doChar			; it's 65536 iterations

@@ Line 143: / Line 143: @@
 			scasw					; used to advance DI by 2, and as DS high byte (0AFh)
 			cmp 	byte [di],al	; is the current char on screen a "null"?
-			adc 	byte [di],ff		; if not, then decrement
+			adc 	byte [di],0ffh		; if not, then decrement
 			dec 	dx				; first loop, besides the first time
 			jnz 	doChar			; it's 65536 iterations

@@ Line 129: / Line 129: @@
 The above performs a similar function as the previous optimization, but runs even more slowly as it requires regular characters to be decremented further than before.
-Note the <CODE>CMP/JZ/DEC</CODE> sequence.  If we can set the carry flag as a result of the comparison, then we can perform a conditional decrement without the branch, via an <CODE>ADC</CODE>.
+Note the <CODE>CMP/JZ/DEC</CODE> sequence.  If we can control the carry flag as a result of the comparison, then we can perform a conditional decrement without the branch, via an <CODE>ADC</CODE>.
-Of course, if the AL register is zero, then there can never be a carry as a result of the comparison, but if we increase AL to 1, then every value other than zero will set the carry.
+Of course, if the AL register is zero, then there can never be a carry as a result of the comparison, but if we increase AL to 1, then every value other than zero will clear the carry.
 To increase the AX register would normally cost us one byte, but we happen to have one to spare in the <CODE>LDS</CODE> alignment.
@@ Line 138: / Line 138: @@
 <syntaxhighlight lang=nasm>
-			lds		bx,[si]			; load DS from our code "scasw" + "inc" = 0AFh
+			lds		bx,[si]			; load DS from our code "scasw" + "inc" = 0AF40h
-			inc		ax				; for alignment
+			inc		ax				; set AL to 1, also for alignment
 doChar:
 			scasw					; used to advance DI by 2, and as DS high byte (0AFh)

← Older revision		Revision as of 04:33, 15 August 2016
Line 128:		Line 128:

	The above performs a similar function as the previous optimization, but runs even more slowly as it requires regular characters to be decremented further than before.		The above performs a similar function as the previous optimization, but runs even more slowly as it requires regular characters to be decremented further than before.
		+
		+	Note the <CODE>CMP/JZ/DEC</CODE> sequence. If we can set the carry flag as a result of the comparison, then we can perform a conditional decrement without the branch, via an <CODE>ADC</CODE>.
		+
		+	Of course, if the AL register is zero, then there can never be a carry as a result of the comparison, but if we increase AL to 1, then every value other than zero will set the carry.
		+
		+	To increase the AX register would normally cost us one byte, but we happen to have one to spare in the <CODE>LDS</CODE> alignment.
		+
		+	That allows us to shave one more byte, to produce this 15 bytes version:
		+
		+	<syntaxhighlight lang=nasm>
		+	lds bx,[si] ; load DS from our code "scasw" + "inc" = 0AFh
		+	inc ax ; for alignment
		+	doChar:
		+	scasw ; used to advance DI by 2, and as DS high byte (0AFh)
		+	cmp byte [di],al ; is the current char on screen a "null"?
		+	adc byte [di],ff ; if not, then decrement
		+	dec dx ; first loop, besides the first time
		+	jnz doChar ; it's 65536 iterations
		+	loop doChar ; second loop, 255 times
		+	ret ; quit
		+	</syntaxhighlight>

@@ Line 13: / Line 13: @@
 doScreen:
-                 mov     cx, 2000        ; Going to loop over all 2000 characters
+                 mov     cx, 2000        ; Going to loop over all (80*25=)2000 characters
-                                        ; (80 * 25 = 2000)
+                 xor     bx, bx          ; bx = 0.  Also our "num of altered chars" counter
                  mov     di, bx          ; es:di now points at the screen (b800:0000)

@@ Line 28: / Line 28: @@
                  inc     bx              ; increase "number of processed chars" counter
                  jmp     short nextChar  ; Keep processing characters
 upToSpace:

← Older revision		Revision as of 22:19, 14 August 2016
Line 112:		Line 112:

	There might be a way of altering the <code>NOP</code> to something useful.		There might be a way of altering the <code>NOP</code> to something useful.
		+
		+	Returning to the non-printing null char, we can shave one more byte, to produce this 16 bytes version:
		+
		+	<syntaxhighlight lang=nasm>
		+	lds bx,[si] ; load DS from our code "scasw" + "nop" = 0AF90h
		+	nop ; for alignment, maybe optimization potential here ;)
		+	doChar:
		+	scasw ; used to advance DI by 2, and as DS high byte (0AFh)
		+	cmp byte [di],al ; is the current char on screen a "null"?
		+	jz short skip ; yes, don't decrement
		+	dec byte [di] ; nope, decrement
		+	skip:
		+	dec dx ; first loop, besides the first time
		+	jnz doChar ; it's 65536 iterations
		+	loop doChar ; second loop, 255 times
		+	ret ; quit
		+	</syntaxhighlight>
		+
		+	The above performs a similar function as the previous optimization, but runs even more slowly as it requires regular characters to be decremented further than before.