A2osX/SYS/KERNEL.S.STDIO.txt

NEW
  AUTO 3,1
*/--------------------------------------
* # putchar (BLOCKING)
* Print A (char) to StdOut
* ## C
* `int putchar ( short int character );`
* ## ASM
* **In:**
* `lda character`
* `>SYSCALL putchar`
* ## RETURN VALUE 
* CC = success
*\--------------------------------------
K.PutChar		>PUSHA					character

				ldy #S.PS.hStdOut
				lda	(pPS),y
				jsr K.FPutC
				bcc .8

				tay
				bne .8

				>PULLA					CS,A=0:BLOCKING, restore A

.8				rts
*/--------------------------------------
* # fputc (BLOCKING)
* Print A (char) to hFILE
* ## C
* `int fputc ( hFILE stream , short int character );`
* ## ASM
* **In:**
* `>PUSHB character`
* `lda stream`
* `>SYSCALL fputc`
* ## RETURN VALUE 
* CC = success
*\--------------------------------------
K.FPutC			jsr PFT.CheckNodeA
				bcs .8

				lda (pStack)			character
				sta K.IOBuf

				lda #0
				>PUSHA
				inc						write 1 byte
				>PUSHA

				>PUSHWI K.IOBuf			buf
				jsr UNISTD.Write
				bcc .8					pop char...

				cmp #E.NODATA
				sec
				bne .8

				inc						CS,A=0:BLOCKING
				rts

.8				>POP 1
				rts
*/--------------------------------------
* # puts (BLOCKING)
* Write Str to StdOut, appends '\r\n'
* ## C
* `int puts ( const char * str );`
* **In:**
* ## ASM
* `>LDYAI str`
* `>SYSCALL PutS`
* ## RETURN VALUE 
* CC = success
*\--------------------------------------
K.PutS			>STYA .1+1

				ldy #0

.1				lda $FFFF,y				SELF MODIFIED
				beq .2

				sta K.IOBuf,y
				iny
				bne .1

.9				lda #E.BUF
				sec
				rts

.2				lda #C.CR
				sta K.IOBuf,y
				iny
				beq .9

				lda #C.LF
				sta K.IOBuf,y
				iny
				beq .9

				lda #0
				sta K.IOBuf,y

				ldy #S.PS.hStdOut
				lda	(pPS),y
				>PUSHA
				>PUSHWI K.IOBuf

				jsr K.FPutS

				bcc K.PutS.RTS
				tay
				bne K.PutS.RTS

				>LDYA .1+1				CS,A=0:BLOCKING, restore Y,A

K.PutS.RET3		>POP 3					pop StdOut & buffer
K.PutS.RTS		rts
*/--------------------------------------
* # fputs (BLOCKING)
* Write Str to hFILE
* ## C
* `int fputs (hFILE stream, const char * str );`
* ## ASM
* **In:**
* `>PUSHB stream`
* `>PUSHW str`
* `>SYSCALL fputs`
* ## RETURN VALUE 
* CC = success
*\--------------------------------------
K.FPutS			jsr PFT.CheckNode2		set IO.hFD
				bcs K.PutS.RET3

				lda (pStack)
				sta ZPPtr2				Get String
				ldy #1
				lda (pStack),y
				sta ZPPtr2+1

				ldy #0
				ldx #0

.1				lda (ZPPtr2),y
				beq .2

				iny
				bne .1

				inx
				bra .1

.2				txa
				>PUSHA					push len HI

				tya
				>PUSHA					push len LO

				>PUSHW ZPPtr2
				jsr UNISTD.Write
				bcc K.PutS.RET3
				
				cmp #E.NODATA
				sec
				bne K.PutS.RET3			IO Error

				inc						FF-> 0 = BLOCKING

K.FPutS.RTS		rts
*/--------------------------------------
* # fgets (BLOCKING)
* read bytes from stream into the array
* pointed to by s, until n-1 bytes are read, or a <newline> is read and
* transferred to s, or an end-of-file condition is encountered. The
* string is then terminated with a null byte.
* ## C
* `char *fgets(hFILE stream, char * s, int n);`
* ## ASM
* **In:**
* `>PUSHB hFILE`
* `>PUSHW s`
* `>PUSHW n`
* `>SYSCALL fgets`
* ## RETURN VALUE 
*  Y,A: s 
* CC = success
*\--------------------------------------
* (pStack)+4	h
* (pStack)+2	s -> ZPPtr2
* (pStack)+0	n -> ZPPtr1
*--------------------------------------
K.FGetS			jsr PFT.CheckNode4
				bcs K.FPutS.RTS

				ldy #3

