PR#3
PREFIX /A2OSX.BUILD
LOMEM $A00
INC 1
AUTO 6
*/--------------------------------------
* # FPutC.AY
* Print A (char) to File
* ## In:
*  A : char to print
*  Y = hFILE
* ## Out: 
*  CC = success
*\--------------------------------------
K.FPutC.AY		sta K.PutC.Char
				sty K.PutC.Node
				tya
				phy
				bne K.PutChar.A.1
K.PutChar.A.8	ply
				clc
				rts
*/--------------------------------------
* # PutChar.A
* Print A (char) to StdOut
* ## In:
*  A : char to print
* ## Out: 
*  CC = success
*\--------------------------------------
K.PutChar.A		sta K.PutC.Char
				phy
				ldy #S.PS.hStdOut
				lda	(pPs),y
				beq K.PutChar.A.8			NUL
				
				phx
				
K.PutChar.A.1	sta K.PutC.Node
				jsr K.GetMemPtr.A
				>STYA pDev
								
				ldy #S.NODE.T
				lda (pDev),y
				asl
				tax
				jsr K.PutChar.A.Jmp
				
				plx
				ply
				rts
*--------------------------------------
K.PutChar.A.Jmp	jmp (.1,x)
.1				.DA K.PutChar.A.REG
				.DA STDIO.IOERR		DIR
				.DA K.PutChar.A.CDEV
				.DA STDIO.IOERR		BDEV
				.DA STDIO.IOERR		LNK
				.DA STDIO.IOERR		DSOCK
				.DA K.PutChar.A.SSOCK
				.DA K.PutChar.A.FIFO
*--------------------------------------
K.PutChar.A.REG	lda K.PutC.Node
				ldy K.PutC.Char
				jmp K.FWrite.AY
*--------------------------------------
K.PutChar.A.CDEV	ldy #S.NODE.DEV.JMP
				lda (pDev),y
				sta .1+1
				iny
				lda (pDev),y
				sta .1+2
				lda K.PutC.Char
				ldx #DEVMGR.WRITE
.1				jmp $ffff
*--------------------------------------
K.PutChar.A.SSOCK
				lda (pDev)				#S.NODE.HANDLER
				jsr K.GetMemPtr.A
				>STYA .1
				
				ldy #S.NODE.SSOCK.HSKT
				>PUSHB (pDev),y
				>PUSHB K.PutC.Char	
				
				ldy #S.NODE.SSOCK.WRITE
				lda (pDev),y
				tax						Function Offset for write
.1				jmp $ffff
*--------------------------------------
K.PutChar.A.FIFO
				ldy #S.NODE.FIFO.S
				lda (pDev),y
				beq .9					Remote PS did not opened yet the pipe
				cmp #S.NODE.FIFO.S.Closed
				beq .99					Remote PS closed the Pipe
				
				ldy #S.NODE.FIFO.hMem
				lda (pDev),y
				jsr K.GetMemPtr.A
				>STYA .1+2
				
				ldy #S.NODE.FIFO.Head
				lda (pDev),y
				inc
				dey						#S.NODE.FIFO.Tail	
				cmp (pDev),y
				beq .9					FIFO is full
				iny
				sta (pDev),y
				tay
				lda K.PutC.Char
.1				sta $ffff,y
				clc
				rts
				
.9				lda #MLI.ERR.VOLFULL
				.HS 2C					bit abs			
.99				lda #MLI.ERR.EOF
				sec
				rts				
*--------------------------------------
K.PutC.Char		.BS 1
K.PutC.Node		.BS 1			
*/--------------------------------------
* # GetChar
* Get char from StdIn
* ## In:
*  none.
* ## Out: 
*  CC = success
*   A = char
*\--------------------------------------
K.GetChar		ldy #S.PS.hStdIn
				lda	(pPs),y		
*/--------------------------------------
* # GetC.A
* Get char from File
* ## In:
*  A = hFILE
* ## Out: 
*  CC = success
*   A = char
*\--------------------------------------
K.GetC.A		sta K.PutC.Node
				jsr K.GetMemPtr.A
				>STYA pDev
								
				ldy #S.NODE.T
				lda (pDev),y
				asl
				tax
				jmp (.1,x)
				
