NEW
PREFIX /A2OSX.BUILD
AUTO 4,1
*/--------------------------------------
* # FPutC.AY
* Print A (char) to Node
* ## 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.E.VOLFULL
				.HS 2C					bit abs			
.99				lda #MLI.E.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 Node
* ## 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+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

				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.FI.A.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.FI.ST.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 .8+1			
				
*				ldy #S.NODE.T			Done by GetMem0
*				lda #S.NODE.T.REG
*				sta (ZPPtr1),y
				
				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
				bra .21
				
.11				>MLICALL MLIGETEOF
				bcs .98
				
				>MLICALL MLISETMARK
.21				bcs .98
				
.20				lda K.FOpen.MODE
				and #SYS.FOpen.T		Text Mode ?
				beq .8
				
				lda #$FF
				sta K.MLI.PARAMS+2
				lda #$0D
				sta K.MLI.PARAMS+3
				>MLICALL MLINEWLINE				
				
.8				lda #$ff				Self Modified
				clc
				rts						CC

.98				pha						save MLI error
				lda .8+1
				jsr K.FClose.A
				pla						get back MLI error
				sec
				rts
*--------------------------------------
K.FOpen.MODE	.BS 1
K.FOpen.TYPE	.BS 1
K.FOpen.AUXTYPE	.BS 2
*/--------------------------------------
* # FClose.A
* Close a file
* ## In :
*  A = hFILE
* ## Out :
*\--------------------------------------
K.FClose.A		jsr PFT.CheckNodeA
				sta K.FClose.A.8+1
				
				jsr K.GetMemPtr.A
				>STYA ZPPtr1

				ldy #S.NODE.T
				lda (ZPPtr1),y
				asl
				tax
				jmp (.1,x)
				
.1				.DA K.FClose.A.REG
				.DA K.FClose.A.DIR
				.DA K.FClose.A.CDEV
				
K.FClose.A.REG
K.FClose.A.DIR	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.8
				
				jsr K.FreeMem.A
				bra K.FClose.A.8
				
K.FClose.A.CDEV	ldy #S.NODE.DEV.ID
				lda (ZPPtr1),y
				jsr K.DevClose.A
				bcs K.FClose.A.9
				
K.FClose.A.8	lda #$ff				Self Modified
				jmp K.FreeMem.A
K.FClose.A.9	rts
*/--------------------------------------
* # FRead.A
* Read ONE byte (A) from file (Y)
* ## In :
*  A = hFILE
* ## Out :
*  A = Byte Read
*\--------------------------------------
K.FRead.A		jsr PFT.CheckNodeA
				ldx #MLIREAD
				bra K.FReadWrite.0				
*/--------------------------------------
* # FWrite.AY
* Write ONE byte (A) To file (Y)
* ## 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 GP.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
* Write bytes to file
* ## 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 GP.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
* Set the file-position indicator for hFILE
* ## In:
*  PUSHW = Ptr to Offset (DWORD)
*  PUSHB = From
*  PUSHB = hFILE
*\-------------------------------------
K.FSeek			jsr PFT.CheckNodeSTK
				>PULLA
				jsr STDIO.GetRefNum
				>PULLA					FROM
				tax
				>PULLW ZPPtr1
				cpx #SYS.FSeek.END+1
				bcs .98
				txa
				asl
				tax
				
				jmp (.1,x)
				
.1				.DA .10
				.DA .20
				.DA .30			
* K.FSeek.SET
.10				stz K.MLI.PARAMS+2
				stz K.MLI.PARAMS+3
				stz K.MLI.PARAMS+4
				bra .8

* K.FSeek.CUR
.20				>MLICALL MLIGETMARK
				bcc .8
				rts

* K.FSeek.END
.30				>MLICALL MLIGETEOF
				bcs .9

.8				ldy #0
				ldx #3					3 bytes, 24 bits!!!
				
				clc
				
.81				lda K.MLI.PARAMS+2,y
				adc (ZPPtr1),y
				sta K.MLI.PARAMS+2,y

				iny
				dex
				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 #K.E.SYN
				.HS 2C					bit abs
.99				lda #K.E.FTB
				sec
				rts
*/--------------------------------------
* # FEOF.A
* Test the end-of-file indicator for hFILE
* ## In:
*  A = hFILE
* ## Out:
*  CC : 
*   A=0 EOF
*   A !=0 NOT EOF
*  CS :
*\--------------------------------------
K.FEOF.A		jsr PFT.CheckNodeA
				jsr STDIO.GetRefNum

				>MLICALL MLIGETMARK
				bcs .9
				
				ldy #2
				
.1				lda K.MLI.PARAMS+2,y
				sta K.FEOF.A.MARK,y
				dey
				bpl .1

				>MLICALL MLIGETEOF
				bcs .9

				ldy #2
				
.2				lda K.MLI.PARAMS+2,y
				eor K.FEOF.A.MARK,y
				bne .8
				dey
				bpl .2
				