.1				lda (pStack),y
				sta ZPPtr1,y
				dey
				bpl .1
				
				lda ZPPtr1+1
				bmi .4					already something in buffer
			
.2				jsr STDIO.Get.1
				bcc .3

				cmp #MLI.E.EOF
				beq .9

				cmp #E.NODATA
				sec
				bne .9					IO error

				lda #0					BLOCKING
				rts

.3				lda K.IOBuf
				cmp #C.LF				Discard any leading LF from a prev CR/LF
				beq .2

				clc						set n = !n + 1
				lda ZPPtr1
				eor #$ff
				adc #1
				sta ZPPtr1

				lda ZPPtr1+1
				eor #$ff
				adc #0
				sta ZPPtr1+1
				
				bra .5
*--------------------------------------
.4				jsr STDIO.Get.1
				bcs .6

.5				lda K.IOBuf
				cmp #C.CR
				beq .8
				
				jsr SHARED.PutCharPtr2

				inc ZPPtr1
				bne .4
				inc ZPPtr1+1
				bne .4
				
				beq .8					Buffer full
				
.6				cmp #MLI.E.EOF
				beq .8					String terminated by EOF

				cmp #E.NODATA
				sec
				bne .9					I/O error

				ldy #3

.7				lda ZPPtr1,y			NO DATA, but string not yet terminated
				sta (pStack),y
				dey
				bpl .7

				lda #0					BLOCKING
*				sec
				rts

.8				lda #0
				sta (ZPPtr2)			terminate string
				clc
.9				>RET 5
*/--------------------------------------
* # getchar (BLOCKING)
* Get char from StdIn
* ## C
* `short int getchar ( );`
* ## ASM
* **In:**
* `>SYSCALL getchar`
* ## RETURN VALUE 
*  CC = success
*   A = char
*\--------------------------------------
K.GetChar		ldy #S.PS.hStdIn
				lda	(pPS),y		
*/--------------------------------------
* # getc (BLOCKING)
* Get char from Node
* ## C
* `short int getc ( short int stream );`
* ## ASM
* **In:**
* `lda stream`
* `>SYSCALL getc`
* ## RETURN VALUE 
*  CC = success
*   A = char
*\--------------------------------------
K.GetC			jsr PFT.CheckNodeA
				bcs K.GetC.RTS

				jsr STDIO.Get.1
				bcc .8
				
				cmp #E.NODATA
				sec
				bne K.GetC.RTS			I/O error

				inc						0 = BLOCKING
				rts

.8				lda K.IOBuf

K.GetC.RTS		rts
*--------------------------------------
STDIO.Get.1		lda #0
				>PUSHA
				inc						read 1 byte
				>PUSHA
				>PUSHWI K.IOBuf
				jmp UNISTD.READ
*/--------------------------------------
* # ungetc
* push byte back into input stream
* ## C
* `short int ungetc(short int c, short int stream);`
* ## ASM
* `>PUSHB c`
* `>PUSHB stream`
* `>SYSCALL ungetc`
* ## RETURN VALUE 
*  CC = success
*   A = char
*\--------------------------------------
K.UngetC		clc
				rts
*/--------------------------------------
* # FOpen
* Open a file
* ## C
* `short int fopen ( const char *filename, short int flags, short int ftype, int auxtype );`
* **In:**
* ## ASM
* `>PUSHW filename`
* `>PUSHB flags`
*  + O.RDONLY : if R and !exists -> ERROR
*  + O.WRONLY : if W and !exists -> CREATE
*  + O.TRUNC : Reset Size To 0
*  + O.APPEND : Append
*  + O.TEXT   : Open/Append in Text mode
*  + O.CREATE : Create if not exists
* `>PUSHB ftype`
* `>PUSHW auxtype`
* TODO: replace flags/ftype/auxtype with mode="w+,t=TYP,x=AUXTYPE"
*  + r  = O_RDONLY
*  + r+ = O_RDWR
*  + w  = O_WRONLY | O_CREAT | O_TRUNC
*  + w+ = O_RDWR | O_CREAT | O_TRUNC
*  + a  = O_WRONLY | O_CREAT | O_APPEND
*  + a+ = O_RDWR | O_CREAT | O_APPEND
*  + ,t=123 or t=$ff or t=TXT
*  + ,x=12345 or x=$ffff
* ## RETURN VALUE 
*  CC : A = hFILE
*  CS : A = EC
*\--------------------------------------
K.FOpen			jsr PFT.CheckPath4
				bcs .9
			
				>PULLW IO.Open.AUXTYPE
				>PULLB IO.Open.TYPE
				>PULLB IO.Open.FLAGS
				
				inc pStack				discard filename
				inc pStack
	
				jmp UNISTD.Open

