Update

Author: autismuk

CHANGES

@@ -111,4 +111,9 @@ Release 20 (01/01/23):
 	CHG: Checked font updated from Micah.
 	CHG: zTemp0 in graphics should be gxzTemp0 ; they are the same but they needn't be.
 
-Release 21 (01/01/23):	
+Release 21 (01/01/23):	
+
+	CHG: Remove capital neatening of file names.
+	CHG: Corrected block write to monitor bytes actually written out.
+
+Release 22 (01/01/23):	

TODO

@@ -1,5 +1,4 @@
 Progress:	
-	Fix Save.	
 	HIMEM
 	LOAD and SAVE memory.
 	- Break check
@@ -22,16 +21,3 @@ Progress:
 Ongoing:
 	Code reading.
 	Continue documentation.	
-
-Sorry for the misunderstanding.  It is functioning as designed ... just like POSIX 'write', and for mostly the same reasons (tho if I could do IEC in an interrupt, I could take up to 256 bytes at a time instead of 64).  Going into detail below so everyone can learn something:
-
-Kernels don't want to buffer data ... they only want to take what they can immediately hand over to a  device driver.  This is for several reasons, but the most important one is that kernel memory is typically allocated statically or per-process, and kernels need to treat all processes fairly (not letting one bad actor starve the others).  As a consequence, when a user performs a write, kernels have three choices:
-1. They can copy the immediately deliverable portion of the data into a small, per-socket buffer, 
-2. They can block the process until they can deliver the data,
-3. They can ask the process not to move or alter the data until signaled.
-
-#3 is hard on everyone, and #2 is a non-starter on an interactive system (even tho y'all are currently blocking yourselves, my games and operating systems won't be doing so).  That leaves #1.    Most unix-like kernels make the same choice for the same reason.  Do a "man 2 read" and a "man 2 write" and you'll see the exact same interface. 
-
-Now if you look under the covers of stdio, you're going to find that it just sits in a loop until it completes the read or write (or hits an error).  Why doesn't the kernel do it instead?  As designed, if you use the POSIX style interface, and you find that a socket is busy, you can do something else until it's no longer busy.  This lets you effect multi-tasking within a single process.  If you want to give up that ability for convenience (stdio), you're free to do so, but if the kernel blocked until the full write was complete, then everyone would be forced to give up the ability to multi-task.
-
-There's an extra little wrinkle with IEC.  Without IEC interrupts, I basically have to do the transfer on the user's thread.  This wouldn't be so bad, except IEC really is quite slow, and if I supported transactions of more than ~64 bytes at a time, the transfer could take so long that the kernel could run out of event objects and you would lose keystrokes or mouse events.  Thus, I force the driver to take no more than 64 bytes at a time.  This isn't a general limit (the kernel can take either 256 or 512 bytes depending on the device), and so it isn't an error to send more than 64 ... the kernel just won't take any more than that at a time for your own protection

bin/basic.rom

@@ -357,7 +357,7 @@ _KNLRBGetNextByte:
 		sta     kernel.args.recv.buflen
 
 		jsr     kernel.ReadData		       	; Get the data from the kernel  (Synchronous call, no error)
-		lda    event.file.data.read 		; Return # of bytes read (in A)
+		lda     event.file.data.read 		; Return # of bytes read (in A)
 
 		clc
 		rts
@@ -397,52 +397,53 @@ _KGNBExitFail:
 ;
 ;							Write data at (zTemp0) to Stream A, X bytes.
 ;
+;					  On error CS ; A = code. On success, CC, A = bytes read.
+;
 ; ************************************************************************************************
 
 Export_KNLWriteBlock:
-		pha
 		phx
 		phy
 		;
 		;		Already handled OPENED so can write out.
 		;
-        sta     kernel.args.file.write.stream ; save the stream.
+		sta     kernel.args.file.write.stream ; save the stream.
 
-        lda     zTemp0 						; save the data location.
-        sta     kernel.args.file.write.buf+0
-        lda     zTemp0+1
-        sta     kernel.args.file.write.buf+1
+		lda     zTemp0 						; save the data location.
+		sta     kernel.args.file.write.buf+0
+		lda     zTemp0+1
+		sta     kernel.args.file.write.buf+1
 
-        stx     kernel.args.file.write.buflen ; Set the buffer length
+		stx     kernel.args.file.write.buflen ; Set the buffer length
 
-        jsr     kernel.File.Write 			; write it out.
-        lda 	#kernel.event.file.ERROR 	; in case it fails.
-        bcs 	_KWBFailed
+		jsr     kernel.File.Write 			; write it out.
+		lda 	#kernel.event.file.ERROR 	; in case it fails.
+		bcs 	_KWBFailed
 
 _KNLWLoop:									; wait for an event.
