gbdev/rgbds
1
0
Fork 0
mirror of https://github.com/gbdev/rgbds.git synced 2025-11-20 18:22:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename out_ functions in section.c to sect_

Browse Source 
More consistent with convention used everywhere, and makes it easier to
know which file the functions come from.
This commit is contained in:
ISSOtm
2021-05-03 12:21:07 +02:00
parent 75ce230dce
commit 8bbafb7200
4 changed files with 191 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
include/asm/section.h
View File

@@ -42,14 +42,12 @@ struct SectionSpec {
extern struct Section *currentSection; extern struct Section *currentSection;
struct Section *out_FindSectionByName(const char *name); struct Section *sect_FindSectionByName(const char *name);
void out_NewSection(char const *name, uint32_t secttype, uint32_t org, void sect_NewSection(char const *name, uint32_t secttype, uint32_t org,
struct SectionSpec const *attributes, struct SectionSpec const *attributes, enum SectionModifier mod);
enum SectionModifier mod); void sect_SetLoadSection(char const *name, uint32_t secttype, uint32_t org,
void out_SetLoadSection(char const *name, uint32_t secttype, uint32_t org, struct SectionSpec const *attributes, enum SectionModifier mod);
struct SectionSpec const *attributes, void sect_EndLoadSection(void);
enum SectionModifier mod);
void out_EndLoadSection(void);
struct Section *sect_GetSymbolSection(void); struct Section *sect_GetSymbolSection(void);
uint32_t sect_GetSymbolOffset(void); uint32_t sect_GetSymbolOffset(void);
@@ -61,21 +59,21 @@ void sect_NextUnionMember(void);
void sect_EndUnion(void); void sect_EndUnion(void);
void sect_CheckUnionClosed(void); void sect_CheckUnionClosed(void);
void out_AbsByte(uint8_t b); void sect_AbsByte(uint8_t b);
void out_AbsByteGroup(uint8_t const *s, int32_t length); void sect_AbsByteGroup(uint8_t const *s, int32_t length);
void out_AbsWordGroup(uint8_t const *s, int32_t length); void sect_AbsWordGroup(uint8_t const *s, int32_t length);
void out_AbsLongGroup(uint8_t const *s, int32_t length); void sect_AbsLongGroup(uint8_t const *s, int32_t length);
void out_Skip(int32_t skip, bool ds); void sect_Skip(int32_t skip, bool ds);
void out_String(char const *s); void sect_String(char const *s);
void out_RelByte(struct Expression *expr, uint32_t pcShift); void sect_RelByte(struct Expression *expr, uint32_t pcShift);
void out_RelBytes(uint32_t n, struct Expression *exprs, size_t size); void sect_RelBytes(uint32_t n, struct Expression *exprs, size_t size);
void out_RelWord(struct Expression *expr, uint32_t pcShift); void sect_RelWord(struct Expression *expr, uint32_t pcShift);
void out_RelLong(struct Expression *expr, uint32_t pcShift); void sect_RelLong(struct Expression *expr, uint32_t pcShift);
void out_PCRelByte(struct Expression *expr, uint32_t pcShift); void sect_PCRelByte(struct Expression *expr, uint32_t pcShift);
void out_BinaryFile(char const *s, int32_t startPos); void sect_BinaryFile(char const *s, int32_t startPos);
void out_BinaryFileSlice(char const *s, int32_t start_pos, int32_t length); void sect_BinaryFileSlice(char const *s, int32_t start_pos, int32_t length);
void out_PushSection(void); void sect_PushSection(void);
void out_PopSection(void); void sect_PopSection(void);
#endif #endif

294
src/asm/parser.y
View File

@@ -937,10 +937,10 @@ popo : T_POP_POPO { opt_Pop(); }
pusho : T_POP_PUSHO { opt_Push(); } pusho : T_POP_PUSHO { opt_Push(); }
; ;
pops : T_POP_POPS { out_PopSection(); } pops : T_POP_POPS { sect_PopSection(); }
; ;
pushs : T_POP_PUSHS { out_PushSection(); } pushs : T_POP_PUSHS { sect_PushSection(); }
; ;
fail : T_POP_FAIL string { fatalerror("%s\n", $2); } fail : T_POP_FAIL string { fatalerror("%s\n", $2); }
@@ -992,9 +992,9 @@ shift : T_POP_SHIFT { macro_ShiftCurrentArgs(1); }
; ;
load : T_POP_LOAD sectmod string T_COMMA sectiontype sectorg sectattrs { load : T_POP_LOAD sectmod string T_COMMA sectiontype sectorg sectattrs {
out_SetLoadSection($3, $5, $6, &$7, $2); sect_SetLoadSection($3, $5, $6, &$7, $2);
} }
| T_POP_ENDL { out_EndLoadSection(); } | T_POP_ENDL { sect_EndLoadSection(); }
; ;
rept : T_POP_REPT uconst T_NEWLINE { rept : T_POP_REPT uconst T_NEWLINE {
@@ -1082,9 +1082,9 @@ nextu : T_POP_NEXTU { sect_NextUnionMember(); }
endu : T_POP_ENDU { sect_EndUnion(); } endu : T_POP_ENDU { sect_EndUnion(); }
; ;
ds : T_POP_DS uconst { out_Skip($2, true); } ds : T_POP_DS uconst { sect_Skip($2, true); }
| T_POP_DS uconst T_COMMA ds_args trailing_comma { | T_POP_DS uconst T_COMMA ds_args trailing_comma {
out_RelBytes($2, $4.args, $4.nbArgs); sect_RelBytes($2, $4.args, $4.nbArgs);
freeDsArgList(&$4); freeDsArgList(&$4);
} }
; ;
@@ -1103,15 +1103,15 @@ ds_args : reloc_8bit {
} }
; ;
db : T_POP_DB { out_Skip(1, false); } db : T_POP_DB { sect_Skip(1, false); }
| T_POP_DB constlist_8bit trailing_comma | T_POP_DB constlist_8bit trailing_comma
; ;
dw : T_POP_DW { out_Skip(2, false); } dw : T_POP_DW { sect_Skip(2, false); }
| T_POP_DW constlist_16bit trailing_comma | T_POP_DW constlist_16bit trailing_comma
; ;
dl : T_POP_DL { out_Skip(4, false); } dl : T_POP_DL { sect_Skip(4, false); }
| T_POP_DL constlist_32bit trailing_comma | T_POP_DL constlist_32bit trailing_comma
; ;
@@ -1193,17 +1193,17 @@ include : label T_POP_INCLUDE string endofline {
; ;
incbin : T_POP_INCBIN string { incbin : T_POP_INCBIN string {
out_BinaryFile($2, 0); sect_BinaryFile($2, 0);
if (failedOnMissingInclude) if (failedOnMissingInclude)
YYACCEPT; YYACCEPT;
} }
| T_POP_INCBIN string T_COMMA const { | T_POP_INCBIN string T_COMMA const {
out_BinaryFile($2, $4); sect_BinaryFile($2, $4);
if (failedOnMissingInclude) if (failedOnMissingInclude)
YYACCEPT; YYACCEPT;
} }
| T_POP_INCBIN string T_COMMA const T_COMMA const { | T_POP_INCBIN string T_COMMA const T_COMMA const {
out_BinaryFileSlice($2, $4, $6); sect_BinaryFileSlice($2, $4, $6);
if (failedOnMissingInclude) if (failedOnMissingInclude)
YYACCEPT; YYACCEPT;
} }
@@ -1289,13 +1289,13 @@ constlist_8bit : constlist_8bit_entry
; ;
constlist_8bit_entry : reloc_8bit_no_str { constlist_8bit_entry : reloc_8bit_no_str {
out_RelByte(&$1, 0); sect_RelByte(&$1, 0);
} }
| string { | string {
uint8_t *output = malloc(strlen($1)); /* Cannot be larger than that */ uint8_t *output = malloc(strlen($1)); /* Cannot be larger than that */
int32_t length = charmap_Convert($1, output); int32_t length = charmap_Convert($1, output);
out_AbsByteGroup(output, length); sect_AbsByteGroup(output, length);
free(output); free(output);
} }
; ;
@@ -1305,13 +1305,13 @@ constlist_16bit : constlist_16bit_entry
; ;
constlist_16bit_entry : reloc_16bit_no_str { constlist_16bit_entry : reloc_16bit_no_str {
out_RelWord(&$1, 0); sect_RelWord(&$1, 0);
} }
| string { | string {
uint8_t *output = malloc(strlen($1)); /* Cannot be larger than that */ uint8_t *output = malloc(strlen($1)); /* Cannot be larger than that */
int32_t length = charmap_Convert($1, output); int32_t length = charmap_Convert($1, output);
out_AbsWordGroup(output, length); sect_AbsWordGroup(output, length);
free(output); free(output);
} }
; ;
@@ -1321,14 +1321,14 @@ constlist_32bit : constlist_32bit_entry
; ;
constlist_32bit_entry : relocexpr_no_str { constlist_32bit_entry : relocexpr_no_str {
out_RelLong(&$1, 0); sect_RelLong(&$1, 0);
} }
| string { | string {
// Charmaps cannot increase the length of a string // Charmaps cannot increase the length of a string
uint8_t *output = malloc(strlen($1)); uint8_t *output = malloc(strlen($1));
int32_t length = charmap_Convert($1, output); int32_t length = charmap_Convert($1, output);
out_AbsLongGroup(output, length); sect_AbsLongGroup(output, length);
free(output); free(output);
} }
; ;
@@ -1624,7 +1624,7 @@ strfmt_va_args : %empty {
; ;
section : T_POP_SECTION sectmod string T_COMMA sectiontype sectorg sectattrs { section : T_POP_SECTION sectmod string T_COMMA sectiontype sectorg sectattrs {
out_NewSection($3, $5, $6, &$7, $2); sect_NewSection($3, $5, $6, &$7, $2);
} }
; ;
@@ -1722,141 +1722,141 @@ cpu_command : z80_adc
; ;
z80_adc : T_Z80_ADC op_a_n { z80_adc : T_Z80_ADC op_a_n {
out_AbsByte(0xCE); sect_AbsByte(0xCE);
out_RelByte(&$2, 1); sect_RelByte(&$2, 1);
} }
| T_Z80_ADC op_a_r { out_AbsByte(0x88 | $2); } | T_Z80_ADC op_a_r { sect_AbsByte(0x88 | $2); }
; ;
z80_add : T_Z80_ADD op_a_n { z80_add : T_Z80_ADD op_a_n {
out_AbsByte(0xC6); sect_AbsByte(0xC6);
out_RelByte(&$2, 1); sect_RelByte(&$2, 1);
} }
| T_Z80_ADD op_a_r { out_AbsByte(0x80 | $2); } | T_Z80_ADD op_a_r { sect_AbsByte(0x80 | $2); }
| T_Z80_ADD T_MODE_HL T_COMMA reg_ss { out_AbsByte(0x09 | ($4 << 4)); } | T_Z80_ADD T_MODE_HL T_COMMA reg_ss { sect_AbsByte(0x09 | ($4 << 4)); }
| T_Z80_ADD T_MODE_SP T_COMMA reloc_8bit { | T_Z80_ADD T_MODE_SP T_COMMA reloc_8bit {
out_AbsByte(0xE8); sect_AbsByte(0xE8);
out_RelByte(&$4, 1); sect_RelByte(&$4, 1);
} }
; ;
z80_and : T_Z80_AND op_a_n { z80_and : T_Z80_AND op_a_n {
out_AbsByte(0xE6); sect_AbsByte(0xE6);
out_RelByte(&$2, 1); sect_RelByte(&$2, 1);
} }
| T_Z80_AND op_a_r { out_AbsByte(0xA0 | $2); } | T_Z80_AND op_a_r { sect_AbsByte(0xA0 | $2); }
; ;
z80_bit : T_Z80_BIT const_3bit T_COMMA reg_r { z80_bit : T_Z80_BIT const_3bit T_COMMA reg_r {
out_AbsByte(0xCB); sect_AbsByte(0xCB);
out_AbsByte(0x40 | ($2 << 3) | $4); sect_AbsByte(0x40 | ($2 << 3) | $4);
} }
; ;
z80_call : T_Z80_CALL reloc_16bit { z80_call : T_Z80_CALL reloc_16bit {
out_AbsByte(0xCD); sect_AbsByte(0xCD);
out_RelWord(&$2, 1); sect_RelWord(&$2, 1);
} }
| T_Z80_CALL ccode T_COMMA reloc_16bit { | T_Z80_CALL ccode T_COMMA reloc_16bit {
out_AbsByte(0xC4 | ($2 << 3)); sect_AbsByte(0xC4 | ($2 << 3));
out_RelWord(&$4, 1); sect_RelWord(&$4, 1);
} }
; ;
z80_ccf : T_Z80_CCF { out_AbsByte(0x3F); } z80_ccf : T_Z80_CCF { sect_AbsByte(0x3F); }
; ;
z80_cp : T_Z80_CP op_a_n { z80_cp : T_Z80_CP op_a_n {
out_AbsByte(0xFE); sect_AbsByte(0xFE);
out_RelByte(&$2, 1); sect_RelByte(&$2, 1);
} }
| T_Z80_CP op_a_r { out_AbsByte(0xB8 | $2); } | T_Z80_CP op_a_r { sect_AbsByte(0xB8 | $2); }
; ;
z80_cpl : T_Z80_CPL { out_AbsByte(0x2F); } z80_cpl : T_Z80_CPL { sect_AbsByte(0x2F); }
; ;
z80_daa : T_Z80_DAA { out_AbsByte(0x27); } z80_daa : T_Z80_DAA { sect_AbsByte(0x27); }
; ;
z80_dec : T_Z80_DEC reg_r { out_AbsByte(0x05 | ($2 << 3)); } z80_dec : T_Z80_DEC reg_r { sect_AbsByte(0x05 | ($2 << 3)); }
| T_Z80_DEC reg_ss { out_AbsByte(0x0B | ($2 << 4)); } | T_Z80_DEC reg_ss { sect_AbsByte(0x0B | ($2 << 4)); }
; ;
z80_di : T_Z80_DI { out_AbsByte(0xF3); } z80_di : T_Z80_DI { sect_AbsByte(0xF3); }
; ;
z80_ei : T_Z80_EI { out_AbsByte(0xFB); } z80_ei : T_Z80_EI { sect_AbsByte(0xFB); }
; ;
z80_halt : T_Z80_HALT { z80_halt : T_Z80_HALT {
out_AbsByte(0x76); sect_AbsByte(0x76);
if (haltnop) if (haltnop)
out_AbsByte(0x00); sect_AbsByte(0x00);
} }
; ;
z80_inc : T_Z80_INC reg_r { out_AbsByte(0x04 | ($2 << 3)); } z80_inc : T_Z80_INC reg_r { sect_AbsByte(0x04 | ($2 << 3)); }
| T_Z80_INC reg_ss { out_AbsByte(0x03 | ($2 << 4)); } | T_Z80_INC reg_ss { sect_AbsByte(0x03 | ($2 << 4)); }
; ;
z80_jp : T_Z80_JP reloc_16bit { z80_jp : T_Z80_JP reloc_16bit {
out_AbsByte(0xC3); sect_AbsByte(0xC3);
out_RelWord(&$2, 1); sect_RelWord(&$2, 1);
} }
| T_Z80_JP ccode T_COMMA reloc_16bit { | T_Z80_JP ccode T_COMMA reloc_16bit {
out_AbsByte(0xC2 | ($2 << 3)); sect_AbsByte(0xC2 | ($2 << 3));
out_RelWord(&$4, 1); sect_RelWord(&$4, 1);
} }
| T_Z80_JP T_MODE_HL { | T_Z80_JP T_MODE_HL {
out_AbsByte(0xE9); sect_AbsByte(0xE9);
} }
; ;
z80_jr : T_Z80_JR reloc_16bit { z80_jr : T_Z80_JR reloc_16bit {
out_AbsByte(0x18); sect_AbsByte(0x18);
out_PCRelByte(&$2, 1); sect_PCRelByte(&$2, 1);
} }
| T_Z80_JR ccode T_COMMA reloc_16bit { | T_Z80_JR ccode T_COMMA reloc_16bit {
out_AbsByte(0x20 | ($2 << 3)); sect_AbsByte(0x20 | ($2 << 3));
out_PCRelByte(&$4, 1); sect_PCRelByte(&$4, 1);
} }
; ;
z80_ldi : T_Z80_LDI T_LBRACK T_MODE_HL T_RBRACK T_COMMA T_MODE_A { z80_ldi : T_Z80_LDI T_LBRACK T_MODE_HL T_RBRACK T_COMMA T_MODE_A {
out_AbsByte(0x02 | (2 << 4)); sect_AbsByte(0x02 | (2 << 4));
} }
| T_Z80_LDI T_MODE_A T_COMMA T_LBRACK T_MODE_HL T_RBRACK { | T_Z80_LDI T_MODE_A T_COMMA T_LBRACK T_MODE_HL T_RBRACK {
out_AbsByte(0x0A | (2 << 4)); sect_AbsByte(0x0A | (2 << 4));
} }
; ;
z80_ldd : T_Z80_LDD T_LBRACK T_MODE_HL T_RBRACK T_COMMA T_MODE_A { z80_ldd : T_Z80_LDD T_LBRACK T_MODE_HL T_RBRACK T_COMMA T_MODE_A {
out_AbsByte(0x02 | (3 << 4)); sect_AbsByte(0x02 | (3 << 4));
} }
| T_Z80_LDD T_MODE_A T_COMMA T_LBRACK T_MODE_HL T_RBRACK { | T_Z80_LDD T_MODE_A T_COMMA T_LBRACK T_MODE_HL T_RBRACK {
out_AbsByte(0x0A | (3 << 4)); sect_AbsByte(0x0A | (3 << 4));
} }
; ;
z80_ldio : T_Z80_LDH T_MODE_A T_COMMA op_mem_ind { z80_ldio : T_Z80_LDH T_MODE_A T_COMMA op_mem_ind {
rpn_CheckHRAM(&$4, &$4); rpn_CheckHRAM(&$4, &$4);
out_AbsByte(0xF0); sect_AbsByte(0xF0);
out_RelByte(&$4, 1); sect_RelByte(&$4, 1);
} }
| T_Z80_LDH op_mem_ind T_COMMA T_MODE_A { | T_Z80_LDH op_mem_ind T_COMMA T_MODE_A {
rpn_CheckHRAM(&$2, &$2); rpn_CheckHRAM(&$2, &$2);
out_AbsByte(0xE0); sect_AbsByte(0xE0);
out_RelByte(&$2, 1); sect_RelByte(&$2, 1);
} }
| T_Z80_LDH T_MODE_A T_COMMA c_ind { | T_Z80_LDH T_MODE_A T_COMMA c_ind {
out_AbsByte(0xF2); sect_AbsByte(0xF2);
} }
| T_Z80_LDH c_ind T_COMMA T_MODE_A { | T_Z80_LDH c_ind T_COMMA T_MODE_A {
out_AbsByte(0xE2); sect_AbsByte(0xE2);
} }
; ;
@@ -1875,70 +1875,70 @@ z80_ld : z80_ld_mem
; ;
z80_ld_hl : T_Z80_LD T_MODE_HL T_COMMA T_MODE_SP reloc_8bit_offset { z80_ld_hl : T_Z80_LD T_MODE_HL T_COMMA T_MODE_SP reloc_8bit_offset {
out_AbsByte(0xF8); sect_AbsByte(0xF8);
out_RelByte(&$5, 1); sect_RelByte(&$5, 1);
} }
| T_Z80_LD T_MODE_HL T_COMMA reloc_16bit { | T_Z80_LD T_MODE_HL T_COMMA reloc_16bit {
out_AbsByte(0x01 | (REG_HL << 4)); sect_AbsByte(0x01 | (REG_HL << 4));
out_RelWord(&$4, 1); sect_RelWord(&$4, 1);
} }
; ;
z80_ld_sp : T_Z80_LD T_MODE_SP T_COMMA T_MODE_HL { out_AbsByte(0xF9); } z80_ld_sp : T_Z80_LD T_MODE_SP T_COMMA T_MODE_HL { sect_AbsByte(0xF9); }
| T_Z80_LD T_MODE_SP T_COMMA reloc_16bit { | T_Z80_LD T_MODE_SP T_COMMA reloc_16bit {
out_AbsByte(0x01 | (REG_SP << 4)); sect_AbsByte(0x01 | (REG_SP << 4));
out_RelWord(&$4, 1); sect_RelWord(&$4, 1);
} }
; ;
z80_ld_mem : T_Z80_LD op_mem_ind T_COMMA T_MODE_SP { z80_ld_mem : T_Z80_LD op_mem_ind T_COMMA T_MODE_SP {
out_AbsByte(0x08); sect_AbsByte(0x08);
out_RelWord(&$2, 1); sect_RelWord(&$2, 1);
} }
| T_Z80_LD op_mem_ind T_COMMA T_MODE_A { | T_Z80_LD op_mem_ind T_COMMA T_MODE_A {
if (optimizeLoads && rpn_isKnown(&$2) if (optimizeLoads && rpn_isKnown(&$2)
&& $2.val >= 0xFF00) { && $2.val >= 0xFF00) {
out_AbsByte(0xE0); sect_AbsByte(0xE0);
out_AbsByte($2.val & 0xFF); sect_AbsByte($2.val & 0xFF);
rpn_Free(&$2); rpn_Free(&$2);
} else { } else {
out_AbsByte(0xEA); sect_AbsByte(0xEA);
out_RelWord(&$2, 1); sect_RelWord(&$2, 1);
} }
} }
; ;
z80_ld_cind : T_Z80_LD c_ind T_COMMA T_MODE_A { z80_ld_cind : T_Z80_LD c_ind T_COMMA T_MODE_A {
out_AbsByte(0xE2); sect_AbsByte(0xE2);
} }
; ;
z80_ld_rr : T_Z80_LD reg_rr T_COMMA T_MODE_A { z80_ld_rr : T_Z80_LD reg_rr T_COMMA T_MODE_A {
out_AbsByte(0x02 | ($2 << 4)); sect_AbsByte(0x02 | ($2 << 4));
} }
; ;
z80_ld_r : T_Z80_LD reg_r T_COMMA reloc_8bit { z80_ld_r : T_Z80_LD reg_r T_COMMA reloc_8bit {
out_AbsByte(0x06 | ($2 << 3)); sect_AbsByte(0x06 | ($2 << 3));
out_RelByte(&$4, 1); sect_RelByte(&$4, 1);
} }
| T_Z80_LD reg_r T_COMMA reg_r { | T_Z80_LD reg_r T_COMMA reg_r {
if (($2 == REG_HL_IND) && ($4 == REG_HL_IND)) if (($2 == REG_HL_IND) && ($4 == REG_HL_IND))
error("LD [HL],[HL] not a valid instruction\n"); error("LD [HL],[HL] not a valid instruction\n");
else else
out_AbsByte(0x40 | ($2 << 3) | $4); sect_AbsByte(0x40 | ($2 << 3) | $4);
} }
; ;
z80_ld_a : T_Z80_LD reg_r T_COMMA c_ind { z80_ld_a : T_Z80_LD reg_r T_COMMA c_ind {
if ($2 == REG_A) if ($2 == REG_A)
out_AbsByte(0xF2); sect_AbsByte(0xF2);
else else
error("Destination operand must be A\n"); error("Destination operand must be A\n");
} }
| T_Z80_LD reg_r T_COMMA reg_rr { | T_Z80_LD reg_r T_COMMA reg_rr {
if ($2 == REG_A) if ($2 == REG_A)
out_AbsByte(0x0A | ($4 << 4)); sect_AbsByte(0x0A | ($4 << 4));
else else
error("Destination operand must be A\n"); error("Destination operand must be A\n");
} }
@@ -1946,12 +1946,12 @@ z80_ld_a : T_Z80_LD reg_r T_COMMA c_ind {
if ($2 == REG_A) { if ($2 == REG_A) {
if (optimizeLoads && rpn_isKnown(&$4) if (optimizeLoads && rpn_isKnown(&$4)
&& $4.val >= 0xFF00) { && $4.val >= 0xFF00) {
out_AbsByte(0xF0); sect_AbsByte(0xF0);
out_AbsByte($4.val & 0xFF); sect_AbsByte($4.val & 0xFF);
rpn_Free(&$4); rpn_Free(&$4);
} else { } else {
out_AbsByte(0xFA); sect_AbsByte(0xFA);
out_RelWord(&$4, 1); sect_RelWord(&$4, 1);
} }
} else { } else {
error("Destination operand must be A\n"); error("Destination operand must be A\n");
@@ -1961,12 +1961,12 @@ z80_ld_a : T_Z80_LD reg_r T_COMMA c_ind {
; ;
z80_ld_ss : T_Z80_LD T_MODE_BC T_COMMA reloc_16bit { z80_ld_ss : T_Z80_LD T_MODE_BC T_COMMA reloc_16bit {
out_AbsByte(0x01 | (REG_BC << 4)); sect_AbsByte(0x01 | (REG_BC << 4));
out_RelWord(&$4, 1); sect_RelWord(&$4, 1);
} }
| T_Z80_LD T_MODE_DE T_COMMA reloc_16bit { | T_Z80_LD T_MODE_DE T_COMMA reloc_16bit {
out_AbsByte(0x01 | (REG_DE << 4)); sect_AbsByte(0x01 | (REG_DE << 4));
out_RelWord(&$4, 1); sect_RelWord(&$4, 1);
} }
/* /*
* HL is taken care of in z80_ld_hl * HL is taken care of in z80_ld_hl
@@ -1974,143 +1974,143 @@ z80_ld_ss : T_Z80_LD T_MODE_BC T_COMMA reloc_16bit {
*/ */
; ;
z80_nop : T_Z80_NOP { out_AbsByte(0x00); } z80_nop : T_Z80_NOP { sect_AbsByte(0x00); }
; ;
z80_or : T_Z80_OR op_a_n { z80_or : T_Z80_OR op_a_n {
out_AbsByte(0xF6); sect_AbsByte(0xF6);
out_RelByte(&$2, 1); sect_RelByte(&$2, 1);
} }
| T_Z80_OR op_a_r { out_AbsByte(0xB0 | $2); } | T_Z80_OR op_a_r { sect_AbsByte(0xB0 | $2); }
; ;
z80_pop : T_Z80_POP reg_tt { out_AbsByte(0xC1 | ($2 << 4)); } z80_pop : T_Z80_POP reg_tt { sect_AbsByte(0xC1 | ($2 << 4)); }
; ;
z80_push : T_Z80_PUSH reg_tt { out_AbsByte(0xC5 | ($2 << 4)); } z80_push : T_Z80_PUSH reg_tt { sect_AbsByte(0xC5 | ($2 << 4)); }
; ;
z80_res : T_Z80_RES const_3bit T_COMMA reg_r { z80_res : T_Z80_RES const_3bit T_COMMA reg_r {
out_AbsByte(0xCB); sect_AbsByte(0xCB);
out_AbsByte(0x80 | ($2 << 3) | $4); sect_AbsByte(0x80 | ($2 << 3) | $4);
} }
; ;
z80_ret : T_Z80_RET { out_AbsByte(0xC9); } z80_ret : T_Z80_RET { sect_AbsByte(0xC9); }
| T_Z80_RET ccode { out_AbsByte(0xC0 | ($2 << 3)); } | T_Z80_RET ccode { sect_AbsByte(0xC0 | ($2 << 3)); }
; ;
z80_reti : T_Z80_RETI { out_AbsByte(0xD9); } z80_reti : T_Z80_RETI { sect_AbsByte(0xD9); }
; ;
z80_rl : T_Z80_RL reg_r { z80_rl : T_Z80_RL reg_r {
out_AbsByte(0xCB); sect_AbsByte(0xCB);
out_AbsByte(0x10 | $2); sect_AbsByte(0x10 | $2);
} }
; ;
z80_rla : T_Z80_RLA { out_AbsByte(0x17); } z80_rla : T_Z80_RLA { sect_AbsByte(0x17); }
; ;
z80_rlc : T_Z80_RLC reg_r { z80_rlc : T_Z80_RLC reg_r {
out_AbsByte(0xCB); sect_AbsByte(0xCB);
out_AbsByte(0x00 | $2); sect_AbsByte(0x00 | $2);
} }
; ;
z80_rlca : T_Z80_RLCA { out_AbsByte(0x07); } z80_rlca : T_Z80_RLCA { sect_AbsByte(0x07); }
; ;
z80_rr : T_Z80_RR reg_r { z80_rr : T_Z80_RR reg_r {
out_AbsByte(0xCB); sect_AbsByte(0xCB);
out_AbsByte(0x18 | $2); sect_AbsByte(0x18 | $2);
} }
; ;
z80_rra : T_Z80_RRA { out_AbsByte(0x1F); } z80_rra : T_Z80_RRA { sect_AbsByte(0x1F); }
; ;
z80_rrc : T_Z80_RRC reg_r { z80_rrc : T_Z80_RRC reg_r {
out_AbsByte(0xCB); sect_AbsByte(0xCB);
out_AbsByte(0x08 | $2); sect_AbsByte(0x08 | $2);
} }
; ;
z80_rrca : T_Z80_RRCA { out_AbsByte(0x0F); } z80_rrca : T_Z80_RRCA { sect_AbsByte(0x0F); }
; ;
z80_rst : T_Z80_RST reloc_8bit { z80_rst : T_Z80_RST reloc_8bit {
rpn_CheckRST(&$2, &$2); rpn_CheckRST(&$2, &$2);
if (!rpn_isKnown(&$2)) if (!rpn_isKnown(&$2))
out_RelByte(&$2, 0); sect_RelByte(&$2, 0);
else else
out_AbsByte(0xC7 | $2.val); sect_AbsByte(0xC7 | $2.val);
rpn_Free(&$2); rpn_Free(&$2);
} }
; ;
z80_sbc : T_Z80_SBC op_a_n { z80_sbc : T_Z80_SBC op_a_n {
out_AbsByte(0xDE); sect_AbsByte(0xDE);
out_RelByte(&$2, 1); sect_RelByte(&$2, 1);
} }
| T_Z80_SBC op_a_r { out_AbsByte(0x98 | $2); } | T_Z80_SBC op_a_r { sect_AbsByte(0x98 | $2); }
; ;
z80_scf : T_Z80_SCF { out_AbsByte(0x37); } z80_scf : T_Z80_SCF { sect_AbsByte(0x37); }
; ;
z80_set : T_POP_SET const_3bit T_COMMA reg_r { z80_set : T_POP_SET const_3bit T_COMMA reg_r {
out_AbsByte(0xCB); sect_AbsByte(0xCB);
out_AbsByte(0xC0 | ($2 << 3) | $4); sect_AbsByte(0xC0 | ($2 << 3) | $4);
} }
; ;
z80_sla : T_Z80_SLA reg_r { z80_sla : T_Z80_SLA reg_r {
out_AbsByte(0xCB); sect_AbsByte(0xCB);
out_AbsByte(0x20 | $2); sect_AbsByte(0x20 | $2);
} }
; ;
z80_sra : T_Z80_SRA reg_r { z80_sra : T_Z80_SRA reg_r {
out_AbsByte(0xCB); sect_AbsByte(0xCB);
out_AbsByte(0x28 | $2); sect_AbsByte(0x28 | $2);
} }
; ;
z80_srl : T_Z80_SRL reg_r { z80_srl : T_Z80_SRL reg_r {
out_AbsByte(0xCB); sect_AbsByte(0xCB);
out_AbsByte(0x38 | $2); sect_AbsByte(0x38 | $2);
} }
; ;
z80_stop : T_Z80_STOP { z80_stop : T_Z80_STOP {
out_AbsByte(0x10); sect_AbsByte(0x10);
out_AbsByte(0x00); sect_AbsByte(0x00);
} }
| T_Z80_STOP reloc_8bit { | T_Z80_STOP reloc_8bit {
out_AbsByte(0x10); sect_AbsByte(0x10);
out_RelByte(&$2, 1); sect_RelByte(&$2, 1);
} }
; ;
z80_sub : T_Z80_SUB op_a_n { z80_sub : T_Z80_SUB op_a_n {
out_AbsByte(0xD6); sect_AbsByte(0xD6);
out_RelByte(&$2, 1); sect_RelByte(&$2, 1);
} }
| T_Z80_SUB op_a_r { out_AbsByte(0x90 | $2); } | T_Z80_SUB op_a_r { sect_AbsByte(0x90 | $2); }
; ;
z80_swap : T_Z80_SWAP reg_r { z80_swap : T_Z80_SWAP reg_r {
out_AbsByte(0xCB); sect_AbsByte(0xCB);
out_AbsByte(0x30 | $2); sect_AbsByte(0x30 | $2);
} }
; ;
z80_xor : T_Z80_XOR op_a_n { z80_xor : T_Z80_XOR op_a_n {
out_AbsByte(0xEE); sect_AbsByte(0xEE);
out_RelByte(&$2, 1); sect_RelByte(&$2, 1);
} }
| T_Z80_XOR op_a_r { out_AbsByte(0xA8 | $2); } | T_Z80_XOR op_a_r { sect_AbsByte(0xA8 | $2); }
; ;
op_mem_ind : T_LBRACK reloc_16bit T_RBRACK { $$ = $2; } op_mem_ind : T_LBRACK reloc_16bit T_RBRACK { $$ = $2; }

2
src/asm/rpn.c
View File

@@ -185,7 +185,7 @@ void rpn_BankSection(struct Expression *expr, char const *sectionName)
{ {
rpn_Init(expr); rpn_Init(expr);
struct Section *section = out_FindSectionByName(sectionName); struct Section *section = sect_FindSectionByName(sectionName);
if (section && section->bank != (uint32_t)-1) { if (section && section->bank != (uint32_t)-1) {
expr->val = section->bank; expr->val = section->bank;

45
src/asm/section.c
View File

@@ -95,7 +95,7 @@ static void reserveSpace(uint32_t delta_size)
checkSectionSize(currentLoadSection, curOffset + delta_size); checkSectionSize(currentLoadSection, curOffset + delta_size);
} }
struct Section *out_FindSectionByName(const char *name) struct Section *sect_FindSectionByName(const char *name)
{ {
for (struct Section *sect = sectionList; sect; sect = sect->next) { for (struct Section *sect = sectionList; sect; sect = sect->next) {
if (strcmp(name, sect->name) == 0) if (strcmp(name, sect->name) == 0)
@@ -361,7 +361,7 @@ static struct Section *getSection(char const *name, enum SectionType type, uint3
// Check if another section exists with the same name; merge if yes, otherwise create one // Check if another section exists with the same name; merge if yes, otherwise create one
struct Section *sect = out_FindSectionByName(name); struct Section *sect = sect_FindSectionByName(name);
if (sect) { if (sect) {
mergeSections(sect, type, org, bank, alignment, alignOffset, mod); mergeSections(sect, type, org, bank, alignment, alignOffset, mod);
@@ -389,8 +389,8 @@ static void changeSection(void)
/* /*
* Set the current section by name and type * Set the current section by name and type
*/ */
void out_NewSection(char const *name, uint32_t type, uint32_t org, void sect_NewSection(char const *name, uint32_t type, uint32_t org,
struct SectionSpec const *attribs, enum SectionModifier mod) struct SectionSpec const *attribs, enum SectionModifier mod)
{ {
if (currentLoadSection) if (currentLoadSection)
fatalerror("Cannot change the section within a `LOAD` block\n"); fatalerror("Cannot change the section within a `LOAD` block\n");
@@ -410,9 +410,8 @@ void out_NewSection(char const *name, uint32_t type, uint32_t org,
/* /*
* Set the current section by name and type * Set the current section by name and type
*/ */
void out_SetLoadSection(char const *name, uint32_t type, uint32_t org, void sect_SetLoadSection(char const *name, uint32_t type, uint32_t org,
struct SectionSpec const *attribs, struct SectionSpec const *attribs, enum SectionModifier mod)
enum SectionModifier mod)
{ {
if (!checkcodesection()) if (!checkcodesection())
return; return;
@@ -440,7 +439,7 @@ void out_SetLoadSection(char const *name, uint32_t type, uint32_t org,
currentLoadSection = sect; currentLoadSection = sect;
} }
void out_EndLoadSection(void) void sect_EndLoadSection(void)
{ {
if (!currentLoadSection) { if (!currentLoadSection) {
error("Found `ENDL` outside of a `LOAD` block\n"); error("Found `ENDL` outside of a `LOAD` block\n");
@@ -593,7 +592,7 @@ void sect_CheckUnionClosed(void)
/* /*
* Output an absolute byte * Output an absolute byte
*/ */
void out_AbsByte(uint8_t b) void sect_AbsByte(uint8_t b)
{ {
if (!checkcodesection()) if (!checkcodesection())
return; return;
@@ -602,7 +601,7 @@ void out_AbsByte(uint8_t b)
writebyte(b); writebyte(b);
} }
void out_AbsByteGroup(uint8_t const *s, int32_t length) void sect_AbsByteGroup(uint8_t const *s, int32_t length)
{ {
if (!checkcodesection()) if (!checkcodesection())
return; return;
@@ -612,7 +611,7 @@ void out_AbsByteGroup(uint8_t const *s, int32_t length)
writebyte(*s++); writebyte(*s++);
} }
void out_AbsWordGroup(uint8_t const *s, int32_t length) void sect_AbsWordGroup(uint8_t const *s, int32_t length)
{ {
if (!checkcodesection()) if (!checkcodesection())
return; return;
@@ -622,7 +621,7 @@ void out_AbsWordGroup(uint8_t const *s, int32_t length)
writeword(*s++); writeword(*s++);
} }
void out_AbsLongGroup(uint8_t const *s, int32_t length) void sect_AbsLongGroup(uint8_t const *s, int32_t length)
{ {
if (!checkcodesection()) if (!checkcodesection())
return; return;
@@ -635,7 +634,7 @@ void out_AbsLongGroup(uint8_t const *s, int32_t length)
/* /*
* Skip this many bytes * Skip this many bytes
*/ */
void out_Skip(int32_t skip, bool ds) void sect_Skip(int32_t skip, bool ds)
{ {
if (!checksection()) if (!checksection())
return; return;
@@ -658,7 +657,7 @@ void out_Skip(int32_t skip, bool ds)
/* /*
* Output a NULL terminated string (excluding the NULL-character) * Output a NULL terminated string (excluding the NULL-character)
*/ */
void out_String(char const *s) void sect_String(char const *s)
{ {
if (!checkcodesection()) if (!checkcodesection())
return; return;
@@ -672,7 +671,7 @@ void out_String(char const *s)
* Output a relocatable byte. Checking will be done to see if it * Output a relocatable byte. Checking will be done to see if it
* is an absolute value in disguise. * is an absolute value in disguise.
*/ */
void out_RelByte(struct Expression *expr, uint32_t pcShift) void sect_RelByte(struct Expression *expr, uint32_t pcShift)
{ {
if (!checkcodesection()) if (!checkcodesection())
return; return;
@@ -691,7 +690,7 @@ void out_RelByte(struct Expression *expr, uint32_t pcShift)
* Output several copies of a relocatable byte. Checking will be done to see if * Output several copies of a relocatable byte. Checking will be done to see if
* it is an absolute value in disguise. * it is an absolute value in disguise.
*/ */
void out_RelBytes(uint32_t n, struct Expression *exprs, size_t size) void sect_RelBytes(uint32_t n, struct Expression *exprs, size_t size)
{ {
if (!checkcodesection()) if (!checkcodesection())
return; return;
@@ -716,7 +715,7 @@ void out_RelBytes(uint32_t n, struct Expression *exprs, size_t size)
* Output a relocatable word. Checking will be done to see if * Output a relocatable word. Checking will be done to see if
* it's an absolute value in disguise. * it's an absolute value in disguise.
*/ */
void out_RelWord(struct Expression *expr, uint32_t pcShift) void sect_RelWord(struct Expression *expr, uint32_t pcShift)
{ {
if (!checkcodesection()) if (!checkcodesection())
return; return;
@@ -735,7 +734,7 @@ void out_RelWord(struct Expression *expr, uint32_t pcShift)
* Output a relocatable longword. Checking will be done to see if * Output a relocatable longword. Checking will be done to see if
* is an absolute value in disguise. * is an absolute value in disguise.
*/ */
void out_RelLong(struct Expression *expr, uint32_t pcShift) void sect_RelLong(struct Expression *expr, uint32_t pcShift)
{ {
if (!checkcodesection()) if (!checkcodesection())
return; return;
@@ -754,7 +753,7 @@ void out_RelLong(struct Expression *expr, uint32_t pcShift)
* Output a PC-relative relocatable byte. Checking will be done to see if it * Output a PC-relative relocatable byte. Checking will be done to see if it
* is an absolute value in disguise. * is an absolute value in disguise.
*/ */
void out_PCRelByte(struct Expression *expr, uint32_t pcShift) void sect_PCRelByte(struct Expression *expr, uint32_t pcShift)
{ {
if (!checkcodesection()) if (!checkcodesection())
return; return;
@@ -789,7 +788,7 @@ void out_PCRelByte(struct Expression *expr, uint32_t pcShift)
/* /*
* Output a binary file * Output a binary file
*/ */
void out_BinaryFile(char const *s, int32_t startPos) void sect_BinaryFile(char const *s, int32_t startPos)
{ {
if (startPos < 0) { if (startPos < 0) {
error("Start position cannot be negative (%" PRId32 ")\n", startPos); error("Start position cannot be negative (%" PRId32 ")\n", startPos);
@@ -852,7 +851,7 @@ cleanup:
fclose(f); fclose(f);
} }
void out_BinaryFileSlice(char const *s, int32_t start_pos, int32_t length) void sect_BinaryFileSlice(char const *s, int32_t start_pos, int32_t length)
{ {
if (start_pos < 0) { if (start_pos < 0) {
error("Start position cannot be negative (%" PRId32 ")\n", start_pos); error("Start position cannot be negative (%" PRId32 ")\n", start_pos);
@@ -937,7 +936,7 @@ cleanup:
/* /*
* Section stack routines * Section stack routines
*/ */
void out_PushSection(void) void sect_PushSection(void)
{ {
struct SectionStackEntry *sect = malloc(sizeof(*sect)); struct SectionStackEntry *sect = malloc(sizeof(*sect));
@@ -957,7 +956,7 @@ void out_PushSection(void)
sym_SetCurrentSymbolScope(NULL); sym_SetCurrentSymbolScope(NULL);
} }
void out_PopSection(void) void sect_PopSection(void)
{ {
if (!sectionStack) if (!sectionStack)
fatalerror("No entries in the section stack\n"); fatalerror("No entries in the section stack\n");