.9				>POP 6
.99				rts
*/--------------------------------------
* # FClose
* Close a file
* ## C
* `int fclose ( short int stream );`
* ## ASM
* **In:**
* `lda stream`
* `>SYSCALL FClose`
* ## RETURN VALUE
*\--------------------------------------
K.FClose		jsr PFT.CheckNodeA
				bcs K.FRead.RTS

				jmp UNISTD.Close
*/--------------------------------------
* # FRead (BLOCKING)
* Read bytes from file
* ## C
* `int fread (short int stream, void * ptr, int count );`
* ## ASM
* **In:**
* `>PUSHWI count`
* `>PUSHW ptr`
* `lda stream`
* `>SYSCALL fread`
* ## RETURN VALUE
*  Y,A = Bytes Read
*\--------------------------------------
K.FRead			jsr PFT.CheckNodeA
				bcs K.FWrite.RET4

				jsr UNISTD.Read
				bcs K.FWrite.9

K.FRead.RTS		rts			
*/--------------------------------------
* # FWrite (BLOCKING)
* Write bytes to file
* ## C
* `int fwrite ( short int stream, const void * ptr, int count );`
* ## ASM
* **In:**
* `>PUSHWI count`
* `>PUSHW ptr`
* `lda stream`
* `>SYSCALL fwrite`
* ## RETURN VALUE
*  Y,A = Bytes Written
*\--------------------------------------
K.FWrite		jsr PFT.CheckNodeA
				bcs K.FWrite.RET4
			
				jsr UNISTD.Write
				bcc K.FWrite.RTS

K.FWrite.9		cmp #E.NODATA
				sec
				bne K.FWrite.RTS		IO Error

				dec pStack				FF = NODATA
				dec pStack
				dec pStack
				dec pStack				keep ptr & count on stack
				inc						0 = BLOCKING
*				sec
K.FWrite.RTS	rts

K.FWrite.RET4	>RET 4
*/--------------------------------------
* # FFlush
* ## C
* `int fflush( short int stream );`
* ## ASM
* **In:**
* `lda stream`
* `>SYSCALL fflush`
*\--------------------------------------
K.FFlush		jsr PFT.CheckNodeA
				bcs .9

				lda (pFD)
				bne STDIO.IOERR
				>MLICALL MLIFLUSH
.9				rts
*--------------------------------------
STDIO.IOERR		lda #MLI.E.IO
				sec
				rts
*/-------------------------------------
* # FSeek
* Set the file-position indicator for hFILE
* ## C
* `int fseek( short int stream, long offset, short int whence );`
* ## ASM
* **In:**
* `>PUSHBI whence`
* `>PUSHL offset`
* `lda stream`
* `>SYSCALL fseek`
*\-------------------------------------
K.FSeek			jsr PFT.CheckNodeA
				bcc .11

				>RET 5

.11				lda (pFD)
				bne STDIO.IOERR
				>PULLL ACC32
				>PULLA					whence
				cmp #SEEK.END
				beq .30
				bcs .98

				dec
				beq .20

				stz K.MLI.PARAMS+2
				stz K.MLI.PARAMS+3
				stz K.MLI.PARAMS+4
				bra .8

* SEEK.CUR
.20				>MLICALL MLIGETMARK
				bcc .8
				rts

* SEEK.END
.30				>MLICALL MLIGETEOF
				bcs .9

.8				ldy #0

				clc

.81				lda K.MLI.PARAMS+2,y
				adc ACC32,y
				sta K.MLI.PARAMS+2,y

				iny
				tya					3 bytes, 24 bits!!!
				eor #3
				bne .81

				bcs .99					Offset out of range!			

.82				>MLICALL MLISETMARK
				bcc .9
				cmp #MLI.E.BEYEOF
				bne .9
				>MLICALL MLISETEOF
				bcc .82
.9				rts

.98				lda #E.BADARG
				.HS 2C					bit abs
