the10thwiz/cc65
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

merge master

Browse Source
This commit is contained in:
mrdudz
2025-06-17 22:51:25 +02:00
parent 7ea6575ca8 3486cd7830
commit f45d25cfaf
29 changed files with 1391 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
asminc/apple2.inc
View File

@@ -24,6 +24,8 @@ DOSWARM := $03D0 ; DOS warmstart vector
BRKVec := $03F0 ; Break vector
SOFTEV := $03F2 ; Vector for warm start
PWREDUP := $03F4 ; This must be = EOR #$A5 of SOFTEV+1
ROM_RST := $FFFC ; 6502 reset vector
ROM_IRQ := $FFFE ; 6502 IRQ vector
;-----------------------------------------------------------------------------
; 80 column firmware

56
cfg/plus4-hires.cfg Normal file
View File

@@ -0,0 +1,56 @@
# Linker configuration that allows for a hi-res bitmap at $C000-$DF3F, but
# puts the stack (and a "HIBSS" segment) in the remaining RAM at $DF40-$FD00.
FEATURES {
STARTADDRESS: default = $1001;
}
SYMBOLS {
__LOADADDR__: type = import;
__EXEHDR__: type = import;
__STACKSIZE__: type = weak, value = $0800; # 2k stack
__HIMEM__: type = weak, value = $FD00;
}
MEMORY {
# Reserve 8000 bytes at $C000 for 320x200 bitmap
RESERVED: file = "", define = yes, start = $C000, size = 8000;
ZP: file = "", define = yes, start = $0002, size = $001A;
LOADADDR: file = %O, start = %S - 2, size = $0002;
HEADER: file = %O, define = yes, start = %S, size = $000D;
MAIN: file = %O, define = yes, start = __HEADER_LAST__, size = __RESERVED_START__ - __MAIN_START__;
# Space between bitmap and top of memory
HIRAM: file = "", define = yes, start = __RESERVED_LAST__, size = __HIMEM__ - __HIRAM_START__ - __STACKSIZE__;
}
SEGMENTS {
ZEROPAGE: load = ZP, type = zp;
LOADADDR: load = LOADADDR, type = ro;
EXEHDR: load = HEADER, type = ro;
STARTUP: load = MAIN, type = ro;
LOWCODE: load = MAIN, type = ro, optional = yes;
CODE: load = MAIN, type = ro;
ONCE: load = MAIN, type = ro, optional = yes;
RODATA: load = MAIN, type = ro;
DATA: load = MAIN, type = rw;
INIT: load = MAIN, type = bss;
BSS: load = MAIN, type = bss, define = yes;
# Allow data between bitmap and top of memory to be used as a second BSS
# space. Define symbols for it so that it can be supplied to _heapadd().
HIBSS: load = HIRAM, type = bss, optional = yes, define = yes;
}
FEATURES {
CONDES: type = constructor,
label = __CONSTRUCTOR_TABLE__,
count = __CONSTRUCTOR_COUNT__,
segment = ONCE;
CONDES: type = destructor,
label = __DESTRUCTOR_TABLE__,
count = __DESTRUCTOR_COUNT__,
segment = RODATA;
CONDES: type = interruptor,
label = __INTERRUPTOR_TABLE__,
count = __INTERRUPTOR_COUNT__,
segment = RODATA,
import = __CALLIRQ__;
}

2
doc/apple2.sgml
View File

@@ -87,7 +87,7 @@ several useful settings:
exit then a plain vanilla ProDOS 8 doesn't make use of the Language Card bank
2 at all.
<tag>LC address: &dollar;D000, LC size: &dollar;3000</tag>
<tag>LC address: &dollar;D000, LC size: &dollar;2FFC</tag>
For plain vanilla DOS 3.3 which doesn't make use of the Language Card at all.
</descrip><p>

2
doc/apple2enh.sgml
View File

@@ -88,7 +88,7 @@ several useful settings:
exit then a plain vanilla ProDOS 8 doesn't make use of the Language Card bank
2 at all.
<tag>LC address: &dollar;D000, LC size: &dollar;3000</tag>
<tag>LC address: &dollar;D000, LC size: &dollar;2FFC</tag>
For plain vanilla DOS 3.3 which doesn't make use of the Language Card at all.
</descrip><p>

24
doc/cc65.sgml
View File

@@ -63,6 +63,8 @@ Short options:
-V Print the compiler version number
-W [-+]warning[,...] Control warnings ('-' disables, '+' enables)
-d Debug mode
-dM Output all user macros (needs -E)
-dP Output all predefined macros (needs -E)
-g Add debug info to object file
-h Help (this text)
-j Default characters are signed
@@ -199,6 +201,28 @@ Here is a description of all the command line options:
Enables debug mode, for debugging the behavior of cc65.
<label id="option-dM">
<tag><tt>-dM</tt></tag>
When used with -E, will output <tt>#define</tt> directives for all the user
macros defined during execution of the preprocessor. This does not include
macros defined by the compiler.
Note: Can be combined with <tt/<ref id="option-dP" name="-dP">/ by using
<tt/-dMP/.
<label id="option-dP">
<tag><tt>-dP</tt></tag>
When used with -E, will output <tt>#define</tt> directives for all the macros
defined by the compiler itself. This does not include any user defined macros.
Note: Can be combined with <tt/<ref id="option-dM" name="-dM">/ by using
<tt/-dMP/.
<tag><tt>--debug-tables name</tt></tag>
Writes symbol table information to a file, which includes details on structs, unions

20
doc/plus4.sgml
View File

@@ -165,8 +165,26 @@ The names in the parentheses denote the symbols to be used for static linking of
<sect1>Graphics drivers<p>
No graphics drivers are currently available for the Plus/4.
<descrip>
<tag><tt/ted-hi.tgi (ted_hi_tgi)/</tag>
This driver features a resolution of 320*200 with two colors and an
adjustable palette (that means that the two colors can be chosen out of a
palette of the 121 TED colors).
Note that the text-mode character matrix and color data are destroyed by this
driver. The driver calls the Kernal <tt/CLRSCR/ routine to return the text
screen to a usable (if empty) state on <tt/tgi_done()/.
This driver places the bitmap at &dollar;C000-&dollar;E000. Programs using
this driver must either be linked with the option <tt/-D
__HIMEM__=&dollar;C000/, or use the <tt/plus4-hires.cfg/ linker configuration.
The <tt/plus4-hires.cfg/ is preferable, as it allows the stack to remain at
&dollar;FCFF, and exposes the remaining high memory from the end of the bitmap
to the stack top as a <tt/HIBSS/ segment that can be used by the programmer,
or given to <tt/_heapadd()/ (using the symbols <tt/_HIBSS_START__/ and
<tt/_HIBSS_SIZE__/).
</descrip><p>
<sect1>Extended memory drivers<p>

18
include/cbm264.h
View File

@@ -110,7 +110,23 @@
#define COLOR_LIGHTBLUE (BCOLOR_LIGHTBLUE | CATTR_LUMA7)
#define COLOR_GRAY3 (BCOLOR_WHITE | CATTR_LUMA5)
/* TGI color defines */
#define TGI_COLOR_BLACK (BCOLOR_BLACK)
#define TGI_COLOR_WHITE (BCOLOR_WHITE | CATTR_LUMA7)
#define TGI_COLOR_RED (BCOLOR_RED | CATTR_LUMA4)
#define TGI_COLOR_CYAN (BCOLOR_CYAN | CATTR_LUMA7)
#define TGI_COLOR_PURPLE (BCOLOR_LIGHTVIOLET | CATTR_LUMA7)
#define TGI_COLOR_GREEN (BCOLOR_GREEN | CATTR_LUMA7)
#define TGI_COLOR_BLUE (BCOLOR_BLUE | CATTR_LUMA7)
#define TGI_COLOR_YELLOW (BCOLOR_YELLOW | CATTR_LUMA7)
#define TGI_COLOR_ORANGE (BCOLOR_ORANGE | CATTR_LUMA7)
#define TGI_COLOR_BROWN (BCOLOR_BROWN | CATTR_LUMA7)
#define TGI_COLOR_LIGHTRED (BCOLOR_RED | CATTR_LUMA7)
#define TGI_COLOR_GRAY1 (BCOLOR_WHITE | CATTR_LUMA1)
#define TGI_COLOR_GRAY2 (BCOLOR_WHITE | CATTR_LUMA3)
#define TGI_COLOR_LIGHTGREEN (BCOLOR_LIGHTGREEN | CATTR_LUMA7)
#define TGI_COLOR_LIGHTBLUE (BCOLOR_LIGHTBLUE | CATTR_LUMA7)
#define TGI_COLOR_GRAY3 (BCOLOR_WHITE | CATTR_LUMA5)
/* Masks for joy_read */
#define JOY_UP_MASK 0x01