.1				.DA K.GetC.REG
				.DA STDIO.IOERR			DIR
				.DA K.GetC.CDEV
				.DA STDIO.IOERR			BDEV
				.DA STDIO.IOERR			LNK
				.DA STDIO.IOERR			DSOCK
				.DA K.GetC.SSOCK
				.DA K.GetC.FIFO
*--------------------------------------
K.GetC.REG		lda K.PutC.Node
				jmp K.FRead.A
*--------------------------------------
K.GetC.CDEV		ldx #DEVMGR.READ
				ldy #S.NODE.DEV.JMP
				lda (pDev),y
				sta .1+1
				iny
				lda (pDev),y
				sta .1+2
.1				jmp $ffff
*--------------------------------------
K.GetC.SSOCK	lda (pDev)				#S.NODE.HANDLER
				jsr K.GetMemPtr.A
				>STYA .1
				
				ldy #S.NODE.SSOCK.READ
				lda (pDev),y
				tax						Function Offset for READ
				
				ldy #S.NODE.SSOCK.HSKT
				lda (pDev),y
				
.1				jmp $ffff
*--------------------------------------
K.GetC.FIFO
*/--------------------------------------
* # FPutS
* Write String to FILE
* ## In:
*  PUSHW : CPtr 
*  PUSHB : hFILE
* ## Out: 
*  CC = success
*\--------------------------------------
K.FPutS	
*/--------------------------------------
* # PutS.YA
* Write String to StdOut
* ## In:
*  Y,A : CPtr 
* ## Out: 
*  CC = success
*\--------------------------------------
K.PutS.YA	
*/--------------------------------------
* # FGetS
* Read String From FILE
* ## In:
*  PUSHW : CPtr 
*  PUSHB : hFILE
* ## Out: 
*  CC = success
*\--------------------------------------
K.FGetS
*/--------------------------------------
* # GetS.YA
* Read String From StdIn
* ## In:
*  Y,A : CPtr 
* ## Out: 
*  CC = success
*\--------------------------------------
K.GetS.YA
				bra *
*/--------------------------------------
* # FOpen
* Open a file
* ## In :
*  PUSHW = AUXTYPE
*  PUSHB = TYPE
*  PUSHB = MODE
*   SYS.FOpen.R : if R and !exists -> ERROR
*   SYS.FOpen.W : if W and !exists -> CREATE
*   SYS.FOpen.A : Append
*   SYS.FOpen.T : Open/Append in Text mode
*   SYS.FOpen.X : Create if not exists
*  PUSHW = PATH (PSTR)
* ## Out : 
*  CC : A = hFILE
*  CS : A = EC
*\--------------------------------------
K.FOpen			jsr PFT.CheckPathSTK
				jsr STDIO.PullMLIPath
				>PULLB K.FOpen.MODE
				>PULLB K.FOpen.TYPE
				>PULLW K.FOpen.AUXTYPE
				
				>MLICALL MLIGETFILEINFO
				bcc K.FOpen.10			Already Exists
				
				bit K.FOpen.MODE		Create if not exists ?
				bpl K.FOpen.9			No, return MLI error
				
				lda #S.FILEINFO.ACCESS.FULL				Yes, Create...
				sta K.MLI.PARAMS+3	Access
				lda K.FOpen.TYPE
				sta K.MLI.PARAMS+4	File type
				>LDYA K.FOpen.AUXTYPE
				>STYA K.MLI.PARAMS+5	Aux type
				lda #S.FILEINFO.STORETYPE.STD
				sta K.MLI.PARAMS+7
				
				ldx #3
				
.1				lda DATELO,x
				sta K.MLI.PARAMS+8,x
				dex
				bpl .1

				>MLICALL MLICREATE
				bcc K.FOpen.10
K.FOpen.9		rts

K.FOpen.10		>LDYAI S.NODE.REG
				jsr K.GetMem0.YA
				bcs K.FOpen.9
				
				>STYA ZPPtr1
				stx hFILE			
				
				jsr STDIO.SetIOBUF
				bcs .98

				>MLICALL MLIOPEN
				bcs .98
				
				lda K.MLI.PARAMS+5	get ref_num
				ldy #S.NODE.REG.REF
				sta (ZPPtr1),y
				
				sta K.MLI.PARAMS+1	Next MLI Calls are REF_NUM based
				
				lda K.FOpen.MODE
				bit #SYS.FOpen.W
				beq .20					Write mode ?
				
				and #SYS.FOpen.A		Append ?
				bne .11					yes, go to end of file
				
				stz K.MLI.PARAMS+2
				stz K.MLI.PARAMS+3
				stz K.MLI.PARAMS+4
				>MLICALL MLISETEOF		no, reset size to 0
				bcs .98
				bra .20
				
