ref: 579a324ce74da5c89271f5d0132697f0c59e7875
dir: /src/asm/symbol.c/
/*
* This file is part of RGBDS.
*
* Copyright (c) 1997-2018, Carsten Sorensen and RGBDS contributors.
*
* SPDX-License-Identifier: MIT
*/
/*
* Symboltable and macroargs stuff
*/
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "asm/asm.h"
#include "asm/fstack.h"
#include "asm/symbol.h"
#include "asm/main.h"
#include "asm/mymath.h"
#include "asm/output.h"
#include "asm/util.h"
#include "asm/warning.h"
#include "extern/err.h"
#include "helpers.h"
#include "version.h"
struct sSymbol *tHashedSymbols[HASHSIZE];
static struct sSymbol *pScope; /* Current section symbol scope */
struct sSymbol *pPCSymbol;
static struct sSymbol *p_NARGSymbol;
static struct sSymbol *p__LINE__Symbol;
static char *currentmacroargs[MAXMACROARGS + 1];
static char *newmacroargs[MAXMACROARGS + 1];
static char SavedTIME[256];
static char SavedDATE[256];
static char SavedTIMESTAMP_ISO8601_LOCAL[256];
static char SavedTIMESTAMP_ISO8601_UTC[256];
static char SavedDAY[3];
static char SavedMONTH[3];
static char SavedYEAR[20];
static char SavedHOUR[3];
static char SavedMINUTE[3];
static char SavedSECOND[3];
static bool exportall;
static int32_t Callback_NARG(unused_ struct sSymbol const *sym)
{
uint32_t i = 0;
while (currentmacroargs[i] && i < MAXMACROARGS)
i++;
return i;
}
static int32_t Callback__LINE__(unused_ struct sSymbol const *sym)
{
return nLineNo;
}
/*
* Get the nValue field of a symbol
*/
static int32_t getvaluefield(struct sSymbol const *sym)
{
if (sym->Callback)
return sym->Callback(sym);
if (sym->type == SYM_LABEL)
return sym->nValue + sym->pSection->nOrg;
return sym->nValue;
}
/*
* Calculate the hash value for a symbol name
*/
uint32_t sym_CalcHash(const char *s)
{
return calchash(s) % HASHSIZE;
}
/*
* Update a symbol's definition filename and line
*/
static void updateSymbolFilename(struct sSymbol *nsym)
{
if (snprintf(nsym->tzFileName, _MAX_PATH + 1, "%s",
tzCurrentFileName) > _MAX_PATH) {
fatalerror("%s: File name is too long: '%s'", __func__,
tzCurrentFileName);
}
nsym->nFileLine = fstk_GetLine();
}
/*
* Create a new symbol by name
*/
static struct sSymbol *createsymbol(char const *s)
{
struct sSymbol **ppsym;
uint32_t hash;
hash = sym_CalcHash(s);
ppsym = &(tHashedSymbols[hash]);
while ((*ppsym) != NULL)
ppsym = &((*ppsym)->pNext);
(*ppsym) = malloc(sizeof(struct sSymbol));
if ((*ppsym) == NULL) {
fatalerror("No memory for symbol");
return NULL;
}
if (snprintf((*ppsym)->tzName, MAXSYMLEN + 1, "%s", s) > MAXSYMLEN)
warning(WARNING_LONG_STR, "Symbol name is too long: '%s'", s);
(*ppsym)->isConstant = false;
(*ppsym)->isExported = false;
(*ppsym)->pScope = NULL;
(*ppsym)->pNext = NULL;
(*ppsym)->pSection = NULL;
(*ppsym)->nValue = 0;
(*ppsym)->pMacro = NULL;
(*ppsym)->Callback = NULL;
updateSymbolFilename(*ppsym);
return *ppsym;
}
/*
* Creates the full name of a local symbol in a given scope, by prepending
* the name with the parent symbol's name.
*/
static void fullSymbolName(char *output, size_t outputSize,
char const *localName, const struct sSymbol *scope)
{
const struct sSymbol *parent = scope->pScope ? scope->pScope : scope;
int n = snprintf(output, outputSize, "%s%s", parent->tzName, localName);
if (n >= (int)outputSize)
fatalerror("Symbol name is too long: '%s%s'",
parent->tzName, localName);
}
/*
* Find the pointer to a symbol by name and scope
*/
static struct sSymbol **findpsymbol(char const *s, struct sSymbol const *scope)
{
struct sSymbol **ppsym;
int32_t hash;
char fullname[MAXSYMLEN + 1];
if (s[0] == '.' && scope) {
fullSymbolName(fullname, sizeof(fullname), s, scope);
s = fullname;
}
char const *separator = strchr(s, '.');
if (separator) {
if (strchr(separator + 1, '.'))
fatalerror("'%s' is a nonsensical reference to a nested local symbol",
s);
}
hash = sym_CalcHash(s);
ppsym = &(tHashedSymbols[hash]);
while ((*ppsym) != NULL) {
if ((strcmp(s, (*ppsym)->tzName) == 0))
return ppsym;
ppsym = &((*ppsym)->pNext);
}
return NULL;
}
/*
* Find a symbol by name and scope
*/
static struct sSymbol *findsymbol(char const *s, struct sSymbol const *scope)
{
struct sSymbol **ppsym = findpsymbol(s, scope);
return ppsym ? *ppsym : NULL;
}
/*
* Find a symbol by name, with automatically determined scope
*/
struct sSymbol *sym_FindSymbol(char const *tzName)
{
struct sSymbol *pscope;
if (*tzName == '.')
pscope = pScope;
else
pscope = NULL;
return findsymbol(tzName, pscope);
}
/*
* Purge a symbol
*/
void sym_Purge(char const *tzName)
{
struct sSymbol **ppSym;
struct sSymbol *pscope;
if (*tzName == '.')
pscope = pScope;
else
pscope = NULL;
ppSym = findpsymbol(tzName, pscope);
if (ppSym) {
struct sSymbol *pSym;
pSym = *ppSym;
*ppSym = pSym->pNext;
if (pSym->pMacro)
free(pSym->pMacro);
free(pSym);
} else {
yyerror("'%s' not defined", tzName);
}
}
/*
* Get a string equate's value
*/
char *sym_GetStringValue(struct sSymbol const *sym)
{
if (sym != NULL)
return sym->pMacro;
yyerror("String symbol '%s' not defined", sym->tzName);
return NULL;
}
/*
* Return a constant symbols value
*/
uint32_t sym_GetConstantValue(char const *s)
{
struct sSymbol const *psym = sym_FindSymbol(s);
if (psym == pPCSymbol) {
if (pCurrentSection->nOrg == -1)
yyerror("Expected constant PC but section is not fixed");
else
return getvaluefield(psym);
} else if (psym != NULL) {
if (sym_IsConstant(psym))
return getvaluefield(psym);
fatalerror("Expression must have a constant value");
}
yyerror("'%s' not defined", s);
return 0;
}
/*
* Return a defined symbols value... aborts if not defined yet
*/
uint32_t sym_GetDefinedValue(char const *s)
{
struct sSymbol const *psym = sym_FindSymbol(s);
if (psym != NULL) {
if (sym_IsDefined(psym)) {
if (!sym_IsNumeric(psym))
yyerror("'%s' is a macro or string symbol", s);
return getvaluefield(psym);
}
}
yyerror("'%s' not defined", s);
return 0;
}
struct sSymbol *sym_GetCurrentSymbolScope(void)
{
return pScope;
}
void sym_SetCurrentSymbolScope(struct sSymbol *pNewScope)
{
pScope = pNewScope;
}
/*
* Macro argument stuff
*/
void sym_ShiftCurrentMacroArgs(void)
{
int32_t i;
free(currentmacroargs[0]);
for (i = 0; i < MAXMACROARGS - 1; i++)
currentmacroargs[i] = currentmacroargs[i + 1];
currentmacroargs[MAXMACROARGS - 1] = NULL;
}
char *sym_FindMacroArg(int32_t i)
{
if (i == -1)
i = MAXMACROARGS + 1;
assert(i >= 1);
assert((size_t)(i - 1)
< sizeof(currentmacroargs) / sizeof(*currentmacroargs));
return currentmacroargs[i - 1];
}
void sym_UseNewMacroArgs(void)
{
int32_t i;
for (i = 0; i <= MAXMACROARGS; i++) {
free(currentmacroargs[i]);
currentmacroargs[i] = newmacroargs[i];
newmacroargs[i] = NULL;
}
}
void sym_SaveCurrentMacroArgs(char *save[])
{
int32_t i;
for (i = 0; i <= MAXMACROARGS; i++) {
save[i] = currentmacroargs[i];
currentmacroargs[i] = NULL;
}
}
void sym_RestoreCurrentMacroArgs(char *save[])
{
int32_t i;
for (i = 0; i <= MAXMACROARGS; i++) {
free(currentmacroargs[i]);
currentmacroargs[i] = save[i];
}
}
void sym_AddNewMacroArg(char const *s)
{
int32_t i = 0;
while (i < MAXMACROARGS && newmacroargs[i] != NULL)
i++;
if (i < MAXMACROARGS) {
if (s)
newmacroargs[i] = strdup(s);
else
newmacroargs[i] = NULL;
} else {
yyerror("A maximum of %d arguments allowed", MAXMACROARGS);
}
}
void sym_SetMacroArgID(uint32_t nMacroCount)
{
char s[256];
snprintf(s, sizeof(s) - 1, "_%u", nMacroCount);
newmacroargs[MAXMACROARGS] = strdup(s);
}
void sym_UseCurrentMacroArgs(void)
{
int32_t i;
for (i = 1; i <= MAXMACROARGS; i++)
sym_AddNewMacroArg(sym_FindMacroArg(i));
}
/*
* Find a macro by name
*/
struct sSymbol *sym_FindMacro(char const *s)
{
return findsymbol(s, NULL);
}
/*
* Create a symbol that will be non-relocatable and ensure that it
* hasn't already been defined or referenced in a context that would
* require that it be relocatable
*/
static struct sSymbol *createNonrelocSymbol(char const *tzSym)
{
struct sSymbol *nsym = findsymbol(tzSym, NULL);
if (nsym != NULL) {
if (sym_IsDefined(nsym)) {
yyerror("'%s' already defined at %s(%u)",
tzSym, nsym->tzFileName, nsym->nFileLine);
} else {
yyerror("'%s' referenced as label at %s(%u)",
tzSym, nsym->tzFileName, nsym->nFileLine);
}
} else {
nsym = createsymbol(tzSym);
}
return nsym;
}
/*
* Add an equated symbol
*/
void sym_AddEqu(char const *tzSym, int32_t value)
{
struct sSymbol *nsym = createNonrelocSymbol(tzSym);
nsym->nValue = value;
nsym->type = SYM_EQU;
nsym->isConstant = true;
nsym->pScope = NULL;
updateSymbolFilename(nsym);
}
/*
* 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
* 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
* as ``` M_PI EQUS "3.1415" ```
*/
void sym_AddString(char const *tzSym, char const *tzValue)
{
struct sSymbol *nsym = createNonrelocSymbol(tzSym);
nsym->pMacro = malloc(strlen(tzValue) + 1);
if (nsym->pMacro != NULL)
strcpy(nsym->pMacro, tzValue);
else
fatalerror("No memory for string equate");
nsym->type = SYM_EQUS;
nsym->ulMacroSize = strlen(tzValue);
nsym->pScope = NULL;
}
/*
* Alter a SET symbols value
*/
void sym_AddSet(char const *tzSym, int32_t value)
{
struct sSymbol *nsym = findsymbol(tzSym, NULL);
if (nsym != NULL) {
if (sym_IsDefined(nsym)) {
if (nsym->type == SYM_LABEL)
yyerror("'%s' already defined as non-constant at %s(%u)",
tzSym,
nsym->tzFileName,
nsym->nFileLine);
else if (nsym->type != SYM_SET)
yyerror("'%s' already defined as constant at %s(%u)",
tzSym,
nsym->tzFileName,
nsym->nFileLine);
} else if (nsym->type == SYM_REF) {
yyerror("'%s' already referenced at %s(%u)",
tzSym,
nsym->tzFileName,
nsym->nFileLine);
}
} else {
nsym = createsymbol(tzSym);
}
nsym->nValue = value;
nsym->type = SYM_SET;
nsym->isConstant = true;
nsym->pScope = NULL;
updateSymbolFilename(nsym);
}
/*
* Add a local (.name) relocatable symbol
*/
void sym_AddLocalReloc(char const *tzSym)
{
if (pScope) {
char fullname[MAXSYMLEN + 1];
fullSymbolName(fullname, sizeof(fullname), tzSym, pScope);
sym_AddReloc(fullname);
} else {
fatalerror("Local label in main scope");
}
}
/*
* Add a relocatable symbol
*/
void sym_AddReloc(char const *tzSym)
{
struct sSymbol *scope = NULL;
struct sSymbol *nsym;
char *localPtr = strchr(tzSym, '.');
if (localPtr != NULL) {
if (!pScope)
fatalerror("Local label in main scope");
struct sSymbol *parent = pScope->pScope ?
pScope->pScope : pScope;
uint32_t parentLen = localPtr - tzSym;
if (strchr(localPtr + 1, '.') != NULL) {
fatalerror("'%s' is a nonsensical reference to a nested local symbol",
tzSym);
} else if (strlen(parent->tzName) != parentLen
|| strncmp(tzSym, parent->tzName, parentLen) != 0) {
yyerror("Not currently in the scope of '%.*s'",
parentLen, tzSym);
}
scope = parent;
}
nsym = findsymbol(tzSym, scope);
if (nsym != NULL) {
if (sym_IsDefined(nsym)) {
yyerror("'%s' already defined in %s(%d)", tzSym,
nsym->tzFileName, nsym->nFileLine);
}
} else {
nsym = createsymbol(tzSym);
}
nsym->nValue = nPC;
nsym->type = SYM_LABEL;
nsym->isConstant = pCurrentSection && pCurrentSection->nOrg != -1;
if (exportall)
nsym->isExported = true;
nsym->pScope = scope;
nsym->pSection = pCurrentSection;
/* Labels need to be assigned a section, except PC */
if (!pCurrentSection && strcmp(tzSym, "@"))
yyerror("Label \"%s\" created outside of a SECTION",
tzSym);
updateSymbolFilename(nsym);
pScope = findsymbol(tzSym, scope);
}
/*
* Check if the subtraction of two symbols is defined. That is, either both
* symbols are defined and the result is a constant, or both symbols are
* relocatable and belong to the same section.
*
* It returns 1 if the difference is defined, 0 if not.
*/
bool sym_IsRelocDiffDefined(char const *tzSym1, char const *tzSym2)
{
const struct sSymbol *nsym1 = sym_FindSymbol(tzSym1);
const struct sSymbol *nsym2 = sym_FindSymbol(tzSym2);
/* Do the symbols exist? */
if (nsym1 == NULL)
fatalerror("Symbol \"%s\" isn't defined.", tzSym1);
if (nsym2 == NULL)
fatalerror("Symbol \"%s\" isn't defined.", tzSym2);
int32_t s1const = sym_IsConstant(nsym1);
int32_t s2const = sym_IsConstant(nsym2);
/* Both are non-relocatable */
if (s1const && s2const)
return true;
/* One of them is relocatable, the other one is not. */
if (s1const ^ s2const)
return false;
/*
* Both of them are relocatable. Make sure they are defined (internal
* coherency with sym_AddReloc and sym_AddLocalReloc).
*/
if (!sym_IsDefined(nsym1))
fatalerror("Relocatable symbol \"%s\" isn't defined.", tzSym1);
if (!sym_IsDefined(nsym2))
fatalerror("Relocatable symbol \"%s\" isn't defined.", tzSym2);
/*
* Both of them must be in the same section for the difference to be
* defined.
*/
return nsym1->pSection == nsym2->pSection;
}
/*
* Export a symbol
*/
void sym_Export(char const *tzSym)
{
sym_Ref(tzSym);
struct sSymbol *nsym = sym_FindSymbol(tzSym);
nsym->isExported = true;
}
/*
* Add a macro definition
*/
void sym_AddMacro(char const *tzSym, int32_t nDefLineNo)
{
struct sSymbol *nsym = createNonrelocSymbol(tzSym);
nsym->type = SYM_MACRO;
nsym->pScope = NULL;
nsym->ulMacroSize = ulNewMacroSize;
nsym->pMacro = tzNewMacro;
updateSymbolFilename(nsym);
/*
* The symbol is created at the line after the `endm`,
* override this with the actual definition line
*/
nsym->nFileLine = nDefLineNo;
}
/*
* Flag that a symbol is referenced in an RPN expression
* and create it if it doesn't exist yet
*/
void sym_Ref(char const *tzSym)
{
struct sSymbol *nsym = sym_FindSymbol(tzSym);
if (nsym == NULL) {
char fullname[MAXSYMLEN + 1];
if (*tzSym == '.') {
if (!pScope)
fatalerror("Local label reference '%s' in main scope",
tzSym);
fullSymbolName(fullname, sizeof(fullname), tzSym,
pScope);
tzSym = fullname;
}
nsym = createsymbol(tzSym);
nsym->type = SYM_REF;
}
}
/*
* Set whether to export all relocatable symbols by default
*/
void sym_SetExportAll(uint8_t set)
{
exportall = set;
}
/**
* Returns a pointer to the first non-zero character in a string
* Non-'0', not non-'\0'.
*/
static inline char const *removeLeadingZeros(char const *ptr)
{
while (*ptr == '0')
ptr++;
return ptr;
}
/*
* Initialize the symboltable
*/
void sym_Init(void)
{
int32_t i;
for (i = 0; i < MAXMACROARGS; i++) {
currentmacroargs[i] = NULL;
newmacroargs[i] = NULL;
}
for (i = 0; i < HASHSIZE; i++)
tHashedSymbols[i] = NULL;
sym_AddReloc("@");
pPCSymbol = findsymbol("@", NULL);
sym_AddEqu("_NARG", 0);
p_NARGSymbol = findsymbol("_NARG", NULL);
p_NARGSymbol->Callback = Callback_NARG;
sym_AddEqu("__LINE__", 0);
p__LINE__Symbol = findsymbol("__LINE__", NULL);
p__LINE__Symbol->Callback = Callback__LINE__;
sym_AddSet("_RS", 0);
time_t now = time(NULL);
if (now == (time_t)-1) {
warn("Couldn't determine current time");
/* Fall back by pretending we are at the Epoch */
now = 0;
}
const struct tm *time_utc = gmtime(&now);
const struct tm *time_local = localtime(&now);
strftime(SavedTIME, sizeof(SavedTIME), "\"%H:%M:%S\"",
time_local);
strftime(SavedDATE, sizeof(SavedDATE), "\"%d %B %Y\"",
time_local);
strftime(SavedTIMESTAMP_ISO8601_LOCAL,
sizeof(SavedTIMESTAMP_ISO8601_LOCAL), "\"%Y-%m-%dT%H-%M-%S%z\"",
time_local);
strftime(SavedTIMESTAMP_ISO8601_UTC,
sizeof(SavedTIMESTAMP_ISO8601_UTC), "\"%Y-%m-%dT%H-%M-%SZ\"",
time_utc);
strftime(SavedYEAR, sizeof(SavedYEAR), "%Y", time_utc);
strftime(SavedMONTH, sizeof(SavedMONTH), "%m", time_utc);
strftime(SavedDAY, sizeof(SavedDAY), "%d", time_utc);
strftime(SavedHOUR, sizeof(SavedHOUR), "%H", time_utc);
strftime(SavedMINUTE, sizeof(SavedMINUTE), "%M", time_utc);
strftime(SavedSECOND, sizeof(SavedSECOND), "%S", time_utc);
sym_AddString("__TIME__", SavedTIME);
sym_AddString("__DATE__", SavedDATE);
sym_AddString("__ISO_8601_LOCAL__", SavedTIMESTAMP_ISO8601_LOCAL);
sym_AddString("__ISO_8601_UTC__", SavedTIMESTAMP_ISO8601_UTC);
/* This cannot start with zeros */
sym_AddString("__UTC_YEAR__", SavedYEAR);
sym_AddString("__UTC_MONTH__", removeLeadingZeros(SavedMONTH));
sym_AddString("__UTC_DAY__", removeLeadingZeros(SavedDAY));
sym_AddString("__UTC_HOUR__", removeLeadingZeros(SavedHOUR));
sym_AddString("__UTC_MINUTE__", removeLeadingZeros(SavedMINUTE));
sym_AddString("__UTC_SECOND__", removeLeadingZeros(SavedSECOND));
pScope = NULL;
math_DefinePI();
}