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

Pass std::string references to symbol functions

Browse Source
This commit is contained in:
Rangi42
2024-03-18 13:29:09 -04:00
committed by Sylvie
parent 6cabb8c9af
commit 472d1bde06
9 changed files with 174 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/asm/fstack.hpp
View File

@@ -61,10 +61,10 @@ std::optional<std::string> fstk_FindFile(char const *path);
bool yywrap();
void fstk_RunInclude(char const *path);
void fstk_RunMacro(char const *macroName, MacroArgs &args);
void fstk_RunMacro(std::string const &macroName, MacroArgs &args);
void fstk_RunRept(uint32_t count, int32_t reptLineNo, char const *body, size_t size);
void fstk_RunFor(
char const *symName,
std::string const &symName,
int32_t start,
int32_t stop,
int32_t step,

4
include/asm/rpn.hpp
View File

@@ -34,7 +34,7 @@ struct Expression {
};
void rpn_Number(Expression &expr, uint32_t val);
void rpn_Symbol(Expression &expr, char const *symName);
void rpn_Symbol(Expression &expr, std::string const &symName);
void rpn_LOGNOT(Expression &expr, Expression &&src);
void rpn_BinaryOp(RPNCommand op, Expression &expr, Expression &&src1, Expression const &src2);
void rpn_HIGH(Expression &expr, Expression &&src);
@@ -42,7 +42,7 @@ void rpn_LOW(Expression &expr, Expression &&src);
void rpn_ISCONST(Expression &expr, Expression const &src);
void rpn_NEG(Expression &expr, Expression &&src);
void rpn_NOT(Expression &expr, Expression &&src);
void rpn_BankSymbol(Expression &expr, char const *symName);
void rpn_BankSymbol(Expression &expr, std::string const &symName);
void rpn_BankSection(Expression &expr, char const *sectionName);
void rpn_BankSelf(Expression &expr);
void rpn_SizeOfSection(Expression &expr, char const *sectionName);

30
include/asm/symbol.hpp
View File

@@ -68,27 +68,29 @@ struct Symbol {
void sym_ForEach(void (*func)(Symbol &));
void sym_SetExportAll(bool set);
Symbol *sym_AddLocalLabel(char const *symName);
Symbol *sym_AddLabel(char const *symName);
Symbol *sym_AddLocalLabel(std::string const &symName);
Symbol *sym_AddLabel(std::string const &symName);
Symbol *sym_AddAnonLabel();
std::string sym_MakeAnonLabelName(uint32_t ofs, bool neg);
void sym_Export(char const *symName);
Symbol *sym_AddEqu(char const *symName, int32_t value);
Symbol *sym_RedefEqu(char const *symName, int32_t value);
Symbol *sym_AddVar(char const *symName, int32_t value);
void sym_Export(std::string const &symName);
Symbol *sym_AddEqu(std::string const &symName, int32_t value);
Symbol *sym_RedefEqu(std::string const &symName, int32_t value);
Symbol *sym_AddVar(std::string const &symName, int32_t value);
uint32_t sym_GetPCValue();
uint32_t sym_GetConstantValue(char const *symName);
int32_t sym_GetRSValue();
void sym_SetRSValue(int32_t value);
uint32_t sym_GetConstantValue(std::string const &symName);
// Find a symbol by exact name, bypassing expansion checks
Symbol *sym_FindExactSymbol(char const *symName);
Symbol *sym_FindExactSymbol(std::string const &symName);
// Find a symbol, possibly scoped, by name
Symbol *sym_FindScopedSymbol(char const *symName);
Symbol *sym_FindScopedSymbol(std::string const &symName);
// Find a scoped symbol by name; do not return `@` or `_NARG` when they have no value
Symbol *sym_FindScopedValidSymbol(char const *symName);
Symbol *sym_FindScopedValidSymbol(std::string const &symName);
Symbol const *sym_GetPC();
Symbol *sym_AddMacro(char const *symName, int32_t defLineNo, char const *body, size_t size);
Symbol *sym_Ref(char const *symName);
Symbol *sym_AddString(char const *symName, char const *value);
Symbol *sym_RedefString(char const *symName, char const *value);
Symbol *sym_AddMacro(std::string const &symName, int32_t defLineNo, char const *body, size_t size);
Symbol *sym_Ref(std::string const &symName);
Symbol *sym_AddString(std::string const &symName, char const *value);
Symbol *sym_RedefString(std::string const &symName, char const *value);
void sym_Purge(std::string const &symName);
void sym_Init(time_t now);

10
src/asm/fstack.cpp
View File

@@ -198,7 +198,7 @@ bool yywrap() {
// Avoid arithmetic overflow runtime error
uint32_t forValue = (uint32_t)context.forValue + (uint32_t)context.forStep;
context.forValue = forValue <= INT32_MAX ? forValue : -(int32_t)~forValue - 1;
Symbol *sym = sym_AddVar(context.forName.c_str(), context.forValue);
Symbol *sym = sym_AddVar(context.forName, context.forValue);
// This error message will refer to the current iteration
if (sym->type != SYM_VAR)
@@ -309,15 +309,15 @@ static void runPreIncludeFile() {
context.uniqueID = macro_UndefUniqueID();
}
void fstk_RunMacro(char const *macroName, MacroArgs &args) {
void fstk_RunMacro(std::string const &macroName, MacroArgs &args) {
Symbol *macro = sym_FindExactSymbol(macroName);
if (!macro) {
error("Macro \"%s\" not defined\n", macroName);
error("Macro \"%s\" not defined\n", macroName.c_str());
return;
}
if (macro->type != SYM_MACRO) {
error("\"%s\" is not a macro\n", macroName);
error("\"%s\" is not a macro\n", macroName.c_str());
return;
}
contextStack.top().macroArgs = macro_GetCurrentArgs();
@@ -392,7 +392,7 @@ void fstk_RunRept(uint32_t count, int32_t reptLineNo, char const *body, size_t s
}
void fstk_RunFor(
char const *symName,
std::string const &symName,
int32_t start,
int32_t stop,
int32_t step,

7
src/asm/lexer.cpp
View File

@@ -558,7 +558,7 @@ static uint32_t readBracketedMacroArgNum() {
shiftChar();
}
Symbol const *sym = sym_FindScopedValidSymbol(symName.c_str());
Symbol const *sym = sym_FindScopedValidSymbol(symName);
if (!sym) {
error("Bracketed symbol \"%s\" does not exist\n", symName.c_str());
@@ -1188,7 +1188,7 @@ static char const *readInterpolation(size_t depth) {
static char buf[MAXSTRLEN + 1];
Symbol const *sym = sym_FindScopedValidSymbol(fmtBuf.c_str());
Symbol const *sym = sym_FindScopedValidSymbol(fmtBuf);
if (!sym) {
error("Interpolated symbol \"%s\" does not exist\n", fmtBuf.c_str());
@@ -1820,8 +1820,7 @@ static Token yylex_NORMAL() {
// Local symbols cannot be string expansions
if (token.type == T_(ID) && lexerState->expandStrings) {
// Attempt string expansion
Symbol const *sym =
sym_FindExactSymbol(std::get<std::string>(token.value).c_str());
Symbol const *sym = sym_FindExactSymbol(std::get<std::string>(token.value));
if (sym && sym->type == SYM_EQUS) {
char const *str = sym->getEqus()->c_str();

6
src/asm/output.cpp
View File

@@ -187,10 +187,10 @@ static void writerpn(std::vector<uint8_t> &rpnexpr, std::vector<uint8_t> const &
}
// The symbol name is always written expanded
sym = sym_FindExactSymbol(symName.c_str());
sym = sym_FindExactSymbol(symName);
if (sym->isConstant()) {
rpnexpr[rpnptr++] = RPN_CONST;
value = sym_GetConstantValue(symName.c_str());
value = sym_GetConstantValue(symName);
} else {
rpnexpr[rpnptr++] = RPN_SYM;
value = getSymbolID(*sym);
@@ -212,7 +212,7 @@ static void writerpn(std::vector<uint8_t> &rpnexpr, std::vector<uint8_t> const &
}
// The symbol name is always written expanded
sym = sym_FindExactSymbol(symName.c_str());
sym = sym_FindExactSymbol(symName);
value = getSymbolID(*sym);
rpnexpr[rpnptr++] = RPN_BANK_SYM;

90
src/asm/parser.y
View File

@@ -68,6 +68,8 @@
#include "helpers.hpp"
using namespace std::literals;
static CaptureBody captureBody; // Captures a REPT/FOR or MACRO
yy::parser::symbol_type yylex(); // Provided by lexer.cpp
@@ -351,7 +353,7 @@ line:
lexer_SetMode(LEXER_NORMAL);
lexer_ToggleStringExpansion(true);
} endofline {
Symbol *macro = sym_FindExactSymbol($1.c_str());
Symbol *macro = sym_FindExactSymbol($1);
if (macro && macro->type == SYM_MACRO)
fprintf(
@@ -488,21 +490,21 @@ label:
sym_AddAnonLabel();
}
| LOCAL_ID {
sym_AddLocalLabel($1.c_str());
sym_AddLocalLabel($1);
}
| LOCAL_ID COLON {
sym_AddLocalLabel($1.c_str());
sym_AddLocalLabel($1);
}
| LABEL COLON {
sym_AddLabel($1.c_str());
sym_AddLabel($1);
}
| LOCAL_ID DOUBLE_COLON {
sym_AddLocalLabel($1.c_str());
sym_Export($1.c_str());
sym_AddLocalLabel($1);
sym_Export($1);
}
| LABEL DOUBLE_COLON {
sym_AddLabel($1.c_str());
sym_Export($1.c_str());
sym_AddLabel($1);
sym_Export($1);
}
;
@@ -511,7 +513,7 @@ macro:
// Parsing 'macroargs' will restore the lexer's normal mode
lexer_SetMode(LEXER_RAW);
} macroargs {
fstk_RunMacro($1.c_str(), *$3);
fstk_RunMacro($1, *$3);
}
;
@@ -617,14 +619,14 @@ equ:
$1.c_str(),
$1.c_str()
);
sym_AddEqu($1.c_str(), $3);
sym_AddEqu($1, $3);
}
;
assignment:
LABEL POP_EQUAL const {
warning(WARNING_OBSOLETE, "`%s =` is deprecated; use `DEF %s =`\n", $1.c_str(), $1.c_str());
sym_AddVar($1.c_str(), $3);
sym_AddVar($1, $3);
}
| LABEL compoundeq const {
char const *compoundEqOperator = nullptr;
@@ -662,7 +664,7 @@ equs:
$1.c_str(),
$1.c_str()
);
sym_AddString($1.c_str(), $3.c_str());
sym_AddString($1, $3.c_str());
}
;
@@ -674,8 +676,9 @@ rb:
$1.c_str(),
$1.c_str()
);
sym_AddEqu($1.c_str(), sym_GetConstantValue("_RS"));
sym_AddVar("_RS", sym_GetConstantValue("_RS") + $3);
uint32_t rs = sym_GetRSValue();
sym_AddEqu($1, rs);
sym_SetRSValue(rs + $3);
}
;
@@ -687,8 +690,9 @@ rw:
$1.c_str(),
$1.c_str()
);
sym_AddEqu($1.c_str(), sym_GetConstantValue("_RS"));
sym_AddVar("_RS", sym_GetConstantValue("_RS") + 2 * $3);
uint32_t rs = sym_GetRSValue();
sym_AddEqu($1, rs);
sym_SetRSValue(rs + 2 * $3);
}
;
@@ -700,8 +704,9 @@ rl:
$1.c_str(),
$1.c_str()
);
sym_AddEqu($1.c_str(), sym_GetConstantValue("_RS"));
sym_AddVar("_RS", sym_GetConstantValue("_RS") + 4 * $3);
uint32_t rs = sym_GetRSValue();
sym_AddEqu($1, rs);
sym_SetRSValue(rs + 4 * $3);
}
;
@@ -872,7 +877,7 @@ for:
} COMMA for_args NEWLINE capture_rept endofline {
if ($8)
fstk_RunFor(
$3.c_str(),
$3,
$6.start,
$6.stop,
$6.step,
@@ -921,7 +926,7 @@ macrodef:
lexer_ToggleStringExpansion(true);
} NEWLINE capture_macro endofline {
if ($6)
sym_AddMacro($3.c_str(), captureBody.lineNo, captureBody.body, captureBody.size);
sym_AddMacro($3, captureBody.lineNo, captureBody.body, captureBody.size);
}
;
@@ -933,13 +938,13 @@ capture_macro:
rsset:
POP_RSSET uconst {
sym_AddVar("_RS", $2);
sym_SetRSValue($2);
}
;
rsreset:
POP_RSRESET {
sym_AddVar("_RS", 0);
sym_SetRSValue(0);
}
;
@@ -1022,22 +1027,22 @@ dl:
def_equ:
def_id POP_EQU const {
sym_AddEqu($1.c_str(), $3);
sym_AddEqu($1, $3);
}
;
redef_equ:
redef_id POP_EQU const {
sym_RedefEqu($1.c_str(), $3);
sym_RedefEqu($1, $3);
}
;
def_set:
def_id POP_EQUAL const {
sym_AddVar($1.c_str(), $3);
sym_AddVar($1, $3);
}
| redef_id POP_EQUAL const {
sym_AddVar($1.c_str(), $3);
sym_AddVar($1, $3);
}
| def_id compoundeq const {
compoundAssignment($1, $2, $3);
@@ -1049,34 +1054,37 @@ def_set:
def_rb:
def_id POP_RB rs_uconst {
sym_AddEqu($1.c_str(), sym_GetConstantValue("_RS"));
sym_AddVar("_RS", sym_GetConstantValue("_RS") + $3);
uint32_t rs = sym_GetRSValue();
sym_AddEqu($1, rs);
sym_SetRSValue(rs + $3);
}
;
def_rw:
def_id POP_RW rs_uconst {
sym_AddEqu($1.c_str(), sym_GetConstantValue("_RS"));
sym_AddVar("_RS", sym_GetConstantValue("_RS") + 2 * $3);
uint32_t rs = sym_GetRSValue();
sym_AddEqu($1, rs);
sym_SetRSValue(rs + 2 * $3);
}
;
def_rl:
def_id Z80_RL rs_uconst {
sym_AddEqu($1.c_str(), sym_GetConstantValue("_RS"));
sym_AddVar("_RS", sym_GetConstantValue("_RS") + 4 * $3);
uint32_t rs = sym_GetRSValue();
sym_AddEqu($1, rs);
sym_SetRSValue(rs + 4 * $3);
}
;
def_equs:
def_id POP_EQUS string {
sym_AddString($1.c_str(), $3.c_str());
sym_AddString($1, $3.c_str());
}
;
redef_equs:
redef_id POP_EQUS string {
sym_RedefString($1.c_str(), $3.c_str());
sym_RedefString($1, $3.c_str());
}
;
@@ -1109,7 +1117,7 @@ export_list:
export_list_entry:
scoped_id {
sym_Export($1.c_str());
sym_Export($1);
}
;
@@ -1316,7 +1324,7 @@ relocexpr:
relocexpr_no_str:
scoped_anon_id {
rpn_Symbol($$, $1.c_str());
rpn_Symbol($$, $1);
}
| NUMBER {
rpn_Number($$, $1);
@@ -1404,7 +1412,7 @@ relocexpr_no_str:
}
| OP_BANK LPAREN scoped_anon_id RPAREN {
// '@' is also an ID; it is handled here
rpn_BankSymbol($$, $3.c_str());
rpn_BankSymbol($$, $3);
}
| OP_BANK LPAREN string RPAREN {
rpn_BankSection($$, $3.c_str());
@@ -1424,7 +1432,7 @@ relocexpr_no_str:
| OP_DEF {
lexer_ToggleStringExpansion(false);
} LPAREN scoped_anon_id RPAREN {
rpn_Number($$, sym_FindScopedValidSymbol($4.c_str()) != nullptr);
rpn_Number($$, sym_FindScopedValidSymbol($4) != nullptr);
lexer_ToggleStringExpansion(true);
}
| OP_ROUND LPAREN const opt_q_arg RPAREN {
@@ -1581,7 +1589,7 @@ string:
$$ = strfmt($3.format, $3.args);
}
| POP_SECTION LPAREN scoped_anon_id RPAREN {
Symbol *sym = sym_FindScopedValidSymbol($3.c_str());
Symbol *sym = sym_FindScopedValidSymbol($3);
if (!sym)
fatalerror("Unknown symbol \"%s\"\n", $3.c_str());
@@ -2716,11 +2724,11 @@ static void compoundAssignment(std::string const &symName, RPNCommand op, int32_
Expression oldExpr, constExpr, newExpr;
int32_t newValue;
rpn_Symbol(oldExpr, symName.c_str());
rpn_Symbol(oldExpr, symName);
rpn_Number(constExpr, constValue);
rpn_BinaryOp(op, newExpr, std::move(oldExpr), constExpr);
newValue = newExpr.getConstVal();
sym_AddVar(symName.c_str(), newValue);
sym_AddVar(symName, newValue);
}
static void failAssert(AssertionType type) {

5
src/asm/rpn.cpp
View File

@@ -10,6 +10,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string_view>
#include "opmath.hpp"
@@ -50,7 +51,7 @@ void rpn_Number(Expression &expr, uint32_t val) {
expr.val = val;
}
void rpn_Symbol(Expression &expr, char const *symName) {
void rpn_Symbol(Expression &expr, std::string const &symName) {
initExpression(expr);
Symbol *sym = sym_FindScopedSymbol(symName);
@@ -92,7 +93,7 @@ static void bankSelf(Expression &expr) {
}
}
void rpn_BankSymbol(Expression &expr, char const *symName) {
void rpn_BankSymbol(Expression &expr, std::string const &symName) {
Symbol const *sym = sym_FindScopedSymbol(symName);
// The @ symbol is treated differently.

171
src/asm/symbol.cpp
View File

@@ -22,11 +22,14 @@
#include "asm/output.hpp"
#include "asm/warning.hpp"
using namespace std::literals;
std::unordered_map<std::string, Symbol> symbols;
static std::optional<std::string> labelScope = std::nullopt; // Current section's label scope
static Symbol *PCSymbol;
static Symbol *_NARGSymbol;
static Symbol *_RSSymbol;
static char savedTIME[256];
static char savedDATE[256];
static char savedTIMESTAMP_ISO8601_LOCAL[256];
@@ -113,7 +116,7 @@ static void updateSymbolFilename(Symbol &sym) {
}
// Create a new symbol by name
static Symbol &createsymbol(char const *symName) {
static Symbol &createsymbol(std::string const &symName) {
Symbol &sym = symbols[symName];
sym.name = symName;
@@ -134,26 +137,25 @@ static void assignStringSymbol(Symbol &sym, char const *value) {
sym.data = equs;
}
Symbol *sym_FindExactSymbol(char const *symName) {
Symbol *sym_FindExactSymbol(std::string const &symName) {
auto search = symbols.find(symName);
return search != symbols.end() ? &search->second : nullptr;
}
Symbol *sym_FindScopedSymbol(char const *symName) {
if (char const *localName = strchr(symName, '.'); localName) {
if (strchr(localName + 1, '.'))
fatalerror("'%s' is a nonsensical reference to a nested local symbol\n", symName);
Symbol *sym_FindScopedSymbol(std::string const &symName) {
if (size_t dotPos = symName.find('.'); dotPos != std::string::npos) {
if (symName.find('.', dotPos + 1) != std::string::npos)
fatalerror(
"'%s' is a nonsensical reference to a nested local symbol\n", symName.c_str()
);
// If auto-scoped local label, expand the name
if (localName == symName) { // Meaning, the name begins with the dot
std::string fullName = labelScope ? *labelScope + symName : symName;
return sym_FindExactSymbol(fullName.c_str());
}
if (dotPos == 0 && labelScope)
return sym_FindExactSymbol(*labelScope + symName);
}
return sym_FindExactSymbol(symName);
}
Symbol *sym_FindScopedValidSymbol(char const *symName) {
Symbol *sym_FindScopedValidSymbol(std::string const &symName) {
Symbol *sym = sym_FindScopedSymbol(symName);
// `@` has no value outside a section
@@ -173,7 +175,7 @@ Symbol const *sym_GetPC() {
// Purge a symbol
void sym_Purge(std::string const &symName) {
Symbol *sym = sym_FindScopedValidSymbol(symName.c_str());
Symbol *sym = sym_FindScopedValidSymbol(symName);
if (!sym) {
error("'%s' not defined\n", symName.c_str());
@@ -205,6 +207,15 @@ uint32_t sym_GetPCValue() {
return 0;
}
int32_t sym_GetRSValue() {
return _RSSymbol->getOutputValue();
}
void sym_SetRSValue(int32_t value) {
updateSymbolFilename(*_RSSymbol);
_RSSymbol->data = value;
}
// Return a constant symbol's value, assuming it's defined
uint32_t Symbol::getConstantValue() const {
if (sym_IsPC(this))
@@ -218,11 +229,11 @@ uint32_t Symbol::getConstantValue() const {
}
// Return a constant symbol's value
uint32_t sym_GetConstantValue(char const *symName) {
uint32_t sym_GetConstantValue(std::string const &symName) {
if (Symbol const *sym = sym_FindScopedSymbol(symName); sym)
return sym->getConstantValue();
error("'%s' not defined\n", symName);
error("'%s' not defined\n", symName.c_str());
return 0;
}
@@ -241,19 +252,19 @@ void sym_SetCurrentSymbolScope(std::optional<std::string> const &newScope) {
* @param symName The name of the symbol to create
* @param numeric If false, the symbol may not have been referenced earlier
*/
static Symbol *createNonrelocSymbol(char const *symName, bool numeric) {
static Symbol *createNonrelocSymbol(std::string const &symName, bool numeric) {
Symbol *sym = sym_FindExactSymbol(symName);
if (!sym) {
sym = &createsymbol(symName);
} else if (sym->isDefined()) {
error("'%s' already defined at ", symName);
error("'%s' already defined at ", symName.c_str());
dumpFilename(*sym);
putc('\n', stderr);
return nullptr; // Don't allow overriding the symbol, that'd be bad!
} else if (!numeric) {
// The symbol has already been referenced, but it's not allowed
error("'%s' already referenced at ", symName);
error("'%s' already referenced at ", symName.c_str());
dumpFilename(*sym);
putc('\n', stderr);
return nullptr; // Don't allow overriding the symbol, that'd be bad!
@@ -263,7 +274,7 @@ static Symbol *createNonrelocSymbol(char const *symName, bool numeric) {
}
// Add an equated symbol
Symbol *sym_AddEqu(char const *symName, int32_t value) {
Symbol *sym_AddEqu(std::string const &symName, int32_t value) {
Symbol *sym = createNonrelocSymbol(symName, true);
if (!sym)
@@ -275,19 +286,19 @@ Symbol *sym_AddEqu(char const *symName, int32_t value) {
return sym;
}
Symbol *sym_RedefEqu(char const *symName, int32_t value) {
Symbol *sym_RedefEqu(std::string const &symName, int32_t value) {
Symbol *sym = sym_FindExactSymbol(symName);
if (!sym)
return sym_AddEqu(symName, value);
if (sym->isDefined() && sym->type != SYM_EQU) {
error("'%s' already defined as non-EQU at ", symName);
error("'%s' already defined as non-EQU at ", symName.c_str());
dumpFilename(*sym);
putc('\n', stderr);
return nullptr;
} else if (sym->isBuiltin) {
error("Built-in symbol '%s' cannot be redefined\n", symName);
error("Built-in symbol '%s' cannot be redefined\n", symName.c_str());
return nullptr;
}
@@ -302,15 +313,15 @@ Symbol *sym_RedefEqu(char const *symName, int32_t value) {
* Add a string equated symbol.
*
* If the desired symbol is a string it needs to be passed to this function with
* quotes inside the string, like sym_AddString("name", "\"test\"), or the
* quotes inside the string, like sym_AddString("name"s, "\"test\"), or the
* assembler won't be able to use it with DB and similar. This is equivalent to
* ``` name EQUS "\"test\"" ```
*
* If the desired symbol is a register or a number, just the terminator quotes
* of the string are enough: sym_AddString("M_PI", "3.1415"). This is the same
* of the string are enough: sym_AddString("M_PI"s, "3.1415"). This is the same
* as ``` M_PI EQUS "3.1415" ```
*/
Symbol *sym_AddString(char const *symName, char const *value) {
Symbol *sym_AddString(std::string const &symName, char const *value) {
Symbol *sym = createNonrelocSymbol(symName, false);
if (!sym)
@@ -320,7 +331,7 @@ Symbol *sym_AddString(char const *symName, char const *value) {
return sym;
}
Symbol *sym_RedefString(char const *symName, char const *value) {
Symbol *sym_RedefString(std::string const &symName, char const *value) {
Symbol *sym = sym_FindExactSymbol(symName);
if (!sym)
@@ -328,14 +339,14 @@ Symbol *sym_RedefString(char const *symName, char const *value) {
if (sym->type != SYM_EQUS) {
if (sym->isDefined())
error("'%s' already defined as non-EQUS at ", symName);
error("'%s' already defined as non-EQUS at ", symName.c_str());
else
error("'%s' already referenced at ", symName);
error("'%s' already referenced at ", symName.c_str());
dumpFilename(*sym);
putc('\n', stderr);
return nullptr;
} else if (sym->isBuiltin) {
error("Built-in symbol '%s' cannot be redefined\n", symName);
error("Built-in symbol '%s' cannot be redefined\n", symName.c_str());
return nullptr;
}
@@ -348,14 +359,16 @@ Symbol *sym_RedefString(char const *symName, char const *value) {
}
// Alter a mutable symbol's value
Symbol *sym_AddVar(char const *symName, int32_t value) {
Symbol *sym_AddVar(std::string const &symName, int32_t value) {
Symbol *sym = sym_FindExactSymbol(symName);
if (!sym) {
sym = &createsymbol(symName);
} else if (sym->isDefined() && sym->type != SYM_VAR) {
error(
"'%s' already defined as %s at ", symName, sym->type == SYM_LABEL ? "label" : "constant"
"'%s' already defined as %s at ",
symName.c_str(),
sym->type == SYM_LABEL ? "label" : "constant"
);
dumpFilename(*sym);
putc('\n', stderr);
@@ -375,14 +388,14 @@ Symbol *sym_AddVar(char const *symName, int32_t value) {
* @param symName The label's full name (so `.name` is invalid)
* @return The created symbol
*/
static Symbol *addLabel(char const *symName) {
assert(symName[0] != '.'); // The symbol name must have been expanded prior
static Symbol *addLabel(std::string const &symName) {
assert(!symName.starts_with('.')); // The symbol name must have been expanded prior
Symbol *sym = sym_FindExactSymbol(symName);
if (!sym) {
sym = &createsymbol(symName);
} else if (sym->isDefined()) {
error("'%s' already defined at ", symName);
error("'%s' already defined at ", symName.c_str());
dumpFilename(*sym);
putc('\n', stderr);
return nullptr;
@@ -393,48 +406,45 @@ static Symbol *addLabel(char const *symName) {
sym->type = SYM_LABEL;
sym->data = (int32_t)sect_GetSymbolOffset();
// Don't export anonymous labels
if (exportAll && symName[0] != '!')
if (exportAll && !symName.starts_with('!'))
sym->isExported = true;
sym->section = sect_GetSymbolSection();
if (sym && !sym->section)
error("Label \"%s\" created outside of a SECTION\n", symName);
error("Label \"%s\" created outside of a SECTION\n", symName.c_str());
return sym;
}
// Add a local (`.name` or `Parent.name`) relocatable symbol
Symbol *sym_AddLocalLabel(char const *symName) {
Symbol *sym_AddLocalLabel(std::string const &symName) {
// Assuming no dots in `labelScope` if defined
assert(!labelScope.has_value() || labelScope->find('.') == std::string::npos);
char const *localName = strchr(symName, '.');
size_t dotPos = symName.find('.');
assert(localName); // There should be at least one dot in `symName`
assert(dotPos != std::string::npos); // There should be at least one dot in `symName`
// Check for something after the dot in `localName`
if (localName[1] == '\0') {
fatalerror("'%s' is a nonsensical reference to an empty local label\n", symName);
// Check for something after the dot
if (dotPos == symName.length() - 1) {
fatalerror("'%s' is a nonsensical reference to an empty local label\n", symName.c_str());
}
// Check for more than one dot in `localName`
if (strchr(localName + 1, '.'))
fatalerror("'%s' is a nonsensical reference to a nested local label\n", symName);
// Check for more than one dot
if (symName.find('.', dotPos + 1) != std::string::npos)
fatalerror("'%s' is a nonsensical reference to a nested local label\n", symName.c_str());
if (localName == symName) {
if (dotPos == 0) {
if (!labelScope.has_value()) {
error("Unqualified local label '%s' in main scope\n", symName);
error("Unqualified local label '%s' in main scope\n", symName.c_str());
return nullptr;
}
std::string fullName = *labelScope + symName;
return addLabel(fullName.c_str());
} else {
return addLabel(symName);
return addLabel(*labelScope + symName);
}
return addLabel(symName);
}
// Add a relocatable symbol
Symbol *sym_AddLabel(char const *symName) {
Symbol *sym_AddLabel(std::string const &symName) {
Symbol *sym = addLabel(symName);
// Set the symbol as the new scope
@@ -454,7 +464,7 @@ Symbol *sym_AddAnonLabel() {
std::string anon = sym_MakeAnonLabelName(0, true); // The direction is important!
anonLabelID++;
return addLabel(anon.c_str());
return addLabel(anon);
}
// Write an anonymous label's name to a buffer
@@ -491,8 +501,8 @@ std::string sym_MakeAnonLabelName(uint32_t ofs, bool neg) {
}
// Export a symbol
void sym_Export(char const *symName) {
if (symName[0] == '!') {
void sym_Export(std::string const &symName) {
if (symName.starts_with('!')) {
error("Anonymous labels cannot be exported\n");
return;
}
@@ -506,7 +516,7 @@ void sym_Export(char const *symName) {
}
// Add a macro definition
Symbol *sym_AddMacro(char const *symName, int32_t defLineNo, char const *body, size_t size) {
Symbol *sym_AddMacro(std::string const &symName, int32_t defLineNo, char const *body, size_t size) {
Symbol *sym = createNonrelocSymbol(symName, false);
if (!sym)
@@ -528,16 +538,16 @@ Symbol *sym_AddMacro(char const *symName, int32_t defLineNo, char const *body, s
// Flag that a symbol is referenced in an RPN expression
// and create it if it doesn't exist yet
Symbol *sym_Ref(char const *symName) {
Symbol *sym_Ref(std::string const &symName) {
Symbol *sym = sym_FindScopedSymbol(symName);
if (!sym) {
if (symName[0] == '.') {
if (symName.starts_with('.')) {
if (!labelScope.has_value())
fatalerror("Local label reference '%s' in main scope\n", symName);
fatalerror("Local label reference '%s' in main scope\n", symName.c_str());
std::string fullName = *labelScope + symName;
sym = &createsymbol(fullName.c_str());
sym = &createsymbol(fullName);
} else {
sym = &createsymbol(symName);
}
@@ -553,7 +563,7 @@ void sym_SetExportAll(bool set) {
exportAll = set;
}
static Symbol *createBuiltinSymbol(char const *symName) {
static Symbol *createBuiltinSymbol(std::string const &symName) {
Symbol *sym = &createsymbol(symName);
sym->isBuiltin = true;
@@ -565,22 +575,23 @@ static Symbol *createBuiltinSymbol(char const *symName) {
// Initialize the symboltable
void sym_Init(time_t now) {
PCSymbol = createBuiltinSymbol("@");
PCSymbol = createBuiltinSymbol("@"s);
PCSymbol->type = SYM_LABEL;
PCSymbol->data = CallbackPC;
_NARGSymbol = createBuiltinSymbol("_NARG");
_NARGSymbol = createBuiltinSymbol("_NARG"s);
_NARGSymbol->type = SYM_EQU;
_NARGSymbol->data = Callback_NARG;
sym_AddVar("_RS", 0)->isBuiltin = true;
_RSSymbol = sym_AddVar("_RS"s, 0);
_RSSymbol->isBuiltin = true;
sym_AddString("__RGBDS_VERSION__", get_package_version_string())->isBuiltin = true;
sym_AddEqu("__RGBDS_MAJOR__", PACKAGE_VERSION_MAJOR)->isBuiltin = true;
sym_AddEqu("__RGBDS_MINOR__", PACKAGE_VERSION_MINOR)->isBuiltin = true;
sym_AddEqu("__RGBDS_PATCH__", PACKAGE_VERSION_PATCH)->isBuiltin = true;
sym_AddString("__RGBDS_VERSION__"s, get_package_version_string())->isBuiltin = true;
sym_AddEqu("__RGBDS_MAJOR__"s, PACKAGE_VERSION_MAJOR)->isBuiltin = true;
sym_AddEqu("__RGBDS_MINOR__"s, PACKAGE_VERSION_MINOR)->isBuiltin = true;
sym_AddEqu("__RGBDS_PATCH__"s, PACKAGE_VERSION_PATCH)->isBuiltin = true;
#ifdef PACKAGE_VERSION_RC
sym_AddEqu("__RGBDS_RC__", PACKAGE_VERSION_RC)->isBuiltin = true;
sym_AddEqu("__RGBDS_RC__"s, PACKAGE_VERSION_RC)->isBuiltin = true;
#endif
if (now == (time_t)-1) {
@@ -609,17 +620,17 @@ void sym_Init(time_t now) {
time_utc
);
sym_AddString("__TIME__", savedTIME)->isBuiltin = true;
sym_AddString("__DATE__", savedDATE)->isBuiltin = true;
sym_AddString("__ISO_8601_LOCAL__", savedTIMESTAMP_ISO8601_LOCAL)->isBuiltin = true;
sym_AddString("__ISO_8601_UTC__", savedTIMESTAMP_ISO8601_UTC)->isBuiltin = true;
sym_AddString("__TIME__"s, savedTIME)->isBuiltin = true;
sym_AddString("__DATE__"s, savedDATE)->isBuiltin = true;
sym_AddString("__ISO_8601_LOCAL__"s, savedTIMESTAMP_ISO8601_LOCAL)->isBuiltin = true;
sym_AddString("__ISO_8601_UTC__"s, savedTIMESTAMP_ISO8601_UTC)->isBuiltin = true;
sym_AddEqu("__UTC_YEAR__", time_utc->tm_year + 1900)->isBuiltin = true;
sym_AddEqu("__UTC_MONTH__", time_utc->tm_mon + 1)->isBuiltin = true;
sym_AddEqu("__UTC_DAY__", time_utc->tm_mday)->isBuiltin = true;
sym_AddEqu("__UTC_HOUR__", time_utc->tm_hour)->isBuiltin = true;
sym_AddEqu("__UTC_MINUTE__", time_utc->tm_min)->isBuiltin = true;
sym_AddEqu("__UTC_SECOND__", time_utc->tm_sec)->isBuiltin = true;
sym_AddEqu("__UTC_YEAR__"s, time_utc->tm_year + 1900)->isBuiltin = true;
sym_AddEqu("__UTC_MONTH__"s, time_utc->tm_mon + 1)->isBuiltin = true;
sym_AddEqu("__UTC_DAY__"s, time_utc->tm_mday)->isBuiltin = true;
sym_AddEqu("__UTC_HOUR__"s, time_utc->tm_hour)->isBuiltin = true;
sym_AddEqu("__UTC_MINUTE__"s, time_utc->tm_min)->isBuiltin = true;
sym_AddEqu("__UTC_SECOND__"s, time_utc->tm_sec)->isBuiltin = true;
labelScope = std::nullopt;
anonLabelID = 0;