.99				lda #E.FTB
*				sec
K.FSeek.RTS		rts
*/--------------------------------------
* # FEOF
* Test the end-of-file indicator for hFILE
* ## C
* `int feof( short int stream );`
* ## ASM
* **In:**
* `lda stream`
* `>SYSCALL feof`
* ## RETURN VALUE
*  CC : 
*  A = $ff EOF
*  A = 0 NOT EOF
*  CS :
*\--------------------------------------
K.FEOF			jsr PFT.CheckNodeA
				bcs K.FSeek.RTS

IO.EOF			lda (pFD)
				tax
				jmp (.1,x)
.1				.DA FS.EOF.REG
				.DA STDIO.IOERR			DIR
				.DA IO.EOF.CDEV
				.DA STDIO.IOERR			BDEV
				.DA STDIO.IOERR			LNK
				.DA STDIO.IOERR			DSOCK
				.DA IO.EOF.SSOCK
				.DA IO.EOF.PIPE
*/--------------------------------------
* # FTell
* Return the current value of the file-position indicator
* ## C
* `long ftell( short int stream );`
* ## ASM
* **In:**
* `lda stream`
* `>SYSCALL ftell`
* ## RETURN VALUE
* On stack (long)
*\--------------------------------------
K.FTell			jsr PFT.CheckNodeA
				bcs .9
				>MLICALL MLIGETMARK
				bcs .9

				lda #0
				>PUSHA

				ldy #2

.1				lda K.MLI.PARAMS+2,y
				>PUSHA
				dey
				bpl .1

.9				rts
*/--------------------------------------
* # Remove
* Remove a file or directory
* ## C
* `int remove ( const char *pathname );`
* ## ASM
* **In:**
* `>LDYA pathname`
* `>SYSCALL remove`
* ## RETURN VALUE
*\--------------------------------------
K.Remove		jsr PFT.CheckPathYA
				bcs .9

				>MLICALL MLIDESTROY
.9				rts
*/--------------------------------------
* # Rename
* Rename a file
* ## C
* `int rename ( const char * oldpath, const char * newpath );`
* ## ASM
* **In:**
* `>PUSHW oldpath`
* `>PUSHW newpath`
* `>SYSCALL rename`
* ## RETURN VALUE
*\--------------------------------------
K.Rename		jsr PFT.CheckPath2
				bcs .9

				lda (pStack)
				sta ZPPtr1
				
				ldy #1
				lda (pStack),y
				sta ZPPtr1+1
				
				dey						ldy #0

.1				lda (ZPPtr1),y
				beq .8

				iny
				sta K.Buf256,y
				cpy #MLI.MAXPATH
				bne .1

.8				sty K.Buf256
				>LDYAI K.Buf256
				>STYA K.MLI.PARAMS+3
				>MLICALL MLIRENAME

.9				>RET 4
*/--------------------------------------
* # PrintF (BLOCKING)
* # FPrintF (BLOCKING)
* # SPrintF
* Prints C-Style String
* ## C
* `int printf ( const char *format, ... );`
* `int fprintf ( short int stream, const char *format, ... );`
* `int sprintf ( char *str, const char *format, ... );`
* ## ASM
* **In:**
* PrintF : (example is for printing Y,A as integer : format="%I", 2 bytes)  
* `>PUSHW format`
* `>PUSHW i`
* `...`
* `>PUSHBI 2`	#bytecount
* `>SYSCALL PrintF`
* FPrintF : 
* `>PUSHB hFILE`
* `>PUSHW format`
* `>PUSHW i`
* `...`
* `>PUSHBI 2`	#bytecount
* `>SYSCALL fprintf`
* SPrintF : 
* `>PUSHW str`
* `>PUSHW format`
* `>PUSHW i`
* `...`
* `>PUSHBI 2`	#bytecount
* `>SYSCALL sprintf`
* ## RETURN VALUE
* CC : success, Y,A = bytes sent
* CS : error, A = code from Output
* Specifiers :
* + %b : pull 1 byte to Print BIN 
* + %d : pull 1 byte unsigned DEC 0..255
* + %D : pull 2 bytes unsigned DEC 0..65535
* + %u : pull 4 bytes long unsigned DEC 0..4294967295
* + %e : pull 5 Bytes float (-)1.23456789e+12
* + %f : pull 5 Bytes float (-)3.1415
* + %h : pull 1 byte to Print HEX
* + %H : pull 2 bytes to Print HEX
* + %i : pull 1 byte to Print signed DEC -128..127
* + %I : pull 2 bytes to Print signed DEC -32768..32767
* + %L : pull 4 bytes signed DEC -2147483648..2147483647
* + %s : pull 2 bytes ptr to C-Style String
* + %S : pull 2 bytes ptr to P-Style String
* + \b : Print 'BS' (08)
* + \e : Print 'ESC' ($1B,27)
* + \f : Print 'FF' ($0C,12)
* + \n : Print 'LF' ($0A,10)
* + \r : Print 'CR' ($0D,13)
* + \t : Print 'TAB' ($09,09)
* + \v : Print 'VT' ($0B,11)
* + \xHH : Print byte with hexadecimal value HH (1 to 2 digits)
* + \\\\ : Print \
* + \\% : Print %
* Modifiers for len and padding : 
* + %d	  : '9'  '12'
* + %2d	  : ' 9' '12'
* + %02d  : '09' '12'
* + %11s  : 'ABCDEFGH   '	
* + %011s : 'ABCDEFGH000'
* + %2f	  :	'3.14'
*\--------------------------------------
				.DUMMY					ZPTMP+5,5  Used by : STDIO2
				.OR ZPTMP+5				5 Bytes