.11				>MLICALL MLIGETEOF
				bcs .98
				
				>MLICALL MLISETMARK
				bcs .98
				
.20				lda K.FOpen.MODE
				and #SYS.FOpen.T		Text Mode ?
				beq .30
				
				lda #$FF
				sta K.MLI.PARAMS+2
				lda #$0D
				sta K.MLI.PARAMS+3
				>MLICALL MLINEWLINE				
				
.30				ldy #S.NODE.T
				lda #S.NODE.T.REG
				sta (ZPPtr1),y
				lda hFILE
				clc
				rts						CC

.98				pha						save MLI error
				lda hFILE
				jsr K.FClose.A.1
				pla						get back MLI error
				sec
				rts
*--------------------------------------
K.FOpen.MODE	.BS 1
K.FOpen.TYPE	.BS 1
K.FOpen.AUXTYPE	.BS 2
hFILE			.BS 1
*/--------------------------------------
* # FClose.A
* Close a file
* ## In :
*  A = hFILE
* ## Out :
*\--------------------------------------
K.FClose.A		jsr PFT.CheckNodeA
				pha
				jsr K.GetMemPtr.A
				>STYA ZPPtr1
				pla
				
K.FClose.A.1	sta K.FClose.A.2+1
				ldy #S.NODE.REG.REF
				lda (ZPPtr1),y
				beq .1
				sta K.MLI.PARAMS+1
				>MLICALL MLICLOSE

.1				ldy #S.NODE.REG.IOBUF				
				lda (ZPPtr1),y
				beq K.FClose.A.2
				jsr K.FreeMem.A

K.FClose.A.2	lda #$ff				Self Modified
				jmp K.FreeMem.A
*/--------------------------------------
* # FRead.A
* Read ONE byte from file
* ## In :
*  A = hFILE
* ## Out :
*  A = Byte Read
*\--------------------------------------
K.FRead.A		jsr PFT.CheckNodeA
				ldx #MLIREAD
				bra K.FReadWrite.0				
*/--------------------------------------
* # FWrite.AY
* ## In:
*  A = hFILE
*  Y = char
* # Out:
*  Y,A = Bytes Written
*\--------------------------------------
K.FWrite.AY		jsr PFT.CheckNodeA
				sty K.FWrite.AY.Buf
				ldx #MLIWRITE
K.FReadWrite.0	jsr STDIO.GetRefNum
				>LDYAI K.FWrite.AY.Buf
				>STYA K.MLI.PARAMS+2
				lda #1
				sta K.MLI.PARAMS+4
				stz K.MLI.PARAMS+5
				lda #4					Param Count = 4 for MLIREAD & MLIWRITE
				jsr A2osX.MLICALL
				bcs .9
				lda K.FWrite.AY.Buf
.9				rts
K.FWrite.AY.Buf	.BS 1		
*/--------------------------------------
* # FRead
* Read bytes from file
* ## In :
*  PUSHW = Dest Ptr
*  PUSHW = Bytes To Read
*  PUSHB = hFILE
* ## Out :
*  Y,A = Bytes Read
*\--------------------------------------
K.FRead			jsr PFT.CheckNodeSTK
				ldx #MLIREAD
				bra K.FReadWrite.1
*/--------------------------------------
* # FWrite
* ## In:
*  PUSHW = Src Ptr
*  PUSHW = Bytes To Write
*  PUSHB = hFILE
* # Out:
*  Y,A = Bytes Written
*\--------------------------------------
K.FWrite		jsr PFT.CheckNodeSTK
				ldx #MLIWRITE
K.FReadWrite.1	>PULLA
				jsr STDIO.GetRefNum
				>PULLW K.MLI.PARAMS+4
				>PULLW K.MLI.PARAMS+2

				lda #4					Param Count = 4 for MLIREAD & MLIWRITE
				jsr A2osX.MLICALL
				bcs .9
				>LDYA K.MLI.PARAMS+6
.9				rts
*/--------------------------------------
* # FFlush.A
* ## In:
*  A = hFILE
*\--------------------------------------
K.FFlush.A		jsr PFT.CheckNodeA
				jsr STDIO.GetRefNum
				>MLICALL MLIFLUSH
				rts