3
include/plus4.h
View File

@@ -57,8 +57,7 @@
/* The addresses of the static drivers */
extern void plus4_stdjoy_joy[]; /* Referred to by joy_static_stddrv[] */
extern void plus4_stdser_ser[]; /* Referred to by ser_static_stddrv[] */
extern void ted_hi_tgi[];
/* End of plus4.h */
#endif

24
libsrc/apple2/crt0.s
View File

@@ -58,6 +58,7 @@ init: ldx #zpspace-1
; Check for ProDOS.
ldy $BF00 ; MLI call entry point
cpy #$4C ; Is MLI present? (JMP opcode)
php ; Remember whether we're running ProDOS
bne basic
; Check the ProDOS system bit map.
@@ -99,7 +100,20 @@ basic: lda HIMEM
bit $C081
bit $C081
; Set the source start address.
plp ; Are we running ProDOS?
beq :+ ; Yes, no need to patch vectors
lda #<reset_6502
ldx #>reset_6502
sta ROM_RST
stx ROM_RST+1
lda #<irq_6502
ldx #>irq_6502
sta ROM_IRQ
stx ROM_IRQ+1
: ; Set the source start address.
; Aka __LC_LOAD__ iff segment LC exists.
lda #<(__ONCE_LOAD__ + __ONCE_SIZE__)
ldy #>(__ONCE_LOAD__ + __ONCE_SIZE__)
@@ -144,6 +158,14 @@ quit: jsr $BF00 ; MLI call entry point
.byte $65 ; Quit
.word q_param
reset_6502: ; Used with DOS3.3 programs
bit $C082 ; Switch in ROM
jmp (ROM_RST) ; Jump to ROM's RESET vector
irq_6502: ; Used with DOS3.3 programs
bit $C082 ; Switch in ROM
jmp (ROM_IRQ) ; Jump to ROM's IRQ/BRK vector
; ------------------------------------------------------------------------
.rodata

5
libsrc/plus4/cgetc.s
View File

@@ -18,11 +18,16 @@ _cgetc: lda KEY_COUNT ; Get number of characters
ora FKEY_COUNT ; Or with number of function key chars
bne L2 ; Jump if there are already chars waiting
lda #%00100000
bit $FF06
bne L2 ; always disable cursor if in bitmap mode
; Switch on the cursor if needed
ldy CURS_X
lda (CRAM_PTR),y ; Get current char
pha ; And save it
lda CHARCOLOR
sta (CRAM_PTR),y

68
libsrc/plus4/crt0.s
View File

@@ -9,8 +9,7 @@
.import callirq_y, initlib, donelib
.import callmain, zerobss
.import __INTERRUPTOR_COUNT__
.import __MAIN_START__, __MAIN_SIZE__ ; Linker generated
.import __STACKSIZE__ ; Linker generated
.import __HIMEM__ ; Linker generated
.importzp ST
.include "zeropage.inc"
@@ -52,19 +51,28 @@ L1: lda sp,x
tsx
stx spsave ; Save system stk ptr
lda #<(__MAIN_START__ + __MAIN_SIZE__ + __STACKSIZE__)
ldx #>(__MAIN_START__ + __MAIN_SIZE__ + __STACKSIZE__)
lda #<__HIMEM__
ldx #>__HIMEM__
sta sp
stx sp+1
; Set up the IRQ vector in the banked RAM; and, switch off the ROM.
ldx #<IRQ
ldy #>IRQ
lda #<IRQ
ldx #>IRQ
sei ; No ints, handler not yet in place
sta ENABLE_RAM
stx $FFFE ; Install interrupt handler
sty $FFFF
sta $FFFE ; Install interrupt handler
stx $FFFF
lda IRQVec
ldx IRQVec+1
sta IRQInd+1
stx IRQInd+2
lda #<IRQStub
ldx #>IRQStub
sta IRQVec
stx IRQVec+1
cli ; Allow interrupts
; Clear the BSS data.
@@ -95,6 +103,13 @@ _exit: pha ; Save the return code
lda #0
sta irqcount ; Disable custom IRQ handlers
sei
ldx IRQInd+1
ldy IRQInd+2
stx IRQVec
sty IRQVec+1
cli
; Copy back the zero-page stuff.
ldx #zpspace-1
@@ -122,9 +137,13 @@ L2: lda zpsave,x
; IRQ handler. The handler in the ROM enables the Kernal, and jumps to
; $CE00, where the ROM code checks for a BRK or IRQ, and branches via the
; indirect vectors at $314/$316.
; To make our stub as fast as possible, we skip the whole part of the ROM
; handler, and jump to the indirect vectors directly. We do also call our
; own interrupt handlers if we have any; so, they need not use $314.
;
; When RAM is banked in, we skip the whole part of the ROM handler, and jump to
; the indirect vectors directly, after calling our own interrupt handlers.
;
; When ROM is banked in, a stub installed in the $314 indirect vector ensures
; that our interrupt handlers are still called (otherwise, interrupts that are
; not serviced by the ROM handler may cause a deadlock).
.segment "LOWCODE"
@@ -139,15 +158,6 @@ IRQ: cld ; Just to be sure
and #$10 ; Test for BRK bit
bne dobreak
; It's an IRQ; and, RAM is enabled. If we have handlers, call them. We will use
; a flag here instead of loading __INTERRUPTOR_COUNT__ directly, since the
; condes function is not reentrant. The irqcount flag will be set/reset from
; the main code, to avoid races.
ldy irqcount
beq @L1
jsr callirq_y ; Call the IRQ functions
; Since the ROM handler will end with an RTI, we have to fake an IRQ return
; on the stack, so that we get control of the CPU after the ROM handler,
; and can switch back to RAM.
@@ -161,7 +171,7 @@ IRQ: cld ; Just to be sure
pha ; Push faked X register
pha ; Push faked Y register
sta ENABLE_ROM ; Switch to ROM
jmp (IRQVec) ; Jump indirect to Kernal IRQ handler
jmp (IRQVec) ; Jump indirect to IRQ stub
irq_ret:
sta ENABLE_RAM ; Switch back to RAM
@@ -183,6 +193,22 @@ nohandler:
sta ENABLE_ROM
jmp (BRKVec) ; Jump indirect to the break vector
; IRQ stub installed at $314, called by our handler above if RAM is banked in,
; or the Kernal IRQ handler if ROM is banked in.
; If we have handlers, call them. We will use a flag here instead of loading
; __INTERRUPTOR_COUNT__ directly, since the condes function is not reentrant.
; The irqcount flag will be set/reset from the main code, to avoid races.
IRQStub:
cld ; Just to be sure
sta ENABLE_RAM
ldy irqcount
beq @L1
jsr callirq_y ; Call the IRQ functions
@L1: sta ENABLE_ROM
jmp (IRQInd+1) ; Jump to the saved IRQ vector
; ------------------------------------------------------------------------
; Data

3
libsrc/plus4/libref.s
View File

@@ -2,8 +2,9 @@
; Oliver Schmidt, 2013-05-31
;
.export joy_libref, ser_libref
.export joy_libref, ser_libref, tgi_libref
.import _exit
joy_libref := _exit
ser_libref := _exit
tgi_libref := _exit

41
libsrc/plus4/ser/plus4-stdser.s
View File