PrintF.Cnt		.BS 2
PrintF.hFILE	.BS 1
STDIO.StackBytePtr	.BS 1
STDIO.ExitPopCnt	.BS 1
				.ED
*--------------------------------------
K.PrintF.PadL	.EQ FAC+5
K.PrintF.PadC	.EQ ARG.SIGN
*--------------------------------------
K.PrintF		ldy #S.PS.hStdOut
				lda	(pPS),y
				sta PrintF.hFILE

				ldx #1
				.HS 2C					BIT ABS
*--------------------------------------
K.FPrintf		ldx #2
				.HS 2C					BIT ABS
*--------------------------------------
K.SPrintf		ldx #3
*--------------------------------------
K.PrintF.1		sec						format string->ptr2
				jsr STDIO.GetParams

				stx pIOBuf
				sta pIOBuf+1			Output buffer->pIOBuf

				sty STDIO.ExitPopCnt	Total bytes to POP

.1				jsr SHARED.GetCharPtr2
				bne .22

				jmp .8					end of format..

.22				cmp #'%'
				bne .10
				stz K.PrintF.PadL
				stz K.PrintF.PadC
				lda (ZPPtr2)
				beq .7					end of format... print % and exit

				jsr ZP.IsDigit
				bcs .6					no digit....go check specifier
				cmp #'0'				...a 0...mmm... padding char?
				bne .4
				sta K.PrintF.PadC
				jsr SHARED.NextCharPtr2	skip 0 ...
				lda (ZPPtr2)
				beq .7

				jsr ZP.IsDigit
				bcs .6					%0x ??????

.4				jsr MATH32.Dec2ACC32
				bcs .99
				lda ACC32
				sta K.PrintF.PadL
				lda K.PrintF.PadC
				bne .5
				lda #C.SPACE
				sta K.PrintF.PadC

.5				jsr SHARED.AddYToPtr2		skip all processed chars

				lda (ZPPtr2)
				beq .7

.6				ldx	#PrintFTBL1.Cnt-1	do we have a %x command?
.61				cmp PrintFTBL1,x
				beq .62
				dex
				bpl	.61
				bra .20					unknown ...

.62				jsr SHARED.NextCharPtr2
				txa						yes, jmp to it!
				asl
				tax
				jsr PrintF.ESC
.11				bcc .1
				bra .99
.7				lda #'%'
				bra .20
*--------------------------------------	
.10				cmp #'\'
				bne .20

				jsr SHARED.GetCharPtr2
				beq .99
				ldx	#PrintFTBL2.Cnt-1
.12				cmp PrintFTBL2,x
				beq .19
				dex
				bpl	.12

				cmp #'x'				\xHH
				bne .1

				jsr MATH32.Hex2ACC32
				bcs .99

				jsr SHARED.AddYToPtr2
.14				lda ACC32
				bra .20
.19				lda	PrintFTBL2.OUT,x

.20				jsr	PrintF.PutC
				bcc .11
*--------------------------------------
.99				lda #E.BADARG
				sec
				jmp STDIO.Exit
*--------------------------------------
.8				ldx PrintF.hFILE
				beq .80					Writing to buffer, append \0

				>PUSHW PrintF.Cnt		Writing to File/dev...
				>PUSHWI K.IOBuf

				txa
				jsr K.FWrite
				bcc .81

				tay
				bne .9
			
				>RET 4					0=BLOCKING

.80				ldy PrintF.Cnt			A=0, Writing to buffer, append \0
				sta (pIOBuf),y
				clc