*/-------------------------------------
* # FSeek
* ## In:
*  PUSHW = OffsetHi
*  PUSHW = OffsetLo
*  PUSHB = From
*  PUSHB = hFILE
*\-------------------------------------
K.FSeek			jsr PFT.CheckNodeSTK
				>PULLA
				jsr STDIO.GetRefNum
				>PULLA					FROM
				tax
				>PULLW K.FSeek.OFFSET
				>PULLW K.FSeek.OFFSET+2

				cpx #SYS.FSeek.SET

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

.1				cpx #SYS.FSeek.CUR
				bne .2
				>MLICALL MLIGETMARK
				bcc .8
				rts

.2				cpx #SYS.FSeek.END
				bne .98
				>MLICALL MLIGETEOF
				bcs .9

.8				ldx #0
				ldy #3
				
				clc
				
.81				lda K.MLI.PARAMS+2,x
				adc K.FSeek.OFFSET,x
				sta K.MLI.PARAMS+2,x

				inx
				dey
				bne .81
				
				bcs .99					Offset out of range!			

				>MLICALL MLISETMARK

.9				rts

.98				lda #SYSMGR.ERRSYN
				.HS 2C					bit abs
.99				lda #SYSMGR.ERRFTB
				sec
				rts
*--------------------------------------
K.FSeek.OFFSET	.BS 4			
*/--------------------------------------
* # FTell.A
* ## In:
*  A = hFILE
* ## Out:
*   Y,A,X = Offset
*\--------------------------------------
K.FTell.A		jsr PFT.CheckNodeA
K.FTell.A.1		jsr STDIO.GetRefNum
				>MLICALL MLIGETMARK
				bcs .9
				>LDYA K.MLI.PARAMS+2
				ldx K.MLI.PARAMS+4
.9				rts
*/--------------------------------------
* # FEOF.A
* ## In:
*  A = hFILE
* ## Out:
*  CC : 
*   A=0 EOF
*   A !=0 NOT EOF
*  CS :
*\--------------------------------------
K.FEOF.A		jsr PFT.CheckNodeA
				jsr STDIO.GetRefNum
				jsr K.FTell.A.1
				bcs .9
				>STYA K.FEOF.A.MARK
				stx K.FEOF.A.MARK+2

				>MLICALL MLIGETEOF
				bcs .9

				sec
				lda K.MLI.PARAMS+2
				sbc K.FEOF.A.MARK
				bne .8
				lda K.MLI.PARAMS+3
				sbc K.FEOF.A.MARK+1
				bne .8
				lda K.MLI.PARAMS+4
				sbc K.FEOF.A.MARK+2
.8				clc
.9				rts
K.FEOF.A.MARK	.BS 3
*/--------------------------------------
* # Remove.YA
*\--------------------------------------
K.Remove.YA		jsr PFT.CheckPathYA
				jsr STDIO.SetMLIPathYA
				>MLICALL MLIDESTROY
				rts
*/--------------------------------------
* # Rename
* Rename a file
* ## In :
*  PUSHW = New Name
*  PUSHW = Old Name
* ## Out :
*\--------------------------------------
K.Rename		jsr PFT.CheckPathSTK
				jsr STDIO.PullMLIPath
				>PULLW .1+1
				
				ldy #0
				
.1				lda $ffff,y				Self Modified
				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
				rts
*/--------------------------------------
* # SScanF
* Scan a PStr (in progress)
* ## In:
*  PUSHW PTR to target buffer
*  PUSHW PSTR pattern	(ex: "%d.%d.%d.%d")
*   %d : byte
*  PUSHW PSTR to scan (ex: "192.168.1.5")
* ## Out:
*\--------------------------------------
K.SScanF		jsr PullPtr1Ptr2Ptr3
				
				ldy	#0					Y = PTR in pattern
				
				lda (ZPPtr1)
				beq .9
				tax						X = COUNT to scan
				inc ZPPtr1
				bne .1
				inc ZPPtr1+1

.1				txa						End Of String?
				beq .8
				tya
				cmp (ZPPtr2)			End of pattern?
				beq .8
				iny
				lda (ZPPtr2),y
				cmp #'%' 				Escape?
				beq .2
				cmp (ZPPtr1)			Same char?
				bne .9
				jsr K.SScanF.IncPtr1
				bne .1
				clc
				rts
				
.2				tya 
				cmp (ZPPtr2)			unexpected End of pattern after "%" ?
				beq .9

				iny
				lda (ZPPtr2),y
				cmp #'d'				BYTE ?
				bne .3
				
				stz ASCBUF
.20				lda (ZPPtr1)
				jsr K.SScanF.IsDigit
				bcs .21
				phx
				inc ASCBUF
				ldx ASCBUF
				sta ASCBUF,x
				plx
				jsr K.SScanF.IncPtr1
				bne .20					end of string ?
				
.21				jsr DEC2HEX
				lda HEXBUF
				sta (ZPPtr3)
				inc ZPPtr3
				bne .1
				inc ZPPtr3+1
				bra .1

.3				cmp #'D'				WORD ?
				bne .4
				
				bra .1

.4				cmp #'s'				STRING ?
				bne .9
				
				bra .1
				
.8				clc
				rts
				
.9				sec
				rts
*--------------------------------------
K.SScanF.IncPtr1	
				dex
				beq .1
				inc ZPPtr1
				bne .1
				inc ZPPtr1+1			never Zero
.1				rts
*--------------------------------------
K.SScanF.IsDigit	
				cmp #'0'
				bcc .1
				cmp #'9'+1
				bcs .1
				rts
.1				sec
				rts				
*/--------------------------------------
* # PrintF.YA/SPrintF.YA/FPrintF.YA
* Prints C-Style String
* ## In:
* PrintF.YA : 
*   Y,A = PTR to CStr
* SPrintF.YA : 
*   Y,A = PTR to CStr
*   PULLW = Ptr to Dst Buffer
* FPrintF.YA : 
*   Y,A = PTR to CStr
*   PULLB = hNode
* ## Out:
*  CC : success
*  CS : error code from Output
*  Specifiers :
*   %a : pull 2 bytes to Print Access right String 'drwxrwxrwx'
*   %b : pull 1 byte to Print BIN 
*   %B : pull 2 bytes to Print BIN
*   %d : pull 1 byte unsigned DEC 0..255
*   %D : pull 2 bytes unsigned DEC 0..65535
*   %u : pull 2 bytes PTR to 4 bytes long unsigned DEC 0..4294967295
*   %e : pull 2 bytes PTR to 6 Bytes Real +1.23456789e+12
*   %f : pull 2 bytes PTR to 6 Bytes Real 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 2 bytes PTR to 4 bytes signed DEC -2147483648..2147483647
*   %n : pull 1 byte to Print low Nibble HEX
*   %N : pull 1 byte to Print high Nibble HEX
*   %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)
*   \\\\ : Print \
*   \% : Print %
*  Modifiers for len and padding : 
*   %d	  : '9'  '12'
*   %2d	  : ' 9' '12'   				
*   %02d  : '09' '12'
*   %11s  : 'ABCDEFGH   '	
*   %011s : 'ABCDEFGH000'
*   %2f	  :	'3.14'
*\--------------------------------------
K.SPrintF.YA	>STYA ZPPtr1
*				>PULLW Printf.Cout.Ptr+1
				
K.FPrintF.YA	>STYA ZPPtr1

K.PrintF.YA		>STYA ZPPtr1
				
				ldy	#0				
				
.1				lda (ZPPtr1),y
				beq .99
				iny
				cmp #'%'
				bne .10
						
				stz PADLEN
				lda #' '
				sta PADCHAR
				
.2				ldx	#PrintFTBL2-PrintFTBL1-1
				lda (ZPPtr1),y
				beq .99
				iny
				
.3				cmp PrintFTBL1,x		do we have a %x command?
				beq .8					yes, jmp to it!
				dex
				bpl	.3					no valid letter...
				
				cmp #'0'				...a 0...mmm... padding char?
				bne .4
				
				ldx PADLEN				PADLEN is not nul, so this 0 is second digit
				bne .5
				
				lda #'0'
				sta PADCHAR				no, this is the first 0, so make it PADCHAR
				bra .2

.4				bcc .99					less than '0'....error				
				cmp #'9'+1
				bcs .99					more than '9' ....error			
				
.5				and #$0F				we have a digit
				pha						save it...
				lda PADLEN				starts PADLEN * 10
				asl 
				asl 					A=times 4
				adc PADLEN				CC by ASL, A=times 5			
				asl						times 10
				sta PADLEN

				pla						get back digit
				adc PADLEN
				sta PADLEN
				bra .2					go get next char...

.8				phy
				txa
				asl
				tax
				jsr PrintFESC
				ply
				bcc .1
				rts

.10				cmp #'\'
				bne .20
				
				ldx	#PrintFTBL2.OUT-PrintFTBL2-1
				lda (ZPPtr1),y
				beq .99
				iny
				
.12				cmp PrintFTBL2,x
				beq .13
				dex
				bpl	.12
				bra .1
				
.13				lda	PrintFTBL2.OUT,x	

.20				jsr	Printf.Cout
				bcc	.1
.99				rts
*--------------------------------------
PrintFESC		jmp	(PrintFJMP,x)
*--------------------------------------
PrintFTBL1		.AS	"abBdDuefhHiILnNsS"
PrintFTBL2		.AS	"befnr\%"
PrintFTBL2.OUT	.HS 08.1B.0C.0A.0D		\b\e\f\n\r
				.DA #'\'				\\
				.DA #'%'				\%
PrintFJMP		.DA PrintF.A
				.DA PrintF.B,PrintF.BB
				.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.N,PrintF.NN
				.DA PrintF.S,PrintF.SS
*--------------------------------------
PrintF.A		>PULLW HEXBUF

				lda HEXBUF+1
				lsr
				lsr
				lsr
				lsr
				tax
				lda TYPES,x
				jsr Printf.Cout
				bcs .9
				
				ldx #0
				
.1				lda #'-'
				lsr HEXBUF
				bcc .2
				lda ACCESS,x
				
.2				jsr Printf.Cout
				bcs .9
				
				inx
				cpx #8
				bne .1
				
.3				lda #'-'
				lsr HEXBUF+1
				bcc .4
				lda ACCESS,x
				
.4				jmp Printf.Cout

.9				rts
*--------------------------------------
PrintF.BB		>PULLA
				pha
				jsr PrintF.B
				pla
				bcc PrintF.B.1
PrintF.BB.RTS	rts
*--------------------------------------
PrintF.B		>PULLA
				
PrintF.B.1		ldx #8
				
.1				asl
				pha
				lda #'0'
				adc #0					add Carry
				jsr Printf.Cout
				pla
				bcs PrintF.BB.RTS
				dex
				bne .1
				rts
*--------------------------------------
PrintF.D		>PULLB HEXBUF
				stz HEXBUF+1
				bra PrintF.DD.1
				
PrintF.DD		>PULLW HEXBUF
PrintF.DD.1		stz HEXBUF+2
				stz HEXBUF+3
				bra PrintF.U.1
				
PrintF.U		>PULLW ZPPtr2
				ldy #3
				
.1				lda (ZPPtr2),y
				sta HEXBUF,y
				dey
				bpl .1

PrintF.U.1		stz SIGN
				jsr HEX2DEC
				jmp PrintDEC
*--------------------------------------				
PrintF.E		>PULLW ZPPtr2
				rts
*--------------------------------------
PrintF.F		>PULLW ZPPtr2
				rts
*--------------------------------------
PrintF.HH		>PULLA
				pha
				jsr PrintF.H
				pla
				bra PrintF.H.1
*--------------------------------------
PrintF.H		>PULLA
PrintF.H.1		pha
				jsr PrintF.NN.1
				pla
				jmp PrintF.N.1
*--------------------------------------
PrintF.I		>PULLB HEXBUF
				eor #$ff				if positive, it becomes neg so branch if....minus!
				clc
				bmi .1
				sec
				inc						2s complement...
				sta HEXBUF

				
.1				stz HEXBUF+1
				bra PrintF.II.1
				
PrintF.II		>PULLW HEXBUF			A=HI
				eor #$ff
				clc
				bmi PrintF.II.1
				sec
				tax
				lda HEXBUF
				eor #$ff
				inc						2s complement...
				sta HEXBUF
				bne .1
				inx
.1				sta HEXBUF
				stx HEXBUF+1

PrintF.II.1		stz HEXBUF+2
				stz HEXBUF+3
				bra PrintF.L.1
				
PrintF.L		>PULLW ZPPtr2
				ldy #3
				
.1				lda (ZPPtr2),y
				sta HEXBUF,y
				dey
				bpl .1

				