-       	jsr     kernel.Yield
-        jsr     kernel.NextEvent
-        bcs     _KNLWLoop
-
-        lda     event.type 					; various errors.
-        cmp     #kernel.event.file.CLOSED
-        beq 	_KWBFailed
-        cmp     #kernel.event.file.ERROR
-        beq 	_KWBFailed
-        cmp     #kernel.event.file.EOF
-        beq 	_KWBFailed
-
-        cmp     #kernel.event.file.WROTE 	; wait until block write succeeds
-      	bne 	_KNLWLoop
-      	clc
-      	bra 	_KWBExit
+		jsr     kernel.Yield
+		jsr     kernel.NextEvent
+		bcs     _KNLWLoop
+
+		lda     event.type 					; various errors.
+		cmp     #kernel.event.file.CLOSED
+		beq 	_KWBFailed
+		cmp     #kernel.event.file.ERROR
+		beq 	_KWBFailed
+		cmp     #kernel.event.file.EOF
+		beq 	_KWBFailed
+
+		cmp     #kernel.event.file.WROTE 	; wait until block write succeeds
+		bne 	_KNLWLoop
+		clc
+		lda    event.file.wrote.wrote 		; get bytes written.
+		bra 	_KWBExit
 
 _KWBFailed:
 		sec
 _KWBExit:
 		ply
 		plx
-		pla
 		rts
 
 		.send code

modules/_build/_kernel.module

@@ -121,7 +121,7 @@ _KNLRBGetNextByte:
 		sta     kernel.args.recv.buflen	  										
 
 		jsr     kernel.ReadData		       	; Get the data from the kernel  (Synchronous call, no error)
-		lda    event.file.data.read 		; Return # of bytes read (in A)
+		lda     event.file.data.read 		; Return # of bytes read (in A)
 
 		clc
 		rts

modules/kernel/readchar.asm

@@ -17,52 +17,53 @@
 ;
 ;							Write data at (zTemp0) to Stream A, X bytes.
 ;
+;					  On error CS ; A = code. On success, CC, A = bytes read.
+;
 ; ************************************************************************************************
 
 Export_KNLWriteBlock:
-		pha
 		phx
 		phy
 		;
 		;		Already handled OPENED so can write out.
 		;
-        sta     kernel.args.file.write.stream ; save the stream.
+		sta     kernel.args.file.write.stream ; save the stream.
 
-        lda     zTemp0 						; save the data location.
-        sta     kernel.args.file.write.buf+0
-        lda     zTemp0+1
-        sta     kernel.args.file.write.buf+1
-      
-        stx     kernel.args.file.write.buflen ; Set the buffer length
+		lda     zTemp0 						; save the data location.
+		sta     kernel.args.file.write.buf+0
+		lda     zTemp0+1
+		sta     kernel.args.file.write.buf+1
+	  
+		stx     kernel.args.file.write.buflen ; Set the buffer length
 
-        jsr     kernel.File.Write 			; write it out.
-        lda 	#kernel.event.file.ERROR 	; in case it fails.
-        bcs 	_KWBFailed
+		jsr     kernel.File.Write 			; write it out.
+		lda 	#kernel.event.file.ERROR 	; in case it fails.
+		bcs 	_KWBFailed
 
 _KNLWLoop:									; wait for an event.
-       	jsr     kernel.Yield        
-        jsr     kernel.NextEvent
-        bcs     _KNLWLoop
+		jsr     kernel.Yield        
+		jsr     kernel.NextEvent
+		bcs     _KNLWLoop
 
-        lda     event.type 					; various errors.
-        cmp     #kernel.event.file.CLOSED
-        beq 	_KWBFailed
-        cmp     #kernel.event.file.ERROR
-        beq 	_KWBFailed
-        cmp     #kernel.event.file.EOF
-        beq 	_KWBFailed
+		lda     event.type 					; various errors.
+		cmp     #kernel.event.file.CLOSED
+		beq 	_KWBFailed
+		cmp     #kernel.event.file.ERROR
+		beq 	_KWBFailed
+		cmp     #kernel.event.file.EOF
+		beq 	_KWBFailed
 
-        cmp     #kernel.event.file.WROTE 	; wait until block write succeeds
-      	bne 	_KNLWLoop      
-      	clc
-      	bra 	_KWBExit
+		cmp     #kernel.event.file.WROTE 	; wait until block write succeeds
+		bne 	_KNLWLoop      
+		clc
+		lda    event.file.wrote.wrote 		; get bytes written.
+		bra 	_KWBExit
 
 _KWBFailed:
 		sec
 _KWBExit:
 		ply
 		plx
-		pla
 		rts
 
 		.send code