.81				>LDYA PrintF.Cnt
*				clc
.9				jmp STDIO.Exit
*--------------------------------------
PrintFTBL1		.AS	"bdDuefhHiILsS"
PrintFTBL1.Cnt	.EQ *-PrintFTBL1
PrintFTBL2		.AS	"abefnrtv\%"
PrintFTBL2.Cnt	.EQ *-PrintFTBL2
PrintFTBL2.OUT	.HS 07.08.1B.0C.0A.0D.09.0B		\a\b\e\f\n\r\t\v
				.DA #'\'				\\
				.DA #'%'				\%
*--------------------------------------
PrintF.ESC		jmp (.1,x)
.1				.DA PrintF.B
				.DA PrintF.D,PrintF.DD,PrintF.U
				.DA PrintF.E,PrintF.F
				.DA PrintF.H,PrintF.HH
				.DA PrintF.I,PrintF.II,PrintF.L
				.DA PrintF.S,PrintF.SS
*--------------------------------------
PrintF.B		jsr STDIO.GetStackByte
				bcs PrintF.B.RTS
				ldy #8

.1				asl
				pha
				lda #'0'/2
				rol
				jsr PrintF.PutC
				bcs .9
				pla
				dey
				bne .1
				rts

.9				ply
PrintF.B.RTS
				rts
*--------------------------------------
PrintF.I		sec						signed short
				.HS 90					BCC
PrintF.D		clc						unsigned short (BYTE)

				ldy #1
				bra PrintF.NUM

PrintF.II		sec						signed int
				.HS 90					BCC
PrintF.DD		clc						unsigned int (WORD)

				ldy #2
				bra PrintF.NUM

PrintF.L		sec						signed long
				.HS 90					BCC
PrintF.U		clc						unsigned long (DWORD)

				ldy #4

PrintF.NUM		sty .2+1

				ror ACC32.Sign			save signed/unsigned flag
				jsr MATH32.ACC32ZERO

.1				jsr STDIO.GetStackByte
				bcs PrintF.B.RTS

				sta ACC32-1,y			PULL 4,2 or 1
				dey
				bne .1
				
				bit ACC32.Sign
				bpl .4
				
.2				ldy #$ff				SELF MODIFIED

				lda ACC32-1,y			Get highest Byte
				bpl .4					positive....

				lda #$ff

.3				cpy #4
				beq .4

				iny
				sta ACC32-1,y
				bra .3
				
.4				ldx K.PrintF.PadL
				ldy K.PrintF.PadC

				rol ACC32.Sign			get back signed/unsigned flag
				jsr MATH32.ACC322STR10
				bra PrintF.StrNum
*--------------------------------------	
* EXP(8) 1(s) 1significants(31)
* http://apple2.org.za/gswv/a2zine/GS.WorldView/Resources/GS.TECH.INFO/AppleSoft/
*--------------------------------------		
PrintF.E		sec						Force "E+12"
				.HS 90					BCC
PrintF.F		clc

				lda	(pStack)			get current stack Ptr
				sec						at least 5 bytes remaining ?
				sbc #5
				bcc PrintF.StrNum.Err
				sta (pStack)

*				sec
				adc pStack
				ldy pStack+1			A,Y = float
				ldx #FPU.SETFAC
				jsr GP.ROMCALL
				ldy #A2osX.NumStrBuf+1	FOUT.1 will do a DEY
				ldx #FPU.FOUT
				jsr GP.ROMCALL
	
PrintF.StrNum	ldy #0
.2				lda A2osX.NumStrBuf,y
				beq .8
				iny
				jsr PrintF.PutC
				bcc .2

.9				rts

.8				clc
				rts
PrintF.StrNum.Err
				lda #E.STACK
				sec
				rts
*--------------------------------------
PrintF.S		ldy #$ff				CSTR
				.HS 2C					bit abs
PrintF.SS		ldy #$00				PSTR

				sty .1+1
			
				jsr STDIO.GetStackByte
				bcs .9

				sta ZPPtr1+1
				jsr STDIO.GetStackByte
				bcs .9

				sta ZPPtr1
			
				lda (ZPPtr1)			if CSTR:last char=0, if PSTR:len=0
				beq .8
				
				ldy .1+1
				
.1				lda #$ff				Self Modified
				bne .11					CSTR

				tya						PSTR
				cmp (ZPPtr1)			len check
				
				beq .2
				
.11				iny
				lda	(ZPPtr1),y
				beq .2
		
				jsr PrintF.PutC
				bcs .9

				lda K.PrintF.PadL
				beq .1
				cpy	K.PrintF.PadL
				bne .1
.8				clc
				rts
				
.2				lda K.PrintF.PadL
				beq .8
				
.3				cpy K.PrintF.PadL
				beq .8
				
				lda K.PrintF.PadC
				jsr PrintF.PutC
				bcs .9
			
				iny
				bne .3

*				clc
.9				rts
*--------------------------------------
PrintF.HH		jsr STDIO.GetStackByte
				bcs PrintF.PutC.RTS
				pha						LO byte
				jsr STDIO.GetStackByte
				plx
				bcs PrintF.PutC.RTS
				pha
				txa
				jsr PrintF.H.1
				plx
				bcs PrintF.PutC.RTS
				txa
				bra PrintF.H.1
*--------------------------------------
PrintF.H		jsr STDIO.GetStackByte
				bcs PrintF.PutC.RTS
PrintF.H.1		jsr MATH32.AToHexAX
				jsr PrintF.PutC
				bcs PrintF.PutC.RTS
				txa
*--------------------------------------
PrintF.PutC		phy
				ldy PrintF.Cnt
				sta (pIOBuf),y
				ply
				inc PrintF.Cnt
				bne .8
				lda PrintF.hFILE
				bne .9

				inc pIOBuf+1
				inc PrintF.Cnt+1
.8				clc
				rts

.9				lda #E.BUF
				sec
PrintF.PutC.RTS	rts		
*/--------------------------------------
* # ScanF (BLOCKING)
* # FScanF (BLOCKING)
* # SScanF
* Read formatted data from string
* ## C
* `int scanf( const char *format, ... );`
* `int fscanf( short int stream, const char *format, ... );`
* `int sscanf ( const char *s, const char *format, ... );`
* ## ASM
* **In:**
* ScanF :
* `>PUSHW format`
* `>PUSHW ptr`
* `...`
* `>PUSHB bytecount`
* `>SYSCALL scanf`
* FScanF :
* `>PUSHB stream`
* `>PUSHW format`
* `>PUSHW ptr`
* `...`
* `>PUSHB bytecount`
* `>SYSCALL fscanf`
* SScanF :
* `>PUSHW s`
* `>PUSHW format`
* `>PUSHW ptr`
* `...`
* `>PUSHB bytecount`
* `>SYSCALL sscanf`
* Specifiers :
* + %i : short int
* + %d : byte
* + %I : int
* + %D : word
* + %L : long int
* + %U : dword
* + %h : HEX byte
* + %H : HEX word
* + %s : string
* TODO : %10s
* ## RETURN VALUE
* A = Number of arguments filled.
*\--------------------------------------
K.ScanF			ldy #S.PS.hStdIn
				lda	(pPS),y
				sta PrintF.hFILE
				
				ldx #1
				.HS 2C					BIT ABS
*--------------------------------------
K.FScanF		ldx #2
				.HS 2C					BIT ABS
*--------------------------------------
K.SScanF		ldx #3
*--------------------------------------
K.SScanF.1		clc						format string->ptr1
				jsr STDIO.GetParams

				stx ZPPtr2
				sta ZPPtr2+1			Output buffer->ZPPtr2

				sty STDIO.ExitPopCnt	Total bytes to POP
			
				ldx PrintF.hFILE
				beq .1
				
				txa
				>PUSHA
				>PUSHW pIOBuf
				>PUSHWI 256 
				jsr K.FGetS
				bcc .1
				
				tax
				bne PrintF.PutC.RTS
				>RET 4
				
.1				jsr SHARED.GetCharPtr1	End Of format?
				beq .8

				cmp #'%' 				Escape ?
				beq .2

				cmp #C.SPACE			Space ?
				beq .12
			
				sta .11+1
			
				jsr SHARED.GetCharPtr2
				beq .9
				
.11				cmp #$ff				Same char in string?
				beq .1
				
				bra .9

.12				jsr SHARED.GetCharPtr2
				beq .9
				cmp #C.SPACE
				bne .9
				
.13				jsr SHARED.GetCharPtr2
				cmp #C.SPACE			another space ?
				beq .13
				
				bra .1

.2				jsr SHARED.GetCharPtr1	Get specifier after %
				beq .9					unexpected End of format after "%" ?

				ldx #K.SScanFJMP-K.SScanFTBL-2

.3				cmp K.SScanFTBL,x
				beq .4
				dex
				dex
				bpl .3

.9				lda #MLI.E.EOF
				sec
				jmp STDIO.Exit

.4				jsr STDIO.GetStackByte
				bcs .9
				sta ZPPtr3+1
				jsr STDIO.GetStackByte
				bcs .9
				sta ZPPtr3
				
				jsr .5
				bcs .9					out of Ptr on stack

				inc .8+1				parsed one more arg!
				bra .1

.8				lda #$ff				SELF MODIFIED Arg processed
				clc
				jmp STDIO.Exit
*--------------------------------------
.5				jmp (K.SScanFJMP,x)
*--------------------------------------
K.SScanFTBL		.DA #'i,#1,#'d,#1,#'I,#2,#'D,#2,#'l,#4,#'u,#4,#'h,#1,#'H,#2,#'s,#2
K.SScanFJMP		.DA K.SScanF.I
				.DA K.SScanF.D
				.DA K.SScanF.II
				.DA K.SScanF.DD
				.DA K.SScanF.L
				.DA K.SScanF.U
				.DA K.SScanF.H
				.DA K.SScanF.HH
				.DA K.SScanF.S
*--------------------------------------
K.SScanF.I		
K.SScanF.D		
K.SScanF.II
K.SScanF.DD
K.SScanF.L
K.SScanF.U		lda K.SScanFTBL+1,x		Get VAR size
				pha						Save VAL size

				jsr MATH32.Dec2ACC32
				bra K.SScanF.GetVAL
*--------------------------------------
K.SScanF.HH
K.SScanF.H		lda K.SScanFTBL+1,x		Get VAR size
				pha

				jsr MATH32.Hex2ACC32

K.SScanF.GetVAL	jsr SHARED.AddYToPtr2	Y=char count parsed

.1				ply						get back VAL size 

.2				lda ACC32-1,y
				dey
				sta (ZPPtr3),y
				bne .2

.9				rts
*--------------------------------------
K.SScanF.S		ldy #$ff

.1				iny
				lda (ZPPtr2),y			Get char in string to scan
				sta (ZPPtr3),y			store in param ptr
				beq K.SScanF.Fwd		end of string to scan ?
				
				cmp (ZPPtr1)			match format next char ? 
				beq .2
				
				cmp #C.SPACE			is it a space ?
				bne .1
				
.2				lda #0					add \0 to param ptr
				sta (ZPPtr3),y

K.SScanF.Fwd	jmp SHARED.AddYToPtr2		Y=char count parsed
*--------------------------------------
* IN:
* CC : format in ZPPtr1
* CS : format in ZPPtr2
* X = 3 : get format & buffer
* X = 2 : get format & hFile
* X = 1 : get format only
* OUT:
* X = Buf LO
* A = Buf HI
* format on stack
* Y = BytePtr
*--------------------------------------
STDIO.GetParams	stz PrintF.Cnt
				stz PrintF.Cnt+1

				lda (pStack)			Bytecount
				
				tay
				sty STDIO.StackBytePtr

				iny
				lda (pStack),y			format LO
				pha

				iny
				lda (pStack),y			format HI
				bcs .10
				
				sta ZPPtr1+1
				pla
				sta ZPPtr1
				bra .11

.10				sta ZPPtr2+1
				pla
				sta ZPPtr2
				
.11				dex
				beq .1
				
				dex
				beq .2
				
.3				stz PrintF.hFILE
				
				iny
				lda (pStack),y			str LO
				tax

				iny
				lda (pStack),y			str HI
				
				rts

.2				iny
				lda (pStack),y			hFILE
				sta PrintF.hFILE

.1				ldx #K.IOBuf
				lda /K.IOBuf
				
STDIO.GetParams.RTS
				rts
*--------------------------------------
STDIO.GetStackPtr
				jsr STDIO.GetStackByte
				bcs STDIO.GetParams.RTS
				tax
*--------------------------------------
STDIO.GetStackByte
				phy

				ldy STDIO.StackBytePtr
				beq .9

				lda (pStack),y
				dec STDIO.StackBytePtr

				ply
				clc
				rts

.9				lda #E.STACK

				ply
				sec
				rts
*--------------------------------------
STDIO.Exit		php
				pha
				
				lda pStack
				sec
				adc STDIO.ExitPopCnt
				sta pStack
				
				pla
				plp
				rts
*--------------------------------------
MAN
SAVE usr/src/sys/kernel.s.stdio
LOAD usr/src/sys/kernel.s
ASM