;writeDecimal<CC> Rx, buffer, buffer_size
;output 123456
MACRO writeDecimal$cc n:R, buffer:I, size:I		;CORRUPTS FLAGS
{
 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
;output 123456
MACRO our_writeDecimal$cc n:R, buffer:I, size:I		;PRESERVES FLAGS
{
 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					;CORRUPTS FLAGS
{
 #if LEN(s) == 0
   SWI$cc  XOS_NewLine
 #endif
 #if LEN(s) == 1
   SWI$cc  XOS_WriteI + ASC(s)
 #endif
 #if LEN(s) > 1
   #if LEN(s) > 1 AND cc<>&E
     ADD$cc  PC, PC, #0
     ._start
     ADD     PC, PC, #_end - _start - 8
   #endif
   SWI     XOS_WriteS
   DCB     s, 0
   ALIGN
   ._end
 #endif
}


;our_writeS<CC> string
;output - string or CR/LF if ""
MACRO our_writeS$cc s:S					;PRESERVES FLAGS
{
 #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
   #if LEN(s) > 1 AND cc<>&E
     ADD$cc  PC, PC, #0
     ._start
     ADD     PC, PC, #_end - _start - 8
   #endif
   STR     R14, [R13, #-4]!
   BL      our_XOS_WriteS
   DCB     s, 0
   ALIGN
   LDR     R14, [R13], #4
   ._end
 #endif
}




;our_writeN<CC> addr, length
;output - string
MACRO our_writeN$cc addr:R, len:R			;PRESERVES FLAGS
{
   #if cc<>&E
     ADD$cc  PC, PC, #0
     ._start
     ADD     PC, PC, #_end - _start - 8
   #endif
   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
;output FF
MACRO writeB$cc n:R					;CORRUPTS FLAGS, R1,R2
{
 #if n <> 1
   MOV$cc  R1, n
 #endif

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


;our_writeB<CC> Rx
;output FF
MACRO our_writeB$cc n:R					;PRESERVES FLAGS
{
 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
;output FFFFFFFF
MACRO writeD$cc n:R					;CORRUPTS FLAGS, R1
{
 #if n <> 1
   MOV$cc  R1, n
 #endif

 BL$cc   outputHex
}


;our_writeD<CC> Rx
;output FFFFFFFF
MACRO our_writeD$cc n:R					;PRESERVES FLAGS
{
 #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					;CORRUPTS FLAGS
{
 #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
;output Double with leading 0's removed
MACRO our_writeDT$cc n:R				;PRESERVES FLAGS
{
 #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				;CORRUPTS FLAGS
{
 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
;output N chars of Rx
MACRO our_writeD_n$cc n:R s:I				;PRESERVES FLAGS
{
 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}
}
