mirror of
https://github.com/cc65/cc65.git
synced 2024-12-27 00:29:31 +00:00
784 lines
16 KiB
ArmAsm
784 lines
16 KiB
ArmAsm
;
|
|
; _printf: Basic layer for all printf type functions.
|
|
;
|
|
; Ullrich von Bassewitz, 21.10.2000
|
|
;
|
|
|
|
.export __printf
|
|
|
|
.import popax, pushax, pusheax, decsp6, push1, axlong, axulong
|
|
.import _ltoa, _ultoa
|
|
.import _strlower, _strlen
|
|
.importzp sp, ptr1, ptr2, tmp1, regbank, sreg
|
|
|
|
.macpack generic
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; We will store variables into the register bank in the zeropage. Define
|
|
; equates for these variables.
|
|
|
|
ArgList = regbank+0 ; Argument list pointer
|
|
Format = regbank+2 ; Format string
|
|
OutData = regbank+4 ; Function parameters
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Other zero page cells
|
|
|
|
Base = ptr1
|
|
FSave = ptr1
|
|
FCount = ptr2
|
|
|
|
.code
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Get one character from the format string and increment the pointer. Will
|
|
; return zero in Y.
|
|
|
|
GetFormatChar:
|
|
ldy #0
|
|
lda (Format),y
|
|
IncFormatPtr:
|
|
inc Format
|
|
bne @L1
|
|
inc Format+1
|
|
@L1: rts
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Output a pad character: outfunc (d, &padchar, 1)
|
|
|
|
OutputPadChar:
|
|
lda PadChar
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Call the output function with one character in A
|
|
|
|
Output1:
|
|
sta CharArg
|
|
jsr PushOutData
|
|
lda #<CharArg
|
|
ldx #>CharArg
|
|
jsr pushax
|
|
jsr push1
|
|
jmp CallOutFunc ; fout (OutData, &CharArg, 1)
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Decrement the argument list pointer by 2
|
|
|
|
DecArgList2:
|
|
lda ArgList
|
|
sub #2
|
|
sta ArgList
|
|
bcs @L1
|
|
dec ArgList+1
|
|
@L1: rts
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Get an unsigned int or long argument depending on the IsLong flag.
|
|
|
|
GetUnsignedArg:
|
|
lda IsLong ; Check flag
|
|
bne GetLongArg ; Long sets all
|
|
jsr GetIntArg ; Get an integer argument
|
|
jmp axulong ; Convert to unsigned long
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Get an signed int or long argument depending on the IsLong flag.
|
|
|
|
GetSignedArg:
|
|
lda IsLong ; Check flag
|
|
bne GetLongArg ; Long sets all
|
|
jsr GetIntArg ; Get an integer argument
|
|
jmp axlong ; Convert to long
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Get a long argument from the argument list. Returns 0 in Y.
|
|
|
|
GetLongArg:
|
|
jsr GetIntArg ; Get high word
|
|
sta sreg
|
|
stx sreg+1
|
|
|
|
; Run into GetIntArg fetching the low word
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Get an integer argument from the argument list. Returns 0 in Y.
|
|
|
|
GetIntArg:
|
|
jsr DecArgList2
|
|
ldy #1
|
|
lda (ArgList),y
|
|
tax
|
|
dey
|
|
lda (ArgList),y
|
|
rts
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Read an integer from the format string. Will return zero in Y.
|
|
|
|
ReadInt:
|
|
ldy #0
|
|
sty ptr1
|
|
sty ptr1+1 ; Start with zero
|
|
@Loop: lda (Format),y ; Get format string character
|
|
sub #'0' ; Make number from ascii digit
|
|
bcc @L9 ; Jump if done
|
|
cmp #9+1
|
|
bcs @L9 ; Jump if done
|
|
|
|
; Skip the digit character
|
|
|
|
jsr IncFormatPtr
|
|
|
|
; Add the digit to the value we have in ptr1
|
|
|
|
pha ; Save digit value
|
|
lda ptr1
|
|
ldx ptr1+1
|
|
asl ptr1
|
|
rol ptr1+1 ; * 2
|
|
asl ptr1
|
|
rol ptr1+1 ; * 4, assume carry clear
|
|
adc ptr1
|
|
sta ptr1
|
|
txa
|
|
adc ptr1+1
|
|
sta ptr1+1 ; * 5
|
|
asl ptr1
|
|
rol ptr1+1 ; * 10, assume carry clear
|
|
pla
|
|
adc ptr1 ; Add digit value
|
|
sta ptr1
|
|
bcc @Loop
|
|
inc ptr1+1
|
|
bcs @Loop ; Branch always
|
|
|
|
; We're done converting
|
|
|
|
@L9: lda ptr1
|
|
ldx ptr1+1 ; Load result
|
|
rts
|
|
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Put a character into the argument buffer and increment the buffer index
|
|
|
|
PutBuf: ldy BufIdx
|
|
inc BufIdx
|
|
sta Buf,y
|
|
rts
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Get a pointer to the current buffer end and push it onto the stack
|
|
|
|
PushBufPtr:
|
|
lda #<Buf
|
|
ldx #>Buf
|
|
add BufIdx
|
|
bcc @L1
|
|
inx
|
|
@L1: jmp pushax
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Push OutData onto the software stack
|
|
|
|
PushOutData:
|
|
lda OutData
|
|
ldx OutData+1
|
|
jmp pushax
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Output Width pad characters
|
|
;
|
|
|
|
PadLoop:
|
|
jsr OutputPadChar
|
|
OutputPadding:
|
|
inc Width
|
|
bne PadLoop
|
|
inc Width+1
|
|
bne PadLoop
|
|
rts
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Output the argument itself: outfunc (d, str, arglen);
|
|
;
|
|
|
|
OutputArg:
|
|
jsr PushOutData
|
|
lda Str
|
|
ldx Str+1
|
|
jsr pushax
|
|
lda ArgLen
|
|
ldx ArgLen+1
|
|
jsr pushax
|
|
jmp CallOutFunc
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; ltoa: Wrapper for _ltoa that pushes all arguments
|
|
|
|
ltoa: sty Base ; Save base
|
|
jsr pusheax ; Push value
|
|
jsr PushBufPtr ; Push the buffer pointer...
|
|
lda Base ; Restore base
|
|
jmp _ltoa ; ultoa (l, s, base);
|
|
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; ultoa: Wrapper for _ultoa that pushes all arguments
|
|
|
|
ultoa: sty Base ; Save base
|
|
jsr pusheax ; Push value
|
|
jsr PushBufPtr ; Push the buffer pointer...
|
|
lda Base ; Restore base
|
|
jmp _ultoa ; ultoa (l, s, base);
|
|
|
|
|
|
; ----------------------------------------------------------------------------
|
|
;
|
|
|
|
__printf:
|
|
|
|
; Save the register bank variables into the save area
|
|
|
|
pha ; Save low byte of ap
|
|
ldy #5
|
|
Save: lda regbank,y
|
|
sta RegSave,y
|
|
dey
|
|
bpl Save
|
|
|
|
; Get the parameters from the stack
|
|
|
|
pla ; Restore low byte of ap
|
|
sta ArgList ; Argument list pointer
|
|
stx ArgList+1
|
|
|
|
jsr popax ; Format string
|
|
sta Format
|
|
stx Format+1
|
|
|
|
jsr popax ; Output descriptor
|
|
sta OutData
|
|
stx OutData+1
|
|
|
|
; Initialize the output counter in the output descriptor to zero
|
|
|
|
lda #0
|
|
tay
|
|
sta (OutData),y
|
|
iny
|
|
sta (OutData),y
|
|
|
|
; Get the output function from the output descriptor and remember it
|
|
|
|
iny
|
|
lda (OutData),y
|
|
sta CallOutFunc+1
|
|
iny
|
|
lda (OutData),y
|
|
sta CallOutFunc+2
|
|
|
|
; Start parsing the format string
|
|
|
|
MainLoop:
|
|
lda Format ; Remember current format pointer
|
|
sta FSave
|
|
lda Format+1
|
|
sta FSave+1
|
|
|
|
ldy #0 ; Index
|
|
@L1: lda (Format),y ; Get next char
|
|
beq @L2 ; Jump on end of string
|
|
cmp #'%' ; Format spec?
|
|
beq @L2
|
|
iny ; Bump pointer
|
|
bne @L1
|
|
inc Format+1 ; Bump high byte of pointer
|
|
bne @L1 ; Branch always
|
|
|
|
; Found a '%' character or end of string. Update the Format pointer so it is
|
|
; current (points to this character).
|
|
|
|
@L2: tya ; Low byte of offset
|
|
add Format
|
|
sta Format
|
|
bcc @L3
|
|
inc Format+1
|
|
|
|
; Calculate, how many characters must be output. Beware: This number may
|
|
; be zero. A still contains the low byte of the pointer.
|
|
|
|
@L3: sub FSave
|
|
sta FCount
|
|
lda Format+1
|
|
sbc FSave+1
|
|
sta FCount+1
|
|
ora FCount ; Is the result zero?
|
|
beq @L4 ; Jump if yes
|
|
|
|
; Output the characters that we have until now. To make the call to out
|
|
; faster, build the stack frame by hand (don't use pushax)
|
|
|
|
jsr decsp6 ; 3 args
|
|
ldy #5
|
|
lda OutData+1
|
|
sta (sp),y
|
|
dey
|
|
lda OutData
|
|
sta (sp),y
|
|
dey
|
|
lda FSave+1
|
|
sta (sp),y
|
|
dey
|
|
lda FSave
|
|
sta (sp),y
|
|
dey
|
|
lda FCount+1
|
|
sta (sp),y
|
|
dey
|
|
lda FCount
|
|
sta (sp),y
|
|
jsr CallOutFunc ; Call the output function
|
|
|
|
; We're back from out(), or we didn't call it. Check for end of string.
|
|
|
|
@L4: jsr GetFormatChar ; Get one char, zero in Y
|
|
tax ; End of format string reached?
|
|
bne NotDone ; End not reached
|
|
|
|
; End of format string reached. Restore the zeropage registers and return.
|
|
|
|
ldx #5
|
|
Rest: lda RegSave,x
|
|
sta regbank,x
|
|
dex
|
|
bpl Rest
|
|
rts
|
|
|
|
; Still a valid format character. Check for '%' and a '%%' sequence. Output
|
|
; anything that is not a format specifier. On intro, Y is zero.
|
|
|
|
NotDone:
|
|
cmp #'%'
|
|
bne @L1
|
|
lda (Format),y ; Check for "%%"
|
|
cmp #'%'
|
|
bne FormatSpec ; Jump if really a format specifier
|
|
jsr IncFormatPtr ; Skip the second '%'
|
|
@L1: jsr Output1 ; Output the character...
|
|
jmp MainLoop ; ...and continue
|
|
|
|
; We have a real format specifier
|
|
; Format is: %[flags][width][.precision][mod]type
|
|
; Y is zero on entry.
|
|
|
|
FormatSpec:
|
|
|
|
; Initialize the flags
|
|
|
|
lda #0
|
|
ldx #FormatVarSize-1
|
|
@L1: sta FormatVars,x
|
|
dex
|
|
bpl @L1
|
|
|
|
; Start with reading the flags if there are any. X is $FF which is used
|
|
; for "true"
|
|
|
|
ReadFlags:
|
|
lda (Format),y ; Get next char...
|
|
cmp #'-'
|
|
bne @L1
|
|
stx LeftJust
|
|
beq @L4
|
|
|
|
@L1: cmp #'+'
|
|
bne @L2
|
|
stx AddSign
|
|
beq @L4
|
|
|
|
@L2: cmp #' '
|
|
bne @L3
|
|
stx AddBlank
|
|
beq @L4
|
|
|
|
@L3: cmp #'#'
|
|
bne ReadPadding
|
|
stx AltForm
|
|
|
|
@L4: jsr IncFormatPtr
|
|
jmp ReadFlags ; ...and start over
|
|
|
|
; Done with flags, read the pad char. Y is still zero if we come here.
|
|
|
|
ReadPadding:
|
|
ldx #' ' ; PadChar
|
|
cmp #'0'
|
|
bne @L1
|
|
tax ; PadChar is '0'
|
|
jsr IncFormatPtr
|
|
lda (Format),y ; Read current for later
|
|
@L1: stx PadChar
|
|
|
|
; Read the width. Even here, Y is still zero. A contains the current character
|
|
; from the format string
|
|
|
|
ReadWidth:
|
|
cmp #'*'
|
|
bne @L1
|
|
jsr IncFormatPtr
|
|
jsr GetIntArg ; Width is an additional argument
|
|
jmp @L2
|
|
|
|
@L1: jsr ReadInt ; Read integer from format string...
|
|
@L2: sta Width
|
|
stx Width+1 ; ...and remember in Width
|
|
|
|
; Read the precision. Even here, Y is still zero.
|
|
|
|
sty Prec ; Assume Precision is zero
|
|
sty Prec+1
|
|
lda (Format),y ; Load next format string char
|
|
cmp #'.' ; Precision given?
|
|
bne ReadMod ; Branch if no precision given
|
|
|
|
ReadPrec:
|
|
jsr IncFormatPtr ; Skip the '.'
|
|
lda (Format),y
|
|
cmp #'*' ; Variable precision?
|
|
bne @L1
|
|
jsr IncFormatPtr ; Skip the '*'
|
|
jsr GetIntArg ; Get integer argument
|
|
jmp @L2
|
|
|
|
@L1: jsr ReadInt ; Read integer from format string
|
|
@L2: sta Prec
|
|
stx Prec+1
|
|
|
|
; Read the modifiers. Y is still zero.
|
|
|
|
ReadMod:
|
|
lda (Format),y
|
|
cmp #'z' ; size_t - same as unsigned
|
|
beq @L2
|
|
cmp #'h' ; short - same as int
|
|
beq @L2
|
|
cmp #'t' ; ptrdiff_t - same as int
|
|
beq @L2
|
|
cmp #'j' ; intmax_t/uintmax_t - same as long
|
|
beq @L1
|
|
cmp #'L' ; long double
|
|
beq @L1
|
|
cmp #'l' ; long int
|
|
bne DoFormat
|
|
@L1: lda #$FF
|
|
sta IsLong
|
|
@L2: jsr IncFormatPtr
|
|
jmp ReadMod
|
|
|
|
; Initialize the argument buffer pointers. We use a static buffer (ArgBuf) to
|
|
; assemble strings. A zero page index (BufIdx) is used to keep the current
|
|
; write position. A pointer to the buffer (Str) is used to point to the the
|
|
; argument in case we will not use the buffer but a user supplied string.
|
|
; Y is zero when we come here.
|
|
|
|
DoFormat:
|
|
sty BufIdx ; Clear BufIdx
|
|
ldx #<Buf
|
|
stx Str
|
|
ldx #>Buf
|
|
stx Str+1
|
|
|
|
; Skip the current format character, then check it (current char in A)
|
|
|
|
jsr IncFormatPtr
|
|
|
|
; Is it a character?
|
|
|
|
cmp #'c'
|
|
bne CheckInt
|
|
|
|
; It is a character
|
|
|
|
jsr GetIntArg ; Get the argument (promoted to int)
|
|
sta Buf ; Place it as zero terminated string...
|
|
lda #0
|
|
sta Buf+1 ; ...into the buffer
|
|
jmp HaveArg ; Done
|
|
|
|
; Is it an integer?
|
|
|
|
CheckInt:
|
|
cmp #'d'
|
|
beq @L1
|
|
cmp #'i'
|
|
bne CheckCount
|
|
|
|
; It is an integer
|
|
|
|
@L1: ldx #0
|
|
lda AddBlank ; Add a blank for positives?
|
|
beq @L2 ; Jump if no
|
|
ldx #' '
|
|
@L2: lda AddSign ; Add a plus for positives (precedence)?
|
|
beq @L3
|
|
ldx #'+'
|
|
@L3: stx Leader
|
|
|
|
; Integer argument
|
|
|
|
jsr GetSignedArg ; Get argument as a long
|
|
ldy sreg+1 ; Check sign
|
|
bmi @Int1
|
|
ldy Leader
|
|
beq @Int1
|
|
sty Buf
|
|
inc BufIdx
|
|
|
|
@Int1: ldy #10 ; Base
|
|
jsr ltoa ; Push arguments, call _ltoa
|
|
jmp HaveArg
|
|
|
|
; Is it a count pseudo format?
|
|
|
|
CheckCount:
|
|
cmp #'n'
|
|
bne CheckOctal
|
|
|
|
; It is a count pseudo argument
|
|
|
|
jsr GetIntArg
|
|
sta ptr1
|
|
stx ptr1+1 ; Get user supplied pointer
|
|
ldy #0
|
|
lda (OutData),y ; Low byte of OutData->ccount
|
|
sta (ptr1),y
|
|
iny
|
|
lda (OutData),y ; High byte of OutData->ccount
|
|
sta (ptr1),y
|
|
jmp MainLoop ; Done
|
|
|
|
; Check for an octal digit
|
|
|
|
CheckOctal:
|
|
cmp #'o'
|
|
bne CheckPointer
|
|
|
|
; Integer in octal representation
|
|
|
|
jsr GetSignedArg ; Get argument as a long
|
|
ldy AltForm ; Alternative form?
|
|
beq @Oct1 ; Jump if no
|
|
pha ; Save low byte of value
|
|
stx tmp1
|
|
ora tmp1
|
|
ora sreg
|
|
ora sreg+1
|
|
ora Prec
|
|
ora Prec+1 ; Check if value or Prec != 0
|
|
beq @Oct1
|
|
lda #'0'
|
|
jsr PutBuf
|
|
pla ; Restore low byte
|
|
|
|
@Oct1: ldy #8 ; Load base
|
|
jsr ltoa ; Push arguments, call _ltoa
|
|
jmp HaveArg
|
|
|
|
; Check for a pointer specifier (%p)
|
|
|
|
CheckPointer:
|
|
cmp #'p'
|
|
bne CheckString
|
|
|
|
; It's a pointer. Use %#x conversion
|
|
|
|
ldx #0
|
|
stx IsLong ; IsLong = 0;
|
|
inx
|
|
stx AltForm ; AltForm = 1;
|
|
lda #'x'
|
|
bne IsHex ; Branch always
|
|
|
|
; Check for a string specifier (%s)
|
|
|
|
CheckString:
|
|
cmp #'s'
|
|
bne CheckUnsigned
|
|
|
|
; It's a string
|
|
|
|
jsr GetIntArg ; Get 16bit argument
|
|
sta Str
|
|
stx Str+1
|
|
jmp HaveArg
|
|
|
|
; Check for an unsigned integer (%u)
|
|
|
|
CheckUnsigned:
|
|
cmp #'u'
|
|
bne CheckHex
|
|
|
|
; It's an unsigned integer
|
|
|
|
jsr GetUnsignedArg ; Get argument as unsigned long
|
|
ldy #10 ; Load base
|
|
jsr ultoa ; Push arguments, call _ultoa
|
|
jmp HaveArg
|
|
|
|
; Check for a hexadecimal integer (%x)
|
|
|
|
CheckHex:
|
|
cmp #'x'
|
|
beq IsHex
|
|
cmp #'X'
|
|
bne UnknownFormat
|
|
|
|
; Hexadecimal integer
|
|
|
|
IsHex: pha ; Save the format spec
|
|
lda AltForm
|
|
beq @L1
|
|
lda #'0'
|
|
jsr PutBuf
|
|
lda #'X'
|
|
jsr PutBuf
|
|
|
|
@L1: jsr GetUnsignedArg ; Get argument as an unsigned long
|
|
ldy #16 ; Load base
|
|
jsr ultoa ; Push arguments, call _ultoa
|
|
|
|
pla ; Get the format spec
|
|
cmp #'x' ; Lower case?
|
|
bne @L2
|
|
lda Str
|
|
ldx Str+1
|
|
jsr _strlower ; Make characters lower case
|
|
@L2: jmp HaveArg
|
|
|
|
; Unknown format character, skip it
|
|
|
|
UnknownFormat:
|
|
jmp MainLoop
|
|
|
|
; We have the argument, do argument string formatting
|
|
|
|
HaveArg:
|
|
|
|
; ArgLen = strlen (Str);
|
|
|
|
lda Str
|
|
ldx Str+1
|
|
jsr _strlen ; Get length of argument
|
|
sta ArgLen
|
|
stx ArgLen+1
|
|
|
|
; if (Prec && Prec < ArgLen) ArgLen = Prec;
|
|
|
|
lda Prec
|
|
ora Prec+1
|
|
beq @L1
|
|
ldx Prec
|
|
cpx ArgLen
|
|
lda Prec+1
|
|
tay
|
|
sbc ArgLen+1
|
|
bcs @L1
|
|
stx ArgLen
|
|
sty ArgLen+1
|
|
|
|
; if (Width > ArgLen) {
|
|
; Width -= ArgLen; /* padcount */
|
|
; } else {
|
|
; Width = 0;
|
|
; }
|
|
; Since width is used as a counter below, calculate -(width+1)
|
|
|
|
@L1: sec
|
|
lda Width
|
|
sbc ArgLen
|
|
tax
|
|
lda Width+1
|
|
sbc ArgLen+1
|
|
bcs @L2
|
|
lda #0
|
|
tax
|
|
@L2: eor #$FF
|
|
sta Width+1
|
|
txa
|
|
eor #$FF
|
|
sta Width
|
|
|
|
; /* Do padding on the left side if needed */
|
|
; if (!leftjust) {
|
|
; /* argument right justified */
|
|
; while (width) {
|
|
; fout (d, &padchar, 1);
|
|
; --width;
|
|
; }
|
|
; }
|
|
|
|
lda LeftJust
|
|
bne @L3
|
|
jsr OutputPadding
|
|
|
|
; Output the argument itself
|
|
|
|
@L3: jsr OutputArg
|
|
|
|
; /* Output right padding bytes if needed */
|
|
; if (leftjust) {
|
|
; /* argument left justified */
|
|
; while (width) {
|
|
; fout (d, &padchar, 1);
|
|
; --width;
|
|
; }
|
|
; }
|
|
|
|
lda LeftJust
|
|
beq @L4
|
|
jsr OutputPadding
|
|
|
|
; Done, parse next chars from format string
|
|
|
|
@L4: jmp MainLoop
|
|
|
|
|
|
; ----------------------------------------------------------------------------
|
|
; Local data (all static)
|
|
|
|
.bss
|
|
|
|
; Save area for the zero page registers
|
|
RegSave: .res 6
|
|
|
|
; One character argument for OutFunc
|
|
CharArg: .byte 0
|
|
|
|
; Format variables
|
|
FormatVars:
|
|
LeftJust: .byte 0
|
|
AddSign: .byte 0
|
|
AddBlank: .byte 0
|
|
AltForm: .byte 0
|
|
PadChar: .byte 0
|
|
Width: .word 0
|
|
Prec: .word 0
|
|
IsLong: .byte 0
|
|
Leader: .byte 0
|
|
BufIdx: .byte 0 ; Argument string pointer
|
|
FormatVarSize = * - FormatVars
|
|
|
|
; Argument buffer and pointer
|
|
Buf: .res 20
|
|
Str: .word 0
|
|
ArgLen: .res 2
|
|
|
|
.data
|
|
|
|
; Stuff from OutData. Is used as a vector and must be aligned
|
|
CallOutFunc: jmp $0000
|
|
|
|
|
|
|