2016-12-28 20:32:00 +00:00
|
|
|
// ACME - a crossassembler for producing 6502/65c02/65816/65ce02 code.
|
2020-04-25 10:20:52 +00:00
|
|
|
// Copyright (C) 1998-2020 Marco Baye
|
2014-06-07 00:12:10 +00:00
|
|
|
// Have a look at "acme.c" for further info
|
|
|
|
//
|
|
|
|
// symbol stuff
|
|
|
|
//
|
|
|
|
// 22 Nov 2007 "warn on indented labels" is now a CLI switch
|
|
|
|
// 25 Sep 2011 Fixed bug in !sl (colons in filename could be interpreted as EOS)
|
2014-11-23 23:40:01 +00:00
|
|
|
// 23 Nov 2014 Added label output in VICE format
|
2014-12-22 00:47:52 +00:00
|
|
|
#include "symbol.h"
|
2014-06-07 00:12:10 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include "acme.h"
|
|
|
|
#include "alu.h"
|
|
|
|
#include "dynabuf.h"
|
2014-12-03 22:18:06 +00:00
|
|
|
#include "global.h" // FIXME - remove when no longer needed
|
2014-06-07 00:12:10 +00:00
|
|
|
#include "input.h"
|
|
|
|
#include "output.h"
|
|
|
|
#include "platform.h"
|
|
|
|
#include "section.h"
|
|
|
|
#include "tree.h"
|
|
|
|
#include "typesystem.h"
|
|
|
|
|
|
|
|
|
|
|
|
// variables
|
2014-12-03 22:18:06 +00:00
|
|
|
struct rwnode *symbols_forest[256] = { NULL }; // because of 8-bit hash - must be (at least partially) pre-defined so array will be zeroed!
|
2014-06-07 00:12:10 +00:00
|
|
|
|
|
|
|
|
|
|
|
// Dump symbol value and flags to dump file
|
2014-11-24 14:52:05 +00:00
|
|
|
static void dump_one_symbol(struct rwnode *node, FILE *fd)
|
2014-06-07 00:12:10 +00:00
|
|
|
{
|
|
|
|
struct symbol *symbol = node->body;
|
|
|
|
|
|
|
|
// output name
|
2017-10-29 23:29:07 +00:00
|
|
|
if (config.warn_on_type_mismatch
|
2014-06-07 00:12:10 +00:00
|
|
|
&& symbol->result.addr_refs == 1)
|
2014-11-22 01:36:02 +00:00
|
|
|
fprintf(fd, "!addr");
|
|
|
|
fprintf(fd, "\t%s", node->id_string);
|
2020-04-28 16:02:09 +00:00
|
|
|
switch (symbol->result.flags & NUMBER_FORCEBITS) {
|
|
|
|
case NUMBER_FORCES_16:
|
2014-06-07 00:12:10 +00:00
|
|
|
fprintf(fd, "+2\t= ");
|
|
|
|
break;
|
2020-04-28 16:02:09 +00:00
|
|
|
case NUMBER_FORCES_16 | NUMBER_FORCES_24:
|
2014-06-07 00:12:10 +00:00
|
|
|
/*FALLTHROUGH*/
|
2020-04-28 16:02:09 +00:00
|
|
|
case NUMBER_FORCES_24:
|
2014-06-07 00:12:10 +00:00
|
|
|
fprintf(fd, "+3\t= ");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
fprintf(fd, "\t= ");
|
|
|
|
}
|
2020-04-28 16:02:09 +00:00
|
|
|
if (symbol->result.flags & NUMBER_IS_DEFINED) {
|
|
|
|
if (symbol->result.flags & NUMBER_IS_FLOAT)
|
2014-06-07 00:12:10 +00:00
|
|
|
fprintf(fd, "%.30f", symbol->result.val.fpval); //FIXME %g
|
|
|
|
else
|
|
|
|
fprintf(fd, "$%x", (unsigned) symbol->result.val.intval);
|
|
|
|
} else {
|
2017-10-21 19:59:56 +00:00
|
|
|
fprintf(fd, " ?"); // TODO - maybe write "UNDEFINED" instead? then the file could at least be parsed without errors
|
2014-06-07 00:12:10 +00:00
|
|
|
}
|
2020-04-28 16:02:09 +00:00
|
|
|
if (symbol->result.flags & NUMBER_EVER_UNDEFINED)
|
2017-10-21 19:59:56 +00:00
|
|
|
fprintf(fd, "\t; ?"); // TODO - write "forward" instead?
|
2014-06-07 00:12:10 +00:00
|
|
|
if (symbol->usage == 0)
|
|
|
|
fprintf(fd, "\t; unused");
|
|
|
|
fprintf(fd, "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-11-23 23:40:01 +00:00
|
|
|
// output symbols in VICE format (example: "al C:09ae .nmi1")
|
2014-11-24 14:52:05 +00:00
|
|
|
static void dump_vice_address(struct rwnode *node, FILE *fd)
|
2014-11-23 23:40:01 +00:00
|
|
|
{
|
|
|
|
struct symbol *symbol = node->body;
|
|
|
|
|
|
|
|
// dump address symbols even if they are not used
|
2020-04-28 16:02:09 +00:00
|
|
|
if ((symbol->result.flags & NUMBER_IS_DEFINED)
|
|
|
|
&& !(symbol->result.flags & NUMBER_IS_FLOAT)
|
2014-11-23 23:40:01 +00:00
|
|
|
&& (symbol->result.addr_refs == 1))
|
|
|
|
fprintf(fd, "al C:%04x .%s\n", (unsigned) symbol->result.val.intval, node->id_string);
|
|
|
|
}
|
2014-11-24 14:52:05 +00:00
|
|
|
static void dump_vice_usednonaddress(struct rwnode *node, FILE *fd)
|
2014-11-23 23:40:01 +00:00
|
|
|
{
|
|
|
|
struct symbol *symbol = node->body;
|
|
|
|
|
|
|
|
// dump non-addresses that are used
|
|
|
|
if (symbol->usage
|
2020-04-28 16:02:09 +00:00
|
|
|
&& (symbol->result.flags & NUMBER_IS_DEFINED)
|
|
|
|
&& !(symbol->result.flags & NUMBER_IS_FLOAT)
|
2014-11-23 23:40:01 +00:00
|
|
|
&& (symbol->result.addr_refs != 1))
|
|
|
|
fprintf(fd, "al C:%04x .%s\n", (unsigned) symbol->result.val.intval, node->id_string);
|
|
|
|
}
|
2014-11-24 14:52:05 +00:00
|
|
|
static void dump_vice_unusednonaddress(struct rwnode *node, FILE *fd)
|
2014-11-23 23:40:01 +00:00
|
|
|
{
|
|
|
|
struct symbol *symbol = node->body;
|
|
|
|
|
|
|
|
// dump non-addresses that are unused
|
|
|
|
if (!symbol->usage
|
2020-04-28 16:02:09 +00:00
|
|
|
&& (symbol->result.flags & NUMBER_IS_DEFINED)
|
|
|
|
&& !(symbol->result.flags & NUMBER_IS_FLOAT)
|
2014-11-23 23:40:01 +00:00
|
|
|
&& (symbol->result.addr_refs != 1))
|
|
|
|
fprintf(fd, "al C:%04x .%s\n", (unsigned) symbol->result.val.intval, node->id_string);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-06-07 00:12:10 +00:00
|
|
|
// search for symbol. create if nonexistant. if created, give it flags "flags".
|
|
|
|
// the symbol name must be held in GlobalDynaBuf.
|
2016-08-05 09:59:07 +00:00
|
|
|
struct symbol *symbol_find(scope_t scope, int flags)
|
2014-06-07 00:12:10 +00:00
|
|
|
{
|
2014-11-24 14:52:05 +00:00
|
|
|
struct rwnode *node;
|
|
|
|
struct symbol *symbol;
|
2020-05-06 11:40:06 +00:00
|
|
|
boolean node_created;
|
|
|
|
int force_bits = flags & NUMBER_FORCEBITS;
|
2014-06-07 00:12:10 +00:00
|
|
|
|
2016-08-05 09:59:07 +00:00
|
|
|
node_created = Tree_hard_scan(&node, symbols_forest, scope, TRUE);
|
2014-06-07 00:12:10 +00:00
|
|
|
// if node has just been created, create symbol as well
|
|
|
|
if (node_created) {
|
|
|
|
// create new symbol structure
|
|
|
|
symbol = safe_malloc(sizeof(*symbol));
|
|
|
|
// finish empty symbol item
|
|
|
|
symbol->result.flags = flags;
|
|
|
|
symbol->result.addr_refs = 0;
|
2020-04-28 16:02:09 +00:00
|
|
|
if (flags & NUMBER_IS_FLOAT)
|
2014-06-07 00:12:10 +00:00
|
|
|
symbol->result.val.fpval = 0;
|
|
|
|
else
|
|
|
|
symbol->result.val.intval = 0;
|
|
|
|
symbol->usage = 0; // usage count
|
2020-05-02 10:40:10 +00:00
|
|
|
symbol->pass = pass.number;
|
2020-05-02 21:59:20 +00:00
|
|
|
symbol->has_been_reported = FALSE;
|
2014-06-07 00:12:10 +00:00
|
|
|
node->body = symbol;
|
|
|
|
} else {
|
|
|
|
symbol = node->body;
|
|
|
|
}
|
|
|
|
// make sure the force bits don't clash
|
2020-05-06 11:40:06 +00:00
|
|
|
if ((!node_created) && force_bits)
|
2020-04-28 16:02:09 +00:00
|
|
|
if ((symbol->result.flags & NUMBER_FORCEBITS) != force_bits)
|
2014-06-07 00:12:10 +00:00
|
|
|
Throw_error("Too late for postfix.");
|
|
|
|
return symbol;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// assign value to symbol. the function acts upon the symbol's flag bits and
|
|
|
|
// produces an error if needed.
|
2020-05-06 11:40:06 +00:00
|
|
|
void symbol_set_value(struct symbol *symbol, struct number *new_value, boolean change_allowed)
|
2014-06-07 00:12:10 +00:00
|
|
|
{
|
|
|
|
int oldflags = symbol->result.flags;
|
|
|
|
|
|
|
|
// value stuff
|
2020-05-06 11:40:06 +00:00
|
|
|
if ((oldflags & NUMBER_IS_DEFINED) && !change_allowed) {
|
2014-06-07 00:12:10 +00:00
|
|
|
// symbol is already defined, so compare new and old values
|
|
|
|
// if different type OR same type but different value, complain
|
2020-04-28 16:02:09 +00:00
|
|
|
if (((oldflags ^ new_value->flags) & NUMBER_IS_FLOAT)
|
|
|
|
|| ((oldflags & NUMBER_IS_FLOAT) ? (symbol->result.val.fpval != new_value->val.fpval) : (symbol->result.val.intval != new_value->val.intval)))
|
2014-06-07 00:12:10 +00:00
|
|
|
Throw_error("Symbol already defined.");
|
|
|
|
} else {
|
|
|
|
// symbol is not defined yet OR redefinitions are allowed
|
|
|
|
symbol->result = *new_value;
|
|
|
|
}
|
|
|
|
// flags stuff
|
|
|
|
// Ensure that "unsure" symbols without "isByte" state don't get that
|
2020-04-28 16:02:09 +00:00
|
|
|
if ((oldflags & (NUMBER_EVER_UNDEFINED | NUMBER_FITS_BYTE)) == NUMBER_EVER_UNDEFINED)
|
|
|
|
new_value->flags &= ~NUMBER_FITS_BYTE;
|
2014-06-07 00:12:10 +00:00
|
|
|
if (change_allowed) {
|
2020-04-28 16:02:09 +00:00
|
|
|
oldflags = (oldflags & NUMBER_EVER_UNDEFINED) | new_value->flags;
|
2014-06-07 00:12:10 +00:00
|
|
|
} else {
|
2020-04-28 16:02:09 +00:00
|
|
|
if ((oldflags & NUMBER_FORCEBITS) == 0)
|
|
|
|
if ((oldflags & (NUMBER_EVER_UNDEFINED | NUMBER_IS_DEFINED)) == 0)
|
|
|
|
oldflags |= new_value->flags & NUMBER_FORCEBITS;
|
|
|
|
oldflags |= new_value->flags & ~NUMBER_FORCEBITS;
|
2014-06-07 00:12:10 +00:00
|
|
|
}
|
|
|
|
symbol->result.flags = oldflags;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// parse label definition (can be either global or local).
|
|
|
|
// name must be held in GlobalDynaBuf.
|
2020-05-06 11:40:06 +00:00
|
|
|
void symbol_set_label(scope_t scope, int stat_flags, int force_bit, boolean change_allowed)
|
2014-06-07 00:12:10 +00:00
|
|
|
{
|
2020-04-28 16:02:09 +00:00
|
|
|
struct number pc,
|
2014-06-07 00:12:10 +00:00
|
|
|
result;
|
|
|
|
struct symbol *symbol;
|
|
|
|
|
2016-08-05 09:59:07 +00:00
|
|
|
symbol = symbol_find(scope, force_bit);
|
2014-06-07 00:12:10 +00:00
|
|
|
// label definition
|
2017-10-29 23:29:07 +00:00
|
|
|
if ((stat_flags & SF_FOUND_BLANK) && config.warn_on_indented_labels)
|
2014-06-07 00:12:10 +00:00
|
|
|
Throw_first_pass_warning("Label name not in leftmost column.");
|
|
|
|
vcpu_read_pc(&pc);
|
2020-05-05 22:56:11 +00:00
|
|
|
// FIXME - if undefined, check pass.complain_about_undefined and maybe throw "value not defined"!
|
2020-04-28 16:02:09 +00:00
|
|
|
result.flags = pc.flags & NUMBER_IS_DEFINED;
|
2014-06-07 00:12:10 +00:00
|
|
|
result.val.intval = pc.val.intval;
|
|
|
|
result.addr_refs = pc.addr_refs;
|
|
|
|
symbol_set_value(symbol, &result, change_allowed);
|
2017-10-29 23:29:07 +00:00
|
|
|
// global labels must open new scope for cheap locals
|
|
|
|
if (scope == SCOPE_GLOBAL)
|
|
|
|
section_new_cheap_scope(section_now);
|
2014-06-07 00:12:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// parse symbol definition (can be either global or local, may turn out to be a label).
|
|
|
|
// name must be held in GlobalDynaBuf.
|
2016-08-05 09:59:07 +00:00
|
|
|
void symbol_parse_definition(scope_t scope, int stat_flags)
|
2014-06-07 00:12:10 +00:00
|
|
|
{
|
2020-04-28 16:02:09 +00:00
|
|
|
struct number result;
|
2014-06-07 00:12:10 +00:00
|
|
|
struct symbol *symbol;
|
|
|
|
int force_bit = Input_get_force_bit(); // skips spaces after
|
|
|
|
// FIXME - force bit is allowed for label definitions?!
|
|
|
|
|
|
|
|
if (GotByte == '=') {
|
|
|
|
// explicit symbol definition (symbol = <something>)
|
2016-08-05 09:59:07 +00:00
|
|
|
symbol = symbol_find(scope, force_bit);
|
2014-06-07 00:12:10 +00:00
|
|
|
// symbol = parsed value
|
|
|
|
GetByte(); // skip '='
|
|
|
|
ALU_any_result(&result);
|
|
|
|
// if wanted, mark as address reference
|
|
|
|
if (typesystem_says_address())
|
|
|
|
result.addr_refs = 1;
|
|
|
|
symbol_set_value(symbol, &result, FALSE);
|
|
|
|
Input_ensure_EOS();
|
|
|
|
} else {
|
2016-08-05 09:59:07 +00:00
|
|
|
symbol_set_label(scope, stat_flags, force_bit, FALSE);
|
2014-06-07 00:12:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// set global symbol to value, no questions asked (for "-D" switch)
|
|
|
|
// Name must be held in GlobalDynaBuf.
|
|
|
|
void symbol_define(intval_t value)
|
|
|
|
{
|
2020-04-28 16:02:09 +00:00
|
|
|
struct number result;
|
2014-06-07 00:12:10 +00:00
|
|
|
struct symbol *symbol;
|
|
|
|
|
2020-04-28 16:02:09 +00:00
|
|
|
result.flags = NUMBER_IS_DEFINED;
|
2014-06-07 00:12:10 +00:00
|
|
|
result.val.intval = value;
|
2016-08-05 09:59:07 +00:00
|
|
|
symbol = symbol_find(SCOPE_GLOBAL, 0);
|
2014-06-07 00:12:10 +00:00
|
|
|
symbol_set_value(symbol, &result, TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// dump global symbols to file
|
2014-11-22 01:36:02 +00:00
|
|
|
void symbols_list(FILE *fd)
|
2014-06-07 00:12:10 +00:00
|
|
|
{
|
2016-08-05 09:59:07 +00:00
|
|
|
Tree_dump_forest(symbols_forest, SCOPE_GLOBAL, dump_one_symbol, fd);
|
2014-06-07 00:12:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-11-23 23:40:01 +00:00
|
|
|
void symbols_vicelabels(FILE *fd)
|
|
|
|
{
|
2016-02-21 12:58:22 +00:00
|
|
|
// FIXME - if type checking is enabled, maybe only output addresses?
|
2014-11-23 23:40:01 +00:00
|
|
|
// the order of dumped labels is important because VICE will prefer later defined labels
|
|
|
|
// dump unused labels
|
2016-08-05 09:59:07 +00:00
|
|
|
Tree_dump_forest(symbols_forest, SCOPE_GLOBAL, dump_vice_unusednonaddress, fd);
|
2014-11-23 23:40:01 +00:00
|
|
|
fputc('\n', fd);
|
|
|
|
// dump other used labels
|
2016-08-05 09:59:07 +00:00
|
|
|
Tree_dump_forest(symbols_forest, SCOPE_GLOBAL, dump_vice_usednonaddress, fd);
|
2014-11-23 23:40:01 +00:00
|
|
|
fputc('\n', fd);
|
|
|
|
// dump address symbols
|
2016-08-05 09:59:07 +00:00
|
|
|
Tree_dump_forest(symbols_forest, SCOPE_GLOBAL, dump_vice_address, fd);
|
2014-11-23 23:40:01 +00:00
|
|
|
}
|
|
|
|
|
2014-06-07 00:12:10 +00:00
|
|
|
|
|
|
|
// fix name of anonymous forward label (held in DynaBuf, NOT TERMINATED!) so it
|
|
|
|
// references the *next* anonymous forward label definition. The tricky bit is,
|
|
|
|
// each name length would need its own counter. But hey, ACME's real quick in
|
|
|
|
// finding symbols, so I'll just abuse the symbol system to store those counters.
|
|
|
|
void symbol_fix_forward_anon_name(int increment)
|
|
|
|
{
|
|
|
|
struct symbol *counter_symbol;
|
|
|
|
unsigned long number;
|
|
|
|
|
|
|
|
// terminate name, find "counter" symbol and read value
|
|
|
|
DynaBuf_append(GlobalDynaBuf, '\0');
|
2017-10-29 23:29:07 +00:00
|
|
|
counter_symbol = symbol_find(section_now->local_scope, 0);
|
2014-06-07 00:12:10 +00:00
|
|
|
// make sure it gets reset to zero in each new pass
|
2020-05-02 10:40:10 +00:00
|
|
|
if (counter_symbol->pass != pass.number) {
|
|
|
|
counter_symbol->pass = pass.number;
|
2014-06-07 00:12:10 +00:00
|
|
|
counter_symbol->result.val.intval = 0;
|
|
|
|
}
|
|
|
|
number = (unsigned long) counter_symbol->result.val.intval;
|
|
|
|
// now append to the name to make it unique
|
|
|
|
GlobalDynaBuf->size--; // forget terminator, we want to append
|
|
|
|
do {
|
|
|
|
DYNABUF_APPEND(GlobalDynaBuf, 'a' + (number & 15));
|
|
|
|
number >>= 4;
|
|
|
|
} while (number);
|
|
|
|
DynaBuf_append(GlobalDynaBuf, '\0');
|
|
|
|
if (increment)
|
|
|
|
counter_symbol->result.val.intval++;
|
|
|
|
}
|