@@ -64,15 +64,15 @@ ACIA_STATUS := ACIA+1 ; Status register
ACIA_CMD := ACIA+2 ; Command register
ACIA_CTRL := ACIA+3 ; Control register
RecvHead := $07D1 ; Head of receive buffer
RecvTail := $07D2 ; Tail of receive buffer
RecvFreeCnt := $07D3 ; Number of bytes in receive buffer
;----------------------------------------------------------------------------
;
; Global variables
;
.bss
RecvHead: .res 1 ; Head of receive buffer
RecvTail: .res 1 ; Tail of receive buffer
RecvFreeCnt: .res 1 ; Number of bytes in receive buffer
SendHead: .res 1 ; Head of send buffer
SendTail: .res 1 ; Tail of send buffer
SendFreeCnt: .res 1 ; Number of bytes in send buffer
@@ -88,7 +88,7 @@ SendBuf: .res 256
; Tables used to translate RS232 params into register values
BaudTable: ; bit7 = 1 means setting is invalid
BaudTable: ; Bit7 = 1 means setting is invalid
.byte $FF ; SER_BAUD_45_5
.byte $01 ; SER_BAUD_50
.byte $02 ; SER_BAUD_75
@@ -354,26 +354,27 @@ SER_IOCTL:
;
SER_IRQ:
lda ACIA_STATUS ; Check ACIA status for receive interrupt
and #$08
beq @L9 ; Jump if no ACIA interrupt (carry still clear)
lda ACIA_DATA ; Get byte from ACIA
ldx RecvFreeCnt ; Check if we have free space left
beq @L1 ; Jump if no space in receive buffer
ldy RecvTail ; Load buffer pointer
sta RecvBuf,y ; Store received byte in buffer
inc RecvTail ; Increment buffer pointer
dec RecvFreeCnt ; Decrement free space counter
cpx #33 ; Check for buffer space low
bcc @L1 ; Assert flow control if buffer space low
lda ACIA_STATUS ; (4) Check for byte received
and #$08 ; (2)
beq @L9 ; (2*)
lda ACIA_DATA ; (4) Get byte and put into receive buffer
ldy RecvTail ; (4)
ldx RecvFreeCnt ; (4)
beq @L3 ; (2*) Jump if no space in receive buffer
sta RecvBuf,y ; (5)
inc RecvTail ; (6)
dec RecvFreeCnt ; (6)
cpx #33 ; (2) Check for buffer space low
bcc @L2 ; (2*)
rts ; Return with carry set (interrupt handled)
; Assert flow control if buffer space too low
@L1: lda RtsOff
sta ACIA_CMD
sta Stopped
sec ; Interrupt handled
@L2: lda RtsOff ; (3)
sta ACIA_CMD ; (4)
sta Stopped ; (3)
@L3: sec ; Interrupt handled
@L9: rts
;----------------------------------------------------------------------------

860
libsrc/plus4/tgi/ted-hi.s Normal file
View File

