;writeDecimal<CC> Rx, buffer, buffer_size
;output 123456
MACRO writeDecimal$cc n:R, buffer:I, size:I
{
 STMFD   R13!, {R0-R2}
 ADR     R1, buffer
 #if n <> 0
   MOV     R0, n
 #endif
 MOV     R2, #size
 SWI     XOS_BinaryToDecimal		;PRM1-468
 MOV     R0, R1
 MOV     R1, R2
 SWI$cc  XOS_WriteN			;PRM1-540
 LDMFD   R13!, {R0-R2}
}


;our_writeDecimal<CC> Rx, buffer, buffer_size		PRESERVES FLAGS
;output 123456
MACRO our_writeDecimal$cc n:R, buffer:I, size:I
{
 STM$cc#FD R13!, {R0-R1, R4, R14}
 #if n <> 0
   MOV$cc    R0, n
 #endif
 MOV$cc    R1, #size
 ADR$cc    R4, buffer + size + 1
 BL$cc     debug_writeDecimal
 LDM$cc#FD R13!, {R0-R1, R4, R14}
}


;writeS<CC> string
MACRO writeS$cc s:S
{
 #if LEN(s) == 0
   SWI$cc  XOS_NewLine
 #endif
 #if LEN(s) == 1
   SWI$cc  XOS_WriteI + ASC(s)
 #endif
 #if LEN(s) > 1
   ADD$cc  PC, PC, #0
   ._start
   ADD     PC, PC, #_end - _start - 8
   SWI     XOS_WriteS
   DCB     s, 0
   ALIGN
   ._end
 #endif
}


;our_writeS<CC> string					PRESERVES FLAGS
;output - string or CR/LF if ""
MACRO our_writeS$cc s:S
{
 #if LEN(s) == 0
   STR$cc    R14, [R13, #-4]!
   BL$cc     our_XOS_NewLine
   LDR$cc    R14, [R13], #4
 #endif
 #if LEN(s) == 1
   STM$cc#FD R13!, {R0, R14}
   MOV$cc    R0, #ASC(s)
   BL$cc     our_XOS_WriteC
   LDM$cc#FD R13!, {R0, R14}
 #endif
 #if LEN(s) > 1
   ADD$cc    PC, PC, #0
   ._start
   ADD       PC, PC, #_end - _start - 8
   STR       R14, [R13, #-4]!
   BL        our_XOS_WriteS
   DCB       s, 0
   ALIGN
   LDR       R14, [R13], #4
   ._end
 #endif
}




;our_writeN<CC> addr, length				PRESERVES FLAGS
;output - string
MACRO our_writeN$cc addr:R, len:R
{
   ADD$cc    PC, PC, #0
   ._start
   ADD       PC, PC, #_end - _start - 8
   STMFD     R13!, {R1-R2, R14}
   #if addr <> 1
     MOV       R1, addr
   #endif
   #if len <> 2
     MOV       R2, len
   #endif
   BL        our_XOS_WriteN
   LDMFD     R13!, {R1-R2, R14}
   ._end
}




;writeB<CC> Rx						CORRUPTS R1,R2
;output FF
MACRO writeB$cc n:R
{
 #if n <> 1
   MOV$cc  R1, n
 #endif

 MOV$cc  R2, #4
 BL$cc   outputHexByte
}


;our_writeB<CC> Rx					PRESERVES FLAGS
;output FF
MACRO our_writeB$cc n:R
{
 STM$cc#FD R13!, {R1-R2}
 #if n <> 1
   MOV$cc    R1, n
 #endif

 MOV$cc    R2, #4
 BL$cc     debug_outputHexByte
 LDM$cc#FD R13!, {R1-R2}
}




;writeD<CC> Rx						CORRUPTS R1
;output FFFFFFFF
MACRO writeD$cc n:R
{
 #if n <> 1
   MOV$cc  R1, n
 #endif

 BL$cc   outputHex
}


;our_writeD<CC> Rx					PRESERVES FLAGS
;output FFFFFFFF
MACRO our_writeD$cc n:R
{
 #if n <> 1
   STR$cc  R1, [R13, #-4]!
   MOV$cc  R1, n
 #endif

 BL$cc   debug_outputHex

 #if n <> 1
   LDR$cc  R1, [R13], #4
 #endif
}




;writeDT<CC> Rx
;output Double with leading 0's removed
MACRO writeDT$cc n:R
{
 #if n <> 1
   STR     R1, [R13, #-4]!
   MOV$cc  R1, n
 #endif

 BL$cc   outputHexTruncated

 #if n <> 1
   LDR     R1, [R13], #4
 #endif
}


;our_writeDT<CC> Rx					PRESERVES FLAGS
;output Double with leading 0's removed
MACRO our_writeDT$cc n:R
{
 #if n <> 1
   STR$cc  R1, [R13, #-4]!
   MOV$cc  R1, n
 #endif

 BL$cc   debug_outputHexTruncated

 #if n <> 1
   LDR$cc  R1, [R13], #4
 #endif
}




;writeD_n<CC> Rx, N
;output N chars of Rx
MACRO writeD_n$cc n:R s:I
{
 STMFD     R13!, {R1-R2, R14}
 #if n <> 1
   MOV       R1, n
 #endif
 MOV       R2, #(s << 2) - 4
 BL$cc     outputHexByte
 LDMFD     R13!, {R1-R2, R14}
}


;our_writeD_n<CC> Rx, N					PRESERVES FLAGS
;output N chars of Rx
MACRO our_writeD_n$cc n:R s:I
{
 STM$cc#FD R13!, {R1-R2, R14}
 #if n <> 1
   MOV$cc     R1, n
 #endif
 MOV$cc    R2, #(s << 2) - 4
 BL$cc     debug_outputHexByte
 LDM$cc#FD R13!, {R1-R2, R14}
}