.8				clc
.9				rts

K.FEOF.A.MARK	.BS 3
*/--------------------------------------
* # FTell
* Return the current value of the file-position indicator
* ## In:
*  PUSHW = Ptr to Offset (DWORD)
*  PUSHB = hFILE
* ## Out:
*   Offset = Offset
*\--------------------------------------
K.FTell			jsr PFT.CheckNodeSTK
				>PULLA
				jsr STDIO.GetRefNum
				>PULLW ZPPtr1
				>MLICALL MLIGETMARK
				bcs .9
				
				ldy #3
				
				lda #0
				sta (ZPPtr1),y
				
				dey

.1				lda K.MLI.PARAMS+2,y
				sta (ZPPtr1),y
				dey
				bpl .1
				
.9				rts
*/--------------------------------------
* # 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
*--------------------------------------
K.PrintF.PadL	.BS 1
K.PrintF.PadC	.BS 1
*--------------------------------------
*HEXBUF			.BS 4
*BCDBUF			.BS 5					5, enough to handle 10 digits (32bits)
HEXBUF			.EQ FAC
BCDBUF			.EQ ARG
*/--------------------------------------
* # SScanF.YA
* Scan a C-String (in progress)
* ## In:
*  PUSHW PTR to target var
*  ...
*  PUSHW PTR pattern (ex: "%d.%d.%d.%d")
*   %i : short int
*   %d : byte
*   %I : int
*   %D : word
*	%L : long int
*	%U : dword
*  Y,A = PTR to String to scan (ex: "192.168.1.5") 
* ## Out:
*\--------------------------------------
K.SScanF.YA		>STYA ZPPtr2			String to Scan
				>PULLW ZPPtr1			Pattern
				
.1				lda (ZPPtr1)			End Of Pattern?
				beq .8

				inc ZPPtr1
				bne .11
				inc ZPPtr1+1

.11				cmp #'%' 				Escape?
				beq .2
				
				cmp (ZPPtr2)			Same char in string?
				bne .9
				
				inc ZPPtr2
				bne .1
				inc ZPPtr2+1
				bra .1
				
.2				lda (ZPPtr1)			Get specifier after %
				beq .9					unexpected End of pattern after "%" ?

				inc ZPPtr1
				bne .21
				inc ZPPtr1+1

.21				ldx #K.SScanFJMP-K.SScanFTBL-2
				
.3				cmp K.SScanFTBL,x
				beq .4
				dex
				dex
				bpl .3
				
.9				lda #MLI.E.EOF
				sec
				rts
				
.4				jsr .5
				
				tya
				clc
				adc ZPPtr2
				sta ZPPtr2
				bcc .1
				inc ZPPtr2+1

				bra .1
				
.8				clc
				rts
*--------------------------------------
.5				>PULLW ZPPtr3			get VAR Ptr
				
				lda K.SScanFTBL+1,x		Get VAR Byte count
				jmp (K.SScanFJMP,x)
*--------------------------------------
K.SScanFTBL		.DA #'i,#1,#'d,#1,#'I,#2,#'D,#2,#'l,#4,#'u,#4
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
*--------------------------------------
K.SScanF.I		
K.SScanF.D		
K.SScanF.II
K.SScanF.DD
K.SScanF.L
K.SScanF.U		pha						Save Byte count

				jsr STDLIB.Dec2Hex
				
				pla
				phy
				tay
				
.1				lda STDLIB.32-1,y
				dey
				sta (ZPPtr3),y
				bpl .1
				
				ply

.9				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 :
*   %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 5 Bytes float (-)1.23456789e+12
*   %f : pull 2 bytes PTR to 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 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 STDIO.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 K.PrintF.PadL
				lda #' '
				sta K.PrintF.PadC
				
.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 K.PrintF.PadL				K.PrintF.PadL is not nul, so this 0 is second digit
				bne .5
				
*				lda #'0'
				sta K.PrintF.PadC				no, this is the first 0, so make it K.PrintF.PadC
				bra .2

.4				jsr MEM.IsDigit
				bcs .99		
				
.5				and #$0F				we have a digit
				pha						save it...
				lda K.PrintF.PadL				starts K.PrintF.PadL * 10
				asl 
				asl 					A=times 4
				adc K.PrintF.PadL				CC by ASL, A=times 5			
				asl						times 10
				sta K.PrintF.PadL

				pla						get back digit
				adc K.PrintF.PadL
				sta K.PrintF.PadL
				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	STDIO.COut
				bcc	.1
.99				rts
*--------------------------------------
PrintFESC		jmp	(PrintFJMP,x)
*--------------------------------------
PrintFTBL1		.AS	"bBdDuefhHiILnNsS"
PrintFTBL2		.AS	"befnr\%"
PrintFTBL2.OUT	.HS 08.1B.0C.0A.0D		\b\e\f\n\r
				.DA #'\'				\\
				.DA #'%'				\%
PrintFJMP		.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.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 STDIO.COut
				pla
				bcs PrintF.BB.RTS
				dex
				bne .1
				rts
*--------------------------------------
PrintF.I		sec						signed short
				.HS 90					BCC
PrintF.D		clc						unsigned short (BYTE)
				ldx #0					one byte
				
				>PULLB HEXBUF
				stz HEXBUF+1
				bra PrintF.DD.1
				
PrintF.II		sec						signed int
				.HS 90					BCC
PrintF.DD		clc						unsigned int (WORD)
				ldx #1					two bytes
				
				>PULLW HEXBUF

PrintF.DD.1		stz HEXBUF+2
				stz HEXBUF+3
				bra PrintF.U.1

PrintF.L		sec						signed long
				.HS 90					BCC
PrintF.U		clc						unsigned long (DWORD)
				ldx #3					4 bytes
				
				>PULLW ZPPtr2			

				ldy #3
				
.1				lda (ZPPtr2),y
				sta HEXBUF,y
				dey
				bpl .1
				
PrintF.U.1		bcc PrintF.Hex2Dec		unsigned, nothing to check
		
				lda HEXBUF,x			get sign
				bpl PrintF.Hex2Dec
				
*				sec

				ldy #0
				
.1				lda HEXBUF,y			two's complement of X bytes
				eor #$ff
				adc #0
				sta HEXBUF,y
				iny
				dex
				bpl .1
				
				sec						tell to print a "-" sign....
*--------------------------------------
* Convert HEXBUF to ASCBUF decimal padded with 0
*--------------------------------------
PrintF.Hex2Dec	ror	.31+1

				ldx #4

.1				stz BCDBUF,x	Clear all 5 bytes
				dex
				bpl .1
				
				sed				switch to BCD mode

				ldx #32			let's roll 32 bits
				
.2				asl HEXBUF
				rol HEXBUF+1
				rol HEXBUF+2
				rol HEXBUF+3

				ldy #4
				
.3				lda BCDBUF,y
				adc BCDBUF,y
				sta BCDBUF,y
				dey
				bpl .3
				
				dex
				bne .2
				
				cld

.31				bit #$ff				SELF MODIFIED -sign to print before digits ?
				bpl .9
				lda #'-'
				jsr STDIO.COut
				
.9				lda K.PrintF.PadL				any Len format ?
				beq .4					no
				
				lda #10
				sec						yes, Print only digits starting at pos 10-K.PrintF.PadL
				sbc K.PrintF.PadL
				
.4				tax						x=0 if no K.PrintF.PadL, or x=10-K.PrintF.PadL

.5				txa						X range 0 to 9
				lsr						CS if lo nibble (1,3,5,7,9)
				tay
				
				lda BCDBUF,y
				
				bcs .6
				
				lsr
				lsr
				lsr
				lsr
				
.6				and #$0F
				ora #$30
				cmp #$30

				beq .7				a zero?
				
				inc K.PrintF.PadL			found a non zero, Print all digits, even if 0, next time
				ldy #'0'
				sty K.PrintF.PadC
				bra .8
				
.7				cpx #9				last digit ?
				beq .8				Print always
				
				ldy K.PrintF.PadL			no pad to fill, do not Print 0
				beq .10
				
				lda K.PrintF.PadC			fill with K.PrintF.PadC
				
.8				jsr STDIO.COut
				bcs .99

.10				inx
				cpx #10
				bne .5
				
				clc
.99				rts
*--------------------------------------	
*       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
				>PULLW INDEX
				>ROMCALL SETFAC
				
				ldy #3					In order not to trash A2osX.SaveSM,A2osX.SaveSX
				>ROMCALL FOUT
				
				ldx #0
				
.2				lda $102,x
				beq .8
				
				phx
				jsr STDIO.COut
				plx
				inx
				bne .2
				
.8				clc
			
.9				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
				bra PrintF.N.1
*--------------------------------------
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 STDIO.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 STDIO.COut
				bcs .9

				lda K.PrintF.PadL
				beq .1
				
				cpy	K.PrintF.PadL
				bne .1
				clc
				rts
				
.2				lda K.PrintF.PadL
				beq .8
				
.3				cpy K.PrintF.PadL
				beq .8
				
				lda K.PrintF.PadC				
				jsr STDIO.COut
				bcs .9
				iny
				bne .3
				
.8				clc
.9				rts
*--------------------------------------
STDIO.COut		jmp K.PutChar.A

*STDIO.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	>LDYAI 1024				get a ProDOS IOBUF
				ldx #S.MEM.F.ALIGN+S.MEM.F.NOMOVE
				jsr MEM.GetMem.YAX
				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.E.IO
				sec
				rts
*--------------------------------------
MAN
SAVE /A2OSX.SRC/SYS/KERNEL.S.STDIO
LOAD /A2OSX.SRC/SYS/KERNEL.S
ASM