@@ -0,0 +1,860 @@
;
; Graphics driver for the 320x200x2 mode on Commodore Plus/4 systems.
;
; Luminance/Chrominance matrices at $800/$C00, overwriting text-mode character
; and color data. Bitmap is at $C000-$DF3F. Programs using this driver should
; either be linked with the option '-D __HIMEM__=0xC000'.
;
; Based on the c64-hi TGI driver, which in turn was based on Stephen L. Judd's
; GRLIB code.
;
; 2017-01-13, Greg King
; 2018-03-13, Sven Klose
; 2019-10-23, Richard Halkyard
;
.include "zeropage.inc"
.include "tgi-kernel.inc"
.include "tgi-error.inc"
.include "cbm_kernal.inc"
.include "plus4.inc"
.macpack generic
.macpack module
; ------------------------------------------------------------------------
; Header. Includes jump table and constants.
module_header _ted_hi_tgi
; First part of the header is a structure that has a magic and defines the
; capabilities of the driver
.byte $74, $67, $69 ; "tgi"
.byte TGI_API_VERSION ; TGI API version number
.addr $0000 ; Library reference
.word 320 ; X resolution
.word 200 ; Y resolution
.byte 2 ; Number of drawing colors
.byte 1 ; Number of screens available
.byte 8 ; System font X size
.byte 8 ; System font Y size
.word $00D4 ; Aspect ratio (based on 4/3 display)
.byte 0 ; TGI driver flags
; Next comes the jump table. With the exception of IRQ, all entries must be
; valid and may point to an RTS for test versions (function not implemented).
.addr INSTALL
.addr UNINSTALL
.addr INIT
.addr DONE
.addr GETERROR
.addr CONTROL
.addr CLEAR
.addr SETVIEWPAGE
.addr SETDRAWPAGE
.addr SETCOLOR
.addr SETPALETTE
.addr GETPALETTE
.addr GETDEFPALETTE
.addr SETPIXEL
.addr GETPIXEL
.addr LINE
.addr BAR
.addr TEXTSTYLE
.addr OUTTEXT
; ------------------------------------------------------------------------
; Data.
; Variables mapped to the zero page segment variables. Some of these are
; used for passing parameters to the driver.
X1 := ptr1
Y1 := ptr2
X2 := ptr3
Y2 := ptr4
TEXT := ptr3
TEMP := tmp4
TEMP2 := sreg
POINT := regsave
CHUNK := X2 ; Used in the line routine
OLDCHUNK := X2+1 ; Dito
; Absolute variables used in the code
.bss
ERROR: .res 1 ; Error code
PALETTE: .res 2 ; The current palette
BITMASK: .res 1 ; $00 = clear, $FF = set pixels
; Line routine stuff
DX: .res 2
DY: .res 2
; BAR variables
X1SAVE: .res 2
Y1SAVE: .res 2
X2SAVE: .res 2
Y2SAVE: .res 2
; Text output stuff
TEXTMAGX: .res 1
TEXTMAGY: .res 1
TEXTDIR: .res 1
; Constants and tables
.rodata
DEFPALETTE: .byte $00, $71 ; White on black
PALETTESIZE = * - DEFPALETTE
BITTAB: .byte $80,$40,$20,$10,$08,$04,$02,$01
BITCHUNK: .byte $FF,$7F,$3F,$1F,$0F,$07,$03,$01
CHARROM := $D000 ; Character rom base address
; The TED uses the CPU's memory configuration to fetch color data! Although
; we run with ROMs banked out, putting color data in banked RAM (above $8000)
; will result in color artifacts appearing when we bank ROM back in for
; interrupts and Kernal calls. Bitmap data is not affected by this limitation,
; but since there is no way to access RAM under IO (FE00-FF40), we can't put the
; bitmap at $E000 like we do on the C64, and have to use the next lowest
; position at $C000.
LBASE := $0800 ; Luminance memory base address
VBASE := $C000 ; Bitmap base address
CBASE := LBASE + $400 ; Chrominance memory base address (fixed relative to LBASE)
CHRBASE := $0800 ; Base address of text mode data
.assert LBASE .mod $0800 = 0, error, "Luma/Chroma memory base address must be a multiple of 2K"
.assert VBASE .mod $2000 = 0, error, "Bitmap base address must be a multiple of 8K"
.assert LBASE + $800 < $8000, warning, "Luma/Chroma memory overlaps ROM. This will produce color artifacts."
.assert VBASE + $2000 < $FE00, error, "Bitmap overlaps IO space"
.code
; ------------------------------------------------------------------------
; INSTALL routine. Is called after the driver is loaded into memory. May
; initialize anything that has to be done just once. Is probably empty
; most of the time.
;
; Must set an error code: NO
;
INSTALL:
; rts ; Fall through
; ------------------------------------------------------------------------
; UNINSTALL routine. Is called before the driver is removed from memory. May
; clean up anything done by INSTALL but is probably empty most of the time.
;
; Must set an error code: NO
;
UNINSTALL:
rts
; ------------------------------------------------------------------------
; INIT: Changes an already installed device from text mode to graphics
; mode.
; Note that INIT/DONE may be called multiple times while the driver
; is loaded, while INSTALL is only called once, so any code that is needed
; to initializes variables and so on must go here. Setting palette and
; clearing the screen is not needed because this is called by the graphics
; kernel later.
; The graphics kernel will never call INIT when a graphics mode is already
; active, so there is no need to protect against that.
;
; Must set an error code: YES
;
INIT:
; Initialize variables
ldx #$FF
stx BITMASK
; Switch into graphics mode
lda $FF12 ; Set bitmap address and enable fetch from RAM
and #%00000011
ora #(>VBASE >> 2)
sta $FF12
.if LBASE <> CHRBASE
lda #>LBASE ; Set color memory address
sta $FF14
.endif
lda $FF06 ; Enable bitmap mode
ora #%00100000
sta $FF06
; Done, reset the error code
lda #TGI_ERR_OK
sta ERROR
rts
; ------------------------------------------------------------------------
; DONE: Will be called to switch the graphics device back into text mode.
; The graphics kernel will never call DONE when no graphics mode is active,
; so there is no need to protect against that.
;
; Must set an error code: NO
;
DONE: lda $FF12
ora #%00000100 ; Fetch from ROM
sta $FF12
.if LBASE <> CHRBASE
lda #>CHRBASE ; Reset character/color matrix address
sta $FF14
.else
sta ENABLE_ROM ; Clear text display since we clobbered it
jsr CLRSCR
sta ENABLE_RAM
.endif
lda $FF06
and #%11011111 ; Exit bitmap mode
sta $FF06
rts
; ------------------------------------------------------------------------
; GETERROR: Return the error code in A and clear it.
GETERROR:
ldx #TGI_ERR_OK
lda ERROR
stx ERROR
rts
; ------------------------------------------------------------------------
; CONTROL: Platform/driver specific entry point.
;
; Must set an error code: YES
;
CONTROL:
lda #TGI_ERR_INV_FUNC
sta ERROR
rts
; ------------------------------------------------------------------------
; CLEAR: Clears the screen.
;
; Must set an error code: NO
;
CLEAR: ldy #$00
tya
@L1: sta VBASE+$0000,y
sta VBASE+$0100,y
sta VBASE+$0200,y
sta VBASE+$0300,y
sta VBASE+$0400,y
sta VBASE+$0500,y
sta VBASE+$0600,y
sta VBASE+$0700,y
sta VBASE+$0800,y
sta VBASE+$0900,y
sta VBASE+$0A00,y
sta VBASE+$0B00,y
sta VBASE+$0C00,y
sta VBASE+$0D00,y
sta VBASE+$0E00,y
sta VBASE+$0F00,y
sta VBASE+$1000,y
sta VBASE+$1100,y
sta VBASE+$1200,y
sta VBASE+$1300,y
sta VBASE+$1400,y
sta VBASE+$1500,y
sta VBASE+$1600,y
sta VBASE+$1700,y
sta VBASE+$1800,y
sta VBASE+$1900,y
sta VBASE+$1A00,y
sta VBASE+$1B00,y
sta VBASE+$1C00,y
sta VBASE+$1D00,y
sta VBASE+$1E00,y
sta VBASE+$1E40,y
iny
bne @L1
rts
; ------------------------------------------------------------------------
; SETVIEWPAGE: Set the visible page. Called with the new page in A (0..n).
; The page number is already checked to be valid by the graphics kernel.
;
; Must set an error code: NO (will only be called if page ok)
;
SETVIEWPAGE:
; rts ; Fall through
; ------------------------------------------------------------------------
; SETDRAWPAGE: Set the drawable page. Called with the new page in A (0..n).
; The page number is already checked to be valid by the graphics kernel.
;
; Must set an error code: NO (will only be called if page ok)
;
SETDRAWPAGE:
rts
; ------------------------------------------------------------------------
; SETCOLOR: Set the drawing color (in A). The new color is already checked
; to be in a valid range (0..maxcolor-1).
;
; Must set an error code: NO (will only be called if color ok)
;
SETCOLOR:
tax
beq @L1
lda #$FF
@L1: sta BITMASK
rts
; ------------------------------------------------------------------------
; SETPALETTE: Set the palette (not available with all drivers/hardware).
; A pointer to the palette is passed in ptr1. Must set an error if palettes
; are not supported
;
; Must set an error code: YES
;
SETPALETTE:
ldy #PALETTESIZE - 1
@L1: lda (ptr1),y ; Copy the palette
sta PALETTE,y
dey
bpl @L1
; Get luma values from the high nybble of the palette entries
lda PALETTE+1 ; Foreground luma
lsr a
lsr a
lsr a
lsr a
sta TEMP ; Foreground -> low nybble
lda PALETTE ; Background luma
and #$F0
ora TEMP ; Background -> high nybble
; Initialize the luma map with the new luma values
ldy #0
@L2: sta LBASE+$0000,y
sta LBASE+$0100,y
sta LBASE+$0200,y
sta LBASE+$02e8,y
iny
bne @L2
; Get chroma values from the low nybble of the palette entries
lda PALETTE+1 ; Foreground chroma
and #$0F
asl a
asl a
asl a
asl a
sta TEMP ; Foreground -> high nybble
lda PALETTE ; Background chroma
and #$0F
ora TEMP ; Background -> low nybble
; Initialize the chroma map with the new chroma values
ldy #0
@L3: sta CBASE+$0000,y
sta CBASE+$0100,y
sta CBASE+$0200,y
sta CBASE+$02e8,y
iny
bne @L3
; Done, reset the error code
lda #TGI_ERR_OK
sta ERROR
rts
; ------------------------------------------------------------------------
; GETPALETTE: Return the current palette in A/X. Even drivers that cannot
; set the palette should return the default palette here, so there's no
; way for this function to fail.
;
; Must set an error code: NO
;
GETPALETTE:
lda #<PALETTE
ldx #>PALETTE
rts
; ------------------------------------------------------------------------
; GETDEFPALETTE: Return the default palette for the driver in A/X. All
; drivers should return something reasonable here, even drivers that don't
; support palettes, otherwise the caller has no way to determine the colors
; of the (not changeable) palette.
;
; Must set an error code: NO (all drivers must have a default palette)
;
GETDEFPALETTE:
lda #<DEFPALETTE
ldx #>DEFPALETTE
rts
; ------------------------------------------------------------------------
; SETPIXEL: Draw one pixel at X1/Y1 = ptr1/ptr2 with the current drawing
; color. The coordinates passed to this function are never outside the
; visible screen area, so there is no need for clipping inside this function.
;
; Must set an error code: NO
;
SETPIXEL:
jsr CALC ; Calculate coordinates
lda (POINT),Y
eor BITMASK
and BITTAB,X
eor (POINT),Y
sta (POINT),Y
@L9: rts
; ------------------------------------------------------------------------
; GETPIXEL: Read the color value of a pixel and return it in A/X. The
; coordinates passed to this function are never outside the visible screen
; area, so there is no need for clipping inside this function.
GETPIXEL:
jsr CALC ; Calculate coordinates
lda (POINT),Y
ldy #$00
and BITTAB,X
beq @L1
iny
@L1:
tya ; Get color value into A
ldx #$00 ; Clear high byte
rts
; ------------------------------------------------------------------------
; LINE: Draw a line from X1/Y1 to X2/Y2, where X1/Y1 = ptr1/ptr2 and
; X2/Y2 = ptr3/ptr4 using the current drawing color.
;
; X1,X2 etc. are set up above (x2=LINNUM in particular)
; Format is LINE x2,y2,x1,y1
;
; Must set an error code: NO
;
LINE:
@CHECK: lda X2 ; Make sure x1<x2
sec
sbc X1
tax
lda X2+1
sbc X1+1
bpl @CONT
lda Y2 ; If not, swap P1 and P2
ldy Y1
sta Y1
sty Y2
lda Y2+1
ldy Y1+1
sta Y1+1
sty Y2+1
lda X1
ldy X2
sty X1
sta X2
lda X2+1
ldy X1+1
sta X1+1
sty X2+1
bcc @CHECK
@CONT: sta DX+1
stx DX
ldx #$C8 ; INY
lda Y2 ; Calculate dy
sec
sbc Y1
tay
lda Y2+1
sbc Y1+1
bpl @DYPOS ; Is y2>=y1?
lda Y1 ; Otherwise dy=y1-y2
sec
sbc Y2
tay
ldx #$88 ; DEY
@DYPOS: sty DY ; 8-bit DY -- FIX ME?
stx YINCDEC
stx XINCDEC
jsr CALC ; Set up .X, .Y, and POINT
lda BITCHUNK,X
sta OLDCHUNK
sta CHUNK
ldx DY
cpx DX ; Who's bigger: dy or dx?
bcc STEPINX ; If dx, then...
lda DX+1
bne STEPINX
;
; Big steps in Y
;
; To simplify my life, just use PLOT to plot points.
;
; No more!
; Added special plotting routine -- cool!
;
; X is now counter, Y is y-coordinate
;
; On entry, X=DY=number of loop iterations, and Y=
; Y1 AND #$07
STEPINY:
lda #00
sta OLDCHUNK ; So plotting routine will work right
lda CHUNK
lsr ; Strip the bit
eor CHUNK
sta CHUNK
txa
beq YCONT2 ; If dy=0, it's just a point
@CONT: lsr ; Init counter to dy/2
;
; Main loop
;
YLOOP: sta TEMP
lda (POINT),y
eor BITMASK
and CHUNK
eor (POINT),y
sta (POINT),y
YINCDEC:
iny ; Advance Y coordinate
cpy #8
bcc @CONT ; No prob if Y=0..7
jsr FIXY
@CONT: lda TEMP ; Restore A
sec
sbc DX
bcc YFIXX
YCONT: dex ; X is counter
bne YLOOP
YCONT2: lda (POINT),y ; Plot endpoint
eor BITMASK
and CHUNK
eor (POINT),y
sta (POINT),y
rts
YFIXX: ; X=x+1
adc DY
lsr CHUNK
bne YCONT ; If we pass a column boundary...
ror CHUNK ; Then reset CHUNK to $80
sta TEMP2
lda POINT ; And add 8 to POINT
adc #8
sta POINT
bcc @CONT
inc POINT+1
@CONT: lda TEMP2
dex
bne YLOOP
beq YCONT2
;
; Big steps in X direction
;
; On entry, X=DY=number of loop iterations, and Y=
; Y1 AND #$07
.bss
COUNTHI:
.byte $00 ; Temporary counter, only used once.
.code
STEPINX:
ldx DX
lda DX+1
sta COUNTHI
cmp #$80
ror ; Need bit for initialization
sta Y1 ; High byte of counter
txa
bne @CONT ; Could be $100
dec COUNTHI
@CONT: ror
;
; Main loop
;
XLOOP: lsr CHUNK
beq XFIXC ; If we pass a column boundary...
XCONT1: sbc DY
bcc XFIXY ; Time to step in Y?
XCONT2: dex
bne XLOOP
dec COUNTHI ; High bits set?
bpl XLOOP
lsr CHUNK ; Advance to last point
jmp LINEPLOT ; Plot the last chunk
;
; CHUNK has passed a column, so plot and increment pointer
; and fix up CHUNK, OLDCHUNK.
;
XFIXC: sta TEMP
jsr LINEPLOT
lda #$FF
sta CHUNK
sta OLDCHUNK
lda POINT
clc
adc #8
sta POINT
lda TEMP
bcc XCONT1
inc POINT+1
jmp XCONT1
;
; Check to make sure there isn't a high bit, plot chunk,
; and update Y-coordinate.
;
XFIXY: dec Y1 ; Maybe high bit set
bpl XCONT2
adc DX
sta TEMP
lda DX+1
adc #$FF ; Hi byte
sta Y1
jsr LINEPLOT ; Plot chunk
lda CHUNK
sta OLDCHUNK
lda TEMP
XINCDEC:
iny ; Y-coord
cpy #8 ; 0..7 is ok
bcc XCONT2
sta TEMP
jsr FIXY
lda TEMP
jmp XCONT2
;
; Subroutine to plot chunks/points (to save a little
; room, gray hair, etc.)
;
LINEPLOT: ; Plot the line chunk
lda (POINT),Y
eor BITMASK
ora CHUNK
and OLDCHUNK
eor CHUNK
eor (POINT),Y
sta (POINT),Y
rts
;
; Subroutine to fix up pointer when Y decreases through
; zero or increases through 7.
;
FIXY: cpy #255 ; Y=255 or Y=8
beq @DECPTR
@INCPTR: ; Add 320 to pointer
ldy #0 ; Y increased through 7
lda POINT
adc #<320
sta POINT
lda POINT+1
adc #>320
sta POINT+1
rts
@DECPTR: ; Okay, subtract 320 then
ldy #7 ; Y decreased through 0
lda POINT
sec
sbc #<320
sta POINT
lda POINT+1
sbc #>320
sta POINT+1
rts
; ------------------------------------------------------------------------
; BAR: Draw a filled rectangle with the corners X1/Y1, X2/Y2, where
; X1/Y1 = ptr1/ptr2 and X2/Y2 = ptr3/ptr4 using the current drawing color.
; Contrary to most other functions, the graphics kernel will sort and clip
; the coordinates before calling the driver, so on entry the following
; conditions are valid:
; X1 <= X2
; Y1 <= Y2
; (X1 >= 0) && (X1 < XRES)
; (X2 >= 0) && (X2 < XRES)
; (Y1 >= 0) && (Y1 < YRES)
; (Y2 >= 0) && (Y2 < YRES)
;
; Must set an error code: NO
;
; Note: This function needs optimization. It's just a cheap translation of
; the original C wrapper and could be written much smaller (besides that,
; calling LINE is not a good idea either).
BAR: lda Y2
sta Y2SAVE
lda Y2+1
sta Y2SAVE+1
lda X2
sta X2SAVE
lda X2+1
sta X2SAVE+1
lda Y1
sta Y1SAVE
lda Y1+1
sta Y1SAVE+1
lda X1
sta X1SAVE
lda X1+1
sta X1SAVE+1
@L1: lda Y1
sta Y2
lda Y1+1
sta Y2+1
jsr LINE
lda Y1SAVE
cmp Y2SAVE
bne @L2
lda Y1SAVE
cmp Y2SAVE
beq @L4
@L2: inc Y1SAVE
bne @L3
inc Y1SAVE+1
@L3: lda Y1SAVE
sta Y1
lda Y1SAVE+1
sta Y1+1
lda X1SAVE
sta X1
lda X1SAVE+1
sta X1+1
lda X2SAVE
sta X2
lda X2SAVE+1
sta X2+1
jmp @L1
@L4: rts
; ------------------------------------------------------------------------
; TEXTSTYLE: Set the style used when calling OUTTEXT. Text scaling in X and Y
; direction is passend in X/Y, the text direction is passed in A.
;
; Must set an error code: NO
;
TEXTSTYLE:
stx TEXTMAGX
sty TEXTMAGY
sta TEXTDIR
rts
; ------------------------------------------------------------------------
; OUTTEXT: Output text at X/Y = ptr1/ptr2 using the current color and the
; current text style. The text to output is given as a zero terminated
; string with address in ptr3.
;
; Must set an error code: NO
;
OUTTEXT:
rts
; ------------------------------------------------------------------------
; Calculate all variables to plot the pixel at X1/Y1.
CALC: lda Y1
sta TEMP2
and #7
tay
lda Y1+1
lsr ; Neg is possible
ror TEMP2
lsr
ror TEMP2
lsr
ror TEMP2
lda #00
sta POINT
lda TEMP2
cmp #$80
ror
ror POINT
cmp #$80
ror
ror POINT ; Row * 64
adc TEMP2 ; + Row * 256
clc
adc #>VBASE ; + Bitmap base
sta POINT+1
lda X1
tax
and #$F8
clc
adc POINT ; +(X AND #$F8)
sta POINT
lda X1+1
adc POINT+1
sta POINT+1
txa
and #7
tax
rts

14
libsrc/plus4/tgi_stat_stddrv.s Normal file
View File

@@ -0,0 +1,14 @@
;
; Address of the static standard tgi driver
;
; Oliver Schmidt, 2012-11-01
;
; const void tgi_static_stddrv[];
;
.export _tgi_static_stddrv
.import _ted_hi_tgi
.rodata
_tgi_static_stddrv := _ted_hi_tgi

13
libsrc/plus4/tgi_stddrv.s Normal file
View File

@@ -0,0 +1,13 @@
;
; Name of the standard tgi driver
;
; Oliver Schmidt, 2011-05-02
;
; const char tgi_stddrv[];
;
.export _tgi_stddrv
.rodata
_tgi_stddrv: .asciiz "ted-hi.tgi"

17
samples/Makefile
View File

@@ -99,6 +99,7 @@ DISK_apple2 = samples.dsk
DISK_apple2enh = samples.dsk
DISK_atari = samples.atr
DISK_atarixl = samples.atr
DISK_plus4 = samples.d64
# --------------------------------------------------------------------------
# System-dependent settings
@@ -146,6 +147,8 @@ LDFLAGS_tgidemo_atarixl = --start-addr 0x4000
.o:
ifeq ($(SYS),vic20)
$(LD) $(LDFLAGS_$(@F)_$(SYS)) $(LDFLAGS) -o $@ -C vic20-32k.cfg -m $@.map $^ $(SYS).lib
else ifeq ($(SYS),plus4)
$(LD) $(LDFLAGS_$(@F)_$(SYS)) $(LDFLAGS) -o $@ -C plus4-hires.cfg -m $@.map $^ $(SYS).lib
else
$(LD) $(LDFLAGS_$(@F)_$(SYS)) $(LDFLAGS) -o $@ -t $(SYS) -m $@.map $^ $(SYS).lib
endif
@@ -326,9 +329,11 @@ EXELIST_plus4 = \
enumdevdir \
gunzip65 \
hello \
mandelbrot \
terminal \
tinyshell \
sieve
sieve \
tgidemo
EXELIST_sim6502 = \
checkversion \
@@ -451,7 +456,15 @@ multdemo: multidemo.o
ovrldemo: overlaydemo.o
$(LD) $(LDFLAGS) -o $@ -C $(SYS)-overlay.cfg -m $@.map $^ $(SYS).lib
OVERLAYLIST := $(foreach I,1 2 3,multdemo.$I ovrldemo.$I)
OVERLAYLIST :=
ifneq ($(filter ovrldemo,$(EXELIST_$(SYS))),)
OVERLAYLIST += $(foreach I,1 2 3,ovrldemo.$I)
endif
ifneq ($(filter multdemo,$(EXELIST_$(SYS))),)
OVERLAYLIST += $(foreach I,1 2 3,multdemo.$I)
endif
# --------------------------------------------------------------------------
# TGI programs on the VIC-20 need a special ld65 configuration file.

1
samples/diodemo.c
View File

@@ -30,6 +30,7 @@
#define DYN_BOX_DRAW
#include <stddef.h>
#include <stdlib.h>
#include <limits.h>

1
samples/hello.c
View File

@@ -7,6 +7,7 @@
#define DYN_BOX_DRAW
#include <stdlib.h>
#include <string.h>
#include <conio.h>

57
samples/tgidemo.c
View File

@@ -12,8 +12,10 @@
# define DYN_DRV 1
#endif
#define COLOR_BACK TGI_COLOR_BLACK
#define COLOR_FORE TGI_COLOR_WHITE
/* Color values passed to TGI functions are indices into the default palette. */
#define COLOR_BACK 0
#define COLOR_FORE 1
/*****************************************************************************/
@@ -65,17 +67,39 @@ static void DoWarning (void)
#endif
/*
* Note that everywhere else in the TGI API, colors are referred to via an index
* to the current palette.
*
* TGI_COLOR_ values can be used (ONLY!) for setting the palette, using them
* with other TGI functions only works by chance, on some targets.
*/
static void DoPalette (int n)
{
static const unsigned char Palette[4][2] = {
/* FIXME: add some ifdefs with proper values for targets that need it */
#if !defined(__APPLE2__)
{ TGI_COLOR_BLACK, TGI_COLOR_BLUE },
{ TGI_COLOR_WHITE, TGI_COLOR_BLACK },
{ TGI_COLOR_RED, TGI_COLOR_BLACK },
#else
{ TGI_COLOR_WHITE, TGI_COLOR_BLACK },
{ TGI_COLOR_BLACK, TGI_COLOR_WHITE },
{ TGI_COLOR_WHITE, TGI_COLOR_BLACK },
#endif
};
tgi_setpalette (Palette[n]);
}
static void DoCircles (void)
{
static const unsigned char Palette[2] = { TGI_COLOR_WHITE, TGI_COLOR_BLUE };
unsigned char I;
unsigned char Color = COLOR_BACK;
const unsigned X = MaxX / 2;
const unsigned Y = MaxY / 2;
const unsigned Limit = (X < Y) ? Y : X;
tgi_setpalette (Palette);
tgi_setcolor (COLOR_FORE);
tgi_clear ();
tgi_line (0, 0, MaxX, MaxY);
@@ -87,7 +111,9 @@ static void DoCircles (void)
tgi_ellipse (X, Y, I, tgi_imulround (I, AspectRatio));
}
}
while (kbhit ()) {
cgetc ();
}
cgetc ();
}
@@ -95,11 +121,9 @@ static void DoCircles (void)
static void DoCheckerboard (void)
{
static const unsigned char Palette[2] = { TGI_COLOR_WHITE, TGI_COLOR_BLACK };
unsigned X, Y;
unsigned char Color = COLOR_BACK;
tgi_setpalette (Palette);
tgi_clear ();
while (1) {
@@ -123,13 +147,11 @@ static void DoCheckerboard (void)
static void DoDiagram (void)
{
static const unsigned char Palette[2] = { TGI_COLOR_WHITE, TGI_COLOR_BLACK };
int XOrigin, YOrigin;
int Amp;
int X, Y;
unsigned I;
tgi_setpalette (Palette);
tgi_setcolor (COLOR_FORE);
tgi_clear ();
@@ -160,6 +182,9 @@ static void DoDiagram (void)
tgi_lineto (XOrigin + X, YOrigin + Y);
}
while (kbhit ()) {
cgetc ();
}
cgetc ();
}
@@ -167,11 +192,9 @@ static void DoDiagram (void)
static void DoLines (void)
{
static const unsigned char Palette[2] = { TGI_COLOR_WHITE, TGI_COLOR_BLACK };
unsigned X;
const unsigned Min = (MaxX < MaxY) ? MaxX : MaxY;
tgi_setpalette (Palette);
tgi_setcolor (COLOR_FORE);
tgi_clear ();
@@ -182,6 +205,9 @@ static void DoLines (void)
tgi_line (Min, Min, Min-X, 0);
}
while (kbhit ()) {
cgetc ();
}
cgetc ();
}
@@ -216,10 +242,11 @@ int main (void)
Border = bordercolor (COLOR_BLACK);
/* Do graphics stuff */
DoCircles ();
DoCheckerboard ();
DoDiagram ();
DoLines ();
/* use default palette */ DoCircles ();
DoPalette (0); DoCheckerboard ();
DoPalette (1); DoDiagram ();
DoPalette (2); DoLines ();
#if DYN_DRV
/* Unload the driver */