PrintF.L.1		ror SIGN
				jsr HEX2DEC
*--------------------------------------
PRINTDEC		lda PADLEN			any Len format ?
				beq .1				no
				
				lda #10
				sec					yes, Print only digits starting at pos 10-padlen
				sbc PADLEN
				
.1				tax					x=0 if no padlen, or x=10-padlen

.2				lda ASCBUF,x		
				cmp #'0'			a zero?
				beq .3
				
				inc PADLEN			found a non zero, Print all digits, even if 0, next time
				ldy #'0'
				sty PADCHAR
				bra .4
				
.3				cpx #9				last digit ?
				beq .4				Print always
				
				ldy PADLEN			no pad to fill, do not Print 0
				beq .6
				
				lda PADCHAR			fill with PADCHAR
				
.4				bit SIGN			a sign to print before digits ?
				bpl .5
				pha					yes, save whatever we have to print....
				lda #'-'
				jsr Printf.Cout
				stz SIGN			reset flag for next char...
				pla
				
.5				jsr Printf.Cout
				bcs .9

.6				inx
				cpx #10
				bne .2
				
				clc
.9				rts
*--------------------------------------
PrintF.N		>PULLA
PrintF.N.1		and #$0F
				bra PrintF.NN.2

PrintF.NN		>PULLA
PrintF.NN.1		lsr
				lsr
				lsr
				lsr
				
PrintF.NN.2		ora #$30
				cmp #$3A
				bcc .1
				adc #6
.1				jmp Printf.Cout
*--------------------------------------
PrintF.S		ldy #$ff				CSTR
				.HS 2C					bit abs
PrintF.SS		ldy #$00				PSTR

				>PULLW ZPPtr2
			
				lda (ZPPtr2)			if CSTR:last char=0, if PSTR:len=0
				beq .8
				
				sty .1+1
			
.1				lda #$ff				Self Modified
				bne .11					CSTR
				
				tya						PSTR
				cmp (ZPPtr2)			len check
				beq .2
				
.11				iny
				
				lda	(ZPPtr2),y
				beq .2
		
				jsr Printf.Cout
				bcs .9

				lda PADLEN
				beq .1
				
				cpy	PADLEN
				bne .1
				clc
				rts
				
.2				lda PADLEN
				beq .8
				
.3				cpy PADLEN
				beq .8
				
				lda PADCHAR				
				jsr Printf.Cout
				bcs .9
				iny
				bne .3
				
.8				clc
.9				rts
*--------------------------------------
Printf.Cout		jmp K.PutChar.A

*Printf.Cout.Ptr	sta $ffff				Self modified
*--------------------------------------
STDIO.PullMLIPath
				>PULLYA
STDIO.SetMLIPathYA
				>STYA .1+1
				
				ldy #0
				
.1				lda $ffff,y				Self Modified
				beq .8
				iny
				sta K.MLI.PATH,y
				cpy #MLI.MAXPATH
				bne .1
				
.8				sty K.MLI.PATH
				>LDYAI K.MLI.PATH
				>STYA K.MLI.PARAMS+1
				rts
*--------------------------------------
STDIO.SetIOBUF	>PUSHWI 1024			get a ProDOS IOBUF
				>PUSHBI S.MEM.F.ALIGN+S.MEM.F.NOMOVE
				jsr K.GetMem
				bcs .9

				>STYA K.MLI.PARAMS+3	Save Ptr to IOBUF for MLIOPEN call
				txa
				ldy #S.NODE.REG.IOBUF
				sta (ZPPtr1),y
.9				rts
*--------------------------------------
STDIO.GetRefNum	jsr K.GetMemPtr.A
				>STYA ZPPtr1				
				ldy #S.NODE.REG.REF
				lda (ZPPtr1),y
				sta K.MLI.PARAMS+1
				rts
*--------------------------------------
STDIO.IOERR		lda #MLI.ERR.IO
				sec
				rts
*--------------------------------------
TYPES			.AS "-dbclssp"
ACCESS			.AS "rwxrwxrwx"
SIGN			.BS 1
PADLEN			.BS 1
PADCHAR			.BS 1
*--------------------------------------
MAN
SAVE /A2OSX.SRC/SYS/KERNEL.S.STDIO
LOAD /A2OSX.SRC/SYS/KERNEL.S
ASM