8
src/cc65/compile.c
View File

@@ -496,6 +496,14 @@ void Compile (const char* FileName)
while (PreprocessNextLine ())
{ /* Nothing */ }
/* Output macros if requested by the user */
if (DumpPredefMacros) {
OutputPredefMacros ();
}
if (DumpUserMacros) {
OutputUserMacros ();
}
/* Close the output file */
CloseOutputFile ();

76
src/cc65/error.c
View File

@@ -39,6 +39,7 @@
/* common */
#include "coll.h"
#include "debugflag.h"
#include "print.h"
#include "strbuf.h"
@@ -183,11 +184,15 @@ static unsigned GetDiagnosticLineNum (void)
void Fatal (const char* Format, ...)
void Fatal_ (const char *file, int line, const char* Format, ...)
/* Print a message about a fatal error and die */
{
va_list ap;
if (Debug) {
fprintf(stderr, "[%s:%d] ", file, line);
}
fprintf (stderr, "%s:%u: Fatal: ", GetDiagnosticFileName (), GetDiagnosticLineNum ());
va_start (ap, Format);
@@ -203,11 +208,15 @@ void Fatal (const char* Format, ...)
void Internal (const char* Format, ...)
void Internal_ (const char *file, int line, const char* Format, ...)
/* Print a message about an internal compiler error and die */
{
va_list ap;
if (Debug) {
fprintf(stderr, "[%s:%d] ", file, line);
}
fprintf (stderr, "%s:%u: Internal compiler error:\n",
GetDiagnosticFileName (), GetDiagnosticLineNum ());
@@ -270,10 +279,15 @@ static void IntError (errcat_t EC, LineInfo* LI, const char* Msg, va_list ap)
void LIError (errcat_t EC, LineInfo* LI, const char* Format, ...)
void LIError_ (const char *file, int line, errcat_t EC, LineInfo* LI, const char* Format, ...)
/* Print an error message with the line info given explicitly */
{
va_list ap;
if (Debug) {
fprintf(stderr, "[%s:%d] ", file, line);
}
va_start (ap, Format);
IntError (EC, LI, Format, ap);
va_end (ap);
@@ -281,10 +295,15 @@ void LIError (errcat_t EC, LineInfo* LI, const char* Format, ...)
void Error (const char* Format, ...)
void Error_ (const char *file, int line, const char* Format, ...)
/* Print an error message */
{
va_list ap;
if (Debug) {
fprintf(stderr, "[%s:%d] ", file, line);
}
va_start (ap, Format);
IntError (EC_PARSER, GetDiagnosticLI (), Format, ap);
va_end (ap);
@@ -292,10 +311,15 @@ void Error (const char* Format, ...)
void PPError (const char* Format, ...)
void PPError_ (const char *file, int line, const char* Format, ...)
/* Print an error message. For use within the preprocessor */
{
va_list ap;
if (Debug) {
fprintf(stderr, "[%s:%d] ", file, line);
}
va_start (ap, Format);
IntError (EC_PP, GetCurLineInfo (), Format, ap);
va_end (ap);
@@ -346,10 +370,15 @@ static void IntWarning (errcat_t EC, LineInfo* LI, const char* Msg, va_list ap)
void LIWarning (errcat_t EC, LineInfo* LI, const char* Format, ...)
void LIWarning_ (const char *file, int line, errcat_t EC, LineInfo* LI, const char* Format, ...)
/* Print a warning message with the line info given explicitly */
{
va_list ap;
if (Debug) {
fprintf(stderr, "[%s:%d] ", file, line);
}
va_start (ap, Format);
IntWarning (EC, LI, Format, ap);
va_end (ap);
@@ -357,10 +386,15 @@ void LIWarning (errcat_t EC, LineInfo* LI, const char* Format, ...)
void Warning (const char* Format, ...)
void Warning_ (const char *file, int line, const char* Format, ...)
/* Print a warning message */
{
va_list ap;
if (Debug) {
fprintf(stderr, "[%s:%d] ", file, line);
}
va_start (ap, Format);
IntWarning (EC_PARSER, GetDiagnosticLI (), Format, ap);
va_end (ap);
@@ -368,10 +402,15 @@ void Warning (const char* Format, ...)
void PPWarning (const char* Format, ...)
void PPWarning_ (const char *file, int line, const char* Format, ...)
/* Print a warning message. For use within the preprocessor */
{
va_list ap;
if (Debug) {
fprintf(stderr, "[%s:%d] ", file, line);
}
va_start (ap, Format);
IntWarning (EC_PP, GetCurLineInfo (), Format, ap);
va_end (ap);
@@ -436,10 +475,15 @@ static void IntNote (const LineInfo* LI, const char* Msg, va_list ap)
void LINote (const LineInfo* LI, const char* Format, ...)
void LINote_ (const char *file, int line, const LineInfo* LI, const char* Format, ...)
/* Print a note message with the line info given explicitly */
{
va_list ap;
if (Debug) {
fprintf(stderr, "[%s:%d] ", file, line);
}
va_start (ap, Format);
IntNote (LI, Format, ap);
va_end (ap);
@@ -447,10 +491,15 @@ void LINote (const LineInfo* LI, const char* Format, ...)
void Note (const char* Format, ...)
void Note_ (const char *file, int line, const char* Format, ...)
/* Print a note message */
{
va_list ap;
if (Debug) {
fprintf(stderr, "[%s:%d] ", file, line);
}
va_start (ap, Format);
IntNote (GetDiagnosticLI (), Format, ap);
va_end (ap);
@@ -458,10 +507,15 @@ void Note (const char* Format, ...)
void PPNote (const char* Format, ...)
void PPNote_ (const char *file, int line, const char* Format, ...)
/* Print a note message. For use within the preprocessor */
{
va_list ap;
if (Debug) {
fprintf(stderr, "[%s:%d] ", file, line);
}
va_start (ap, Format);
IntNote (GetDiagnosticLI (), Format, ap);
va_end (ap);

33
src/cc65/error.h
View File

@@ -103,28 +103,36 @@ struct StrBuf;
void PrintFileInclusionInfo (const LineInfo* LI);
/* Print hierarchy of file inclusion */
void Fatal (const char* Format, ...) attribute ((noreturn, format (printf, 1, 2)));
void Fatal_ (const char *file, int line, const char* Format, ...) attribute ((noreturn, format (printf, 3, 4)));
#define Fatal(...) Fatal_(__FILE__, __LINE__, __VA_ARGS__)
/* Print a message about a fatal error and die */
void Internal (const char* Format, ...) attribute ((noreturn, format (printf, 1, 2)));
void Internal_ (const char *file, int line, const char* Format, ...) attribute ((noreturn, format (printf, 3, 4)));
#define Internal(...) Internal_(__FILE__, __LINE__, __VA_ARGS__)
/* Print a message about an internal compiler error and die */
void Error (const char* Format, ...) attribute ((format (printf, 1, 2)));
void Error_ (const char *file, int line, const char* Format, ...) attribute ((format (printf, 3, 4)));
#define Error(...) Error_(__FILE__, __LINE__, __VA_ARGS__)
/* Print an error message */
void LIError (errcat_t EC, LineInfo* LI, const char* Format, ...) attribute ((format (printf, 3, 4)));
void LIError_ (const char *file, int line, errcat_t EC, LineInfo* LI, const char* Format, ...) attribute ((format (printf, 5, 6)));
#define LIError(...) LIError_(__FILE__, __LINE__, __VA_ARGS__)
/* Print an error message with the line info given explicitly */
void PPError (const char* Format, ...) attribute ((format (printf, 1, 2)));
void PPError_ (const char *file, int line, const char* Format, ...) attribute ((format (printf, 3, 4)));
#define PPError(...) PPError_(__FILE__, __LINE__, __VA_ARGS__)
/* Print an error message. For use within the preprocessor */
void Warning (const char* Format, ...) attribute ((format (printf, 1, 2)));
void Warning_ (const char *file, int line, const char* Format, ...) attribute ((format (printf, 3, 4)));
#define Warning(...) Warning_(__FILE__, __LINE__, __VA_ARGS__)
/* Print a warning message */
void LIWarning (errcat_t EC, LineInfo* LI, const char* Format, ...) attribute ((format (printf, 3, 4)));
void LIWarning_ (const char *file, int line, errcat_t EC, LineInfo* LI, const char* Format, ...) attribute ((format (printf, 5, 6)));
#define LIWarning(...) LIWarning_(__FILE__, __LINE__, __VA_ARGS__)
/* Print a warning message with the line info given explicitly */
void PPWarning (const char* Format, ...) attribute ((format (printf, 1, 2)));
void PPWarning_ (const char *file, int line, const char* Format, ...) attribute ((format (printf, 3, 4)));
#define PPWarning(...) PPWarning_(__FILE__, __LINE__, __VA_ARGS__)
/* Print a warning message. For use within the preprocessor */
void UnreachableCodeWarning (void);
@@ -140,13 +148,16 @@ IntStack* FindWarning (const char* Name);
void ListWarnings (FILE* F);
/* Print a list of warning types/names to the given file */
void Note (const char* Format, ...) attribute ((format (printf, 1, 2)));
void Note_ (const char *file, int line, const char* Format, ...) attribute ((format (printf, 3, 4)));
#define Note(...) Note_(__FILE__, __LINE__, __VA_ARGS__)
/* Print a note message */
void LINote (const LineInfo* LI, const char* Format, ...) attribute ((format (printf, 2, 3)));
void LINote_ (const char *file, int line, const LineInfo* LI, const char* Format, ...) attribute ((format (printf, 4, 5)));
#define LINote(...) LINote_(__FILE__, __LINE__, __VA_ARGS__)
/* Print a note message with the line info given explicitly */
void PPNote (const char* Format, ...) attribute ((format (printf, 1, 2)));
void PPNote_ (const char *file, int line, const char* Format, ...) attribute ((format (printf, 3, 4)));
#define PPNote(...) PPNote_(__FILE__, __LINE__, __VA_ARGS__)
/* Print a note message. For use within the preprocessor */
unsigned GetTotalErrors (void);

4
src/cc65/global.c
View File

@@ -44,12 +44,14 @@
unsigned char AddSource = 0; /* Add source lines as comments */
unsigned char AllowNewComments = 0; /* Allow new style comments in C89 mode */
unsigned char AutoCDecl = 0; /* Make functions default to __cdecl__ */
unsigned char DebugInfo = 0; /* Add debug info to the obj */
unsigned char DumpPredefMacros = 0; /* Output predefined macros */
unsigned char DumpUserMacros = 0; /* Output user macros */
unsigned char PreprocessOnly = 0; /* Just preprocess the input */
unsigned char DebugOptOutput = 0; /* Output debug stuff */
unsigned RegisterSpace = 6; /* Space available for register vars */
unsigned AllowNewComments = 0; /* Allow new style comments in C89 mode */
/* Stackable options */
IntStack WritableStrings = INTSTACK(0); /* Literal strings are r/w */

4
src/cc65/global.h
View File

@@ -52,12 +52,14 @@
/* Options */
extern unsigned char AddSource; /* Add source lines as comments */
extern unsigned char AllowNewComments; /* Allow new style comments in C89 mode */
extern unsigned char AutoCDecl; /* Make functions default to __cdecl__ */
extern unsigned char DebugInfo; /* Add debug info to the obj */
extern unsigned char DumpPredefMacros; /* Output predefined macros */
extern unsigned char DumpUserMacros; /* Output user macros */
extern unsigned char PreprocessOnly; /* Just preprocess the input */
extern unsigned char DebugOptOutput; /* Output debug stuff */
extern unsigned RegisterSpace; /* Space available for register vars */
extern unsigned AllowNewComments; /* Allow new style comments in C89 mode */
/* Stackable options */
extern IntStack WritableStrings; /* Literal strings are r/w */

94
src/cc65/macrotab.c
View File

@@ -1,4 +1,4 @@
/*****************************************************************************/
/* */
/* macrotab.h */
/* */
@@ -42,6 +42,7 @@
/* cc65 */
#include "error.h"
#include "output.h"
#include "preproc.h"
#include "macrotab.h"
@@ -60,6 +61,70 @@ static Macro* MacroTab[MACRO_TAB_SIZE];
/* The undefined macros list head */
static Macro* UndefinedMacrosListHead;
/* Some defines for better readability when calling OutputMacros() */
#define USER_MACROS 0
#define PREDEF_MACROS 1
#define NAME_ONLY 0
#define FULL_DEFINITION 1
/*****************************************************************************/
/* helpers */
/*****************************************************************************/
static void OutputMacro (const Macro* M, int Full)
/* Output one macro. If Full is true, the replacement is also output. */
{
WriteOutput ("#define %s", M->Name);
int ParamCount = M->ParamCount;
if (M->ParamCount >= 0) {
int I;
if (M->Variadic) {
CHECK (ParamCount > 0);
--ParamCount;
}
WriteOutput ("(");
for (I = 0; I < ParamCount; ++I) {
const char* Name = CollConstAt (&M->Params, I);
WriteOutput ("%s%s", (I == 0)? "" : ",", Name);
}
if (M->Variadic) {
WriteOutput ("%s...", (ParamCount == 0)? "" : ",");
}
WriteOutput (")");
}
WriteOutput (" ");
if (Full) {
WriteOutput ("%.*s",
SB_GetLen (&M->Replacement),
SB_GetConstBuf (&M->Replacement));
}
WriteOutput ("\n");
}
static void OutputMacros (int Predefined, int Full)
/* Output macros to the output file depending on the flags given. */
{
/* Note: The Full flag is currently not used by any callers but is left in
** place for possible future changes.
*/
unsigned I;
for (I = 0; I < MACRO_TAB_SIZE; ++I) {
const Macro* M = MacroTab [I];
while (M) {
if ((Predefined != 0) == (M->Predefined != 0)) {
OutputMacro (M, Full);
}
M = M->Next;
}
}
}
/*****************************************************************************/
@@ -68,7 +133,7 @@ static Macro* UndefinedMacrosListHead;
Macro* NewMacro (const char* Name)
Macro* NewMacro (const char* Name, unsigned char Predefined)
/* Allocate a macro structure with the given name. The structure is not
** inserted into the macro table.
*/
@@ -84,6 +149,7 @@ Macro* NewMacro (const char* Name)
M->ParamCount = -1; /* Flag: Not a function-like macro */
InitCollection (&M->Params);
SB_Init (&M->Replacement);
M->Predefined = Predefined;
M->Variadic = 0;
memcpy (M->Name, Name, Len+1);
@@ -116,7 +182,7 @@ Macro* CloneMacro (const Macro* M)
** Use FreeMacro for that.
*/
{
Macro* New = NewMacro (M->Name);
Macro* New = NewMacro (M->Name, M->Predefined);
unsigned I;
for (I = 0; I < CollCount (&M->Params); ++I) {
@@ -134,7 +200,7 @@ Macro* CloneMacro (const Macro* M)
void DefineNumericMacro (const char* Name, long Val)
/* Define a macro for a numeric constant */
/* Define a predefined macro for a numeric constant */
{
char Buf[64];
@@ -148,10 +214,10 @@ void DefineNumericMacro (const char* Name, long Val)
void DefineTextMacro (const char* Name, const char* Val)
/* Define a macro for a textual constant */
/* Define a predefined macro for a textual constant */
{
/* Create a new macro */
Macro* M = NewMacro (Name);
Macro* M = NewMacro (Name, 1);
/* Set the value as replacement text */
SB_CopyStr (&M->Replacement, Val);
@@ -350,3 +416,19 @@ void PrintMacroStats (FILE* F)
}
}
}
void OutputPredefMacros (void)
/* Output all predefined macros to the output file */
{
OutputMacros (PREDEF_MACROS, FULL_DEFINITION);
}
void OutputUserMacros (void)
/* Output all user defined macros to the output file */
{
OutputMacros (USER_MACROS, FULL_DEFINITION);
}

13
src/cc65/macrotab.h
View File

@@ -58,6 +58,7 @@ struct Macro {
int ParamCount; /* Number of parameters, -1 = no parens */
Collection Params; /* Parameter list (char*) */
StrBuf Replacement; /* Replacement text */
unsigned char Predefined; /* True if this is a predefined macro */
unsigned char Variadic; /* C99 variadic macro */
char Name[1]; /* Name, dynamically allocated */
};
@@ -70,7 +71,7 @@ struct Macro {
Macro* NewMacro (const char* Name);
Macro* NewMacro (const char* Name, unsigned char Predefined);
/* Allocate a macro structure with the given name. The structure is not
** inserted into the macro table.
*/
@@ -87,10 +88,10 @@ Macro* CloneMacro (const Macro* M);
*/
void DefineNumericMacro (const char* Name, long Val);
/* Define a macro for a numeric constant */
/* Define a predefined macro for a numeric constant */
void DefineTextMacro (const char* Name, const char* Val);
/* Define a macro for a textual constant */
/* Define a predefined macro for a textual constant */
void InsertMacro (Macro* M);
/* Insert the given macro into the macro table. */
@@ -132,6 +133,12 @@ int MacroCmp (const Macro* M1, const Macro* M2);
void PrintMacroStats (FILE* F);
/* Print macro statistics to the given text file. */
void OutputPredefMacros (void);
/* Output all predefined macros to the output file */
void OutputUserMacros (void);
/* Output all user defined macros to the output file */
/* End of macrotab.h */

27
src/cc65/main.c
View File

@@ -93,6 +93,8 @@ static void Usage (void)
" -V\t\t\t\tPrint the compiler version number\n"
" -W [-+]warning[,...]\t\tControl warnings ('-' disables, '+' enables)\n"
" -d\t\t\t\tDebug mode\n"
" -dM\t\t\t\tOutput all user macros (needs -E)\n"
" -dP\t\t\t\tOutput all predefined macros (needs -E)\n"
" -g\t\t\t\tAdd debug info to object file\n"
" -h\t\t\t\tHelp (this text)\n"
" -j\t\t\t\tDefault characters are signed\n"
@@ -1026,7 +1028,25 @@ int main (int argc, char* argv[])
break;
case 'd':
OptDebug (Arg, 0);
P = Arg + 2;
if (*P == '\0') {
OptDebug (Arg, 0);
} else {
while (*P) {
switch (*P) {
case 'M':
DumpUserMacros = 1;
break;
case 'P':
DumpPredefMacros = 1;
break;
default:
UnknownOption (Arg);
break;
}
++P;
}
}
break;
case 'h':
@@ -1138,6 +1158,11 @@ int main (int argc, char* argv[])
AbEnd ("No input files");
}
/* The options to output macros can only be used with -E */
if ((DumpPredefMacros || DumpUserMacros) && !PreprocessOnly) {
AbEnd ("Preprocessor macro output can only be used together with -E");
}
/* Add the default include search paths. */
FinishIncludePaths ();

2
src/cc65/preproc.c
View File

@@ -2575,7 +2575,7 @@ static void DoDefine (void)
CheckForBadIdent (Ident, Std, 0);
/* Create a new macro definition */
M = NewMacro (Ident);
M = NewMacro (Ident, 0);
/* Check if this is a function-like macro */
if (CurC == '(') {