acn/vt100-games
acn/vt100-games
1
0
Fork 0
Code Releases Activity
9008c67a38
vt100-games/2048/uz80as/uz80as.c

1241 lines
22 KiB
C
Raw Blame History

/* ===========================================================================
* uz80as, an assembler for the Zilog Z80 and several other microprocessors.
*
* Assembler.
* ===========================================================================
*/
#include "config.h"
#include "uz80as.h"
#include "options.h"
#include "utils.h"
#include "err.h"
#include "incl.h"
#include "sym.h"
#include "expr.h"
#include "exprint.h"
#include "pp.h"
#include "list.h"
#include "targets.h"
#ifndef ASSERT_H
#include <assert.h>
#endif
#ifndef CTYPE_H
#include <ctype.h>
#endif
#ifndef STDIO_H
#include <stdio.h>
#endif
#ifndef STDLIB_H
#include <stdlib.h>
#endif
#ifndef STRING_H
#include <string.h>
#endif
static void output();
static const char *d_align(const char *);
static const char *d_null(const char *);
static const char *d_block(const char *);
static const char *d_byte(const char *);
static const char *d_chk(const char *);
static const char *d_codes(const char *);
static const char *d_echo(const char *);
static const char *d_eject(const char *);
static const char *d_export(const char *);
static const char *d_end(const char *);
static const char *d_equ(const char *);
static const char *d_fill(const char *);
static const char *d_ds(const char *);
static const char *d_list(const char *);
static const char *d_lsfirst(const char *);
static const char *d_module(const char *);
static const char *d_msfirst(const char *);
static const char *d_nocodes(const char *);
static const char *d_nolist(const char *);
static const char *d_org(const char *);
static const char *d_set(const char *);
static const char *d_text(const char *);
static const char *d_title(const char *);
static const char *d_word(const char *);
/*
* Directives.
* This table must be sorted, to allow for binary search.
*/
static struct direc {
const char *name;
const char *(*fun)(const char *);
} s_directab[] = {
{ "ALIGN", d_align },
{ "BLOCK", d_block },
{ "BYTE", d_byte },
{ "CHK", d_chk },
{ "CODES", d_codes },
{ "DB", d_byte },
{ "DS", d_ds },
{ "DW", d_word },
{ "ECHO", d_echo },
{ "EJECT", d_eject },
{ "END", d_end },
{ "EQU", d_equ },
{ "EXPORT", d_export },
{ "FILL", d_fill },
{ "GLOBAL", d_export },
{ "LIST", d_list },
{ "LSFIRST", d_lsfirst },
{ "MODULE", d_module },
{ "MSFIRST", d_msfirst },
{ "NOCODES", d_nocodes },
{ "NOLIST", d_nolist },
{ "NOPAGE", d_null },
{ "ORG", d_org },
{ "PAGE", d_null },
{ "SECTION", d_null },
{ "SET", d_set },
{ "TEXT", d_text },
{ "TITLE", d_title },
{ "WORD", d_word },
};
/* binary output file */
FILE *fout;
/* output in source order */
int b_flag = 1;
/* The target. */
const struct target *s_target;
/* The z80 addressable memory. The object code. */
static unsigned char s_mem[64 * 1024];
/* Program counter min and max ([s_minpc, s_maxpc[). */
static int s_minpc, s_maxpc;
/* Original input line. */
static char s_line[LINESZ];
/* Label defined on this line. */
static struct sym *s_lastsym;
/* Output words the most significant byte first */
static int s_msbword;
/* If we have seen the .END directive. */
static int s_end_seen;
/* We have issued the error of generating things after an .END. */
static int s_gen_after_end;
/* The empty line, to pass to listing, for compatibility with TASM. */
static const char *s_empty_line = "";
/* Pointer in s_pline for error reporting. */
const char *s_pline_ep;
/* We skip characters until endline or backslash or comment. */
static const char *sync(const char *p)
{
while (*p != '\0' && *p != '\\' && *p != ';')
p++;
return p;
}
/* the written bitmap */
unsigned char membit[65536 / 8];
void
setbit(int pc)
{
membit[pc / 8] |= (1 << (pc % 8));
}
int
isset(int pc)
{
return membit[pc / 8] & (1 << (pc % 8));
}
void
open_output()
{
fout = efopen(s_objfname, "wb");
}
void
close_output()
{
if (fclose(fout) == EOF) {
eprint(_("cannot close file %s\n"), s_objfname);
}
}
/*
* Generates a byte to the output and updates s_pc, s_minpc and s_maxpc.
* Will issue a fatal error if we write beyong 64k.
*/
void genb(int b, const char *ep)
{
if (s_pass == 0 && s_end_seen && !s_gen_after_end) {
s_gen_after_end = 1;
eprint(_("generating code after .END\n"));
eprcol(s_pline, ep);
newerr();
}
if (s_minpc < 0)
s_minpc = s_pc;
if (s_pc >= 65536) {
eprint(_("generating code beyond address 65535\n"));
eprcol(s_pline, ep);
exit(EXIT_FAILURE);
}
s_mem[s_pc] = (unsigned char) b;
setbit(s_pc);
if (s_pass == 1) {
list_genb(b);
if (b_flag) {
fwrite(&s_mem[s_pc], 1, 1, fout);
}
}
if (s_pc < s_minpc)
s_minpc = s_pc;
s_pc++;
if (s_pc > s_maxpc)
s_maxpc = s_pc;
}
/*
* Generate 'n' as a 16 bit word, little endian or big endian depending on
* s_msbword.
*/
static void genw(int n, const char *ep)
{
if (s_msbword)
genb(n >> 8, ep);
genb(n, ep);
if (!s_msbword)
genb(n >> 8, ep);
}
/*
* We have matched an instruction in the table.
* Generate the machine code for the instruction using the generation
* pattern 'p. 'vs are the arguments generated during the matching process.
*/
static void gen(const char *p, const int *vs)
{
// int w, b, i, savepc;
int b, i, savepc;
const char *p_orig;
savepc = s_pc;
p_orig = p;
b = 0;
loop:
i = hexvalu(*p);
if (i >= 0) {
p++;
b = (i << 4) | hexval(*p);
} else if (*p == '.') {
genb(b, s_pline_ep);
b = 0;
} else if (*p == '\0') {
return;
} else {
i = *(p + 1) - '0';
switch (*p) {
case 'b': b |= (vs[i] << 3); break;
case 'c': b |= vs[i]; break;
case 'd': b = vs[i]; break;
case 'e': genb(vs[i] & 0xff, s_pline_ep);
genb(vs[i] >> 8, s_pline_ep);
break;
default:
if (s_target->genf(&b, *p, vs, i, savepc) == -1) {
eprogname();
fprintf(stderr,
_("fatal: bad pattern %s ('%c')"),
p_orig, *p);
enl();
exit(EXIT_FAILURE);
}
}
p++;
}
p++;
goto loop;
}
/*
* Tries to match *p with any of the strings in list.
* If matched, returns the index in list and r points to the position
* in p past the matched string.
*/
int mreg(const char *p, const char *const list[], const char **r)
{
const char *s;
const char *q;
int i;
i = 0;
while ((s = list[i++]) != NULL) {
if (*s == '\0')
continue;
q = p;
while (toupper(*q++) == *s++) {
if (*s == '\0') {
if (!isalnum(*q)) {
*r = q;
return i - 1;
} else {
break;
}
}
}
}
return -1;
}
static int isoctal(int c)
{
return c >= '0' && c <= '7';
}
/*
* Read an octal of 3 digits, being the maximum value 377 (255 decimal);
* Return -1 if there is an error in the syntax.
*/
static int readoctal(const char *p)
{
int n;
const char *q;
if (*p >= '0' && *p <= '3' && isoctal(*(p + 1)) && isoctal(*(p + 2))) {
n = 0;
q = p + 3;
while (p < q) {
n *= 8;
n += (*p - '0');
p++;
}
return n;
}
return -1;
}
enum strmode {
STRMODE_ECHO,
STRMODE_NULL,
STRMODE_BYTE,
STRMODE_WORD
};
/*
* Generate the string bytes until double quote or null char.
* Return a pointer to the ending double quote character or '\0'.
* 'p must point to the starting double quote.
* If mode:
* STRMODE_ECHO only echo to stderr the characters.
* STRMODE_NULL only parses the string.
* STRMODE_BYTE generate the characters in the binary file as bytes.
* STRMODE_WORD generate the characters in the binary file as words.
*/
static const char *genstr(const char *p, enum strmode mode)
{
int c;
for (p = p + 1; *p != '\0' && *p != '\"'; p++) {
c = *p;
if (c == '\\') {
p++;
switch (*p) {
case 'n': c = '\n'; break;
case 'r': c = '\r'; break;
case 'b': c = '\b'; break;
case 't': c = '\t'; break;
case 'f': c = '\f'; break;
case '\\': c = '\\'; break;
case '\"': c = '\"'; break;
default:
c = readoctal(p);
if (c < 0) {
eprint(_("bad character escape "
"sequence\n"));
eprcol(s_pline, p - 1);
newerr();
p--;
} else {
p += 2;
}
}
}
switch (mode) {
case STRMODE_ECHO: fputc(c, stderr); break;
case STRMODE_NULL: break;
case STRMODE_BYTE: genb(c, p); break;
case STRMODE_WORD: genw(c, p); break;
}
}
return p;
}
/* Match an instruction.
* If no match returns NULL; else returns one past end of match.
* p should point to no whitespace.
*/
static const char *match(const char *p)
{
const struct matchtab *mtab;
const char *s, *pp, *q;
int v, n, vi, linepc;
int vs[4];
assert(!isspace(*p));
mtab = s_target->matcht;
linepc = s_pc;
pp = p;
n = -1;
next:
n++;
s = mtab[n].pat;
if (s == NULL) {
return NULL;
} else if ((s_target->mask & mtab[n].mask) == 0) {
goto next;
} else if (!s_undocumented_op && (s_target->mask & mtab[n].undoc)) {
goto next;
}
p = pp;
vi = 0;
loop:
if (*s == '\0') {
p = skipws(p);
if (*p != ';' && *p != '\0' && *p != '\\')
goto next;
else
goto found;
} else if (*s == ' ') {
if (!isspace(*p))
goto next;
p = skipws(p);
} else if ((*s == ',' || *s == '(' || *s == ')') && isspace(*p)) {
p = skipws(p);
if (*s != *p)
goto next;
p = skipws(p + 1);
} else if (*s == 'a') {
p = expr(p, &v, linepc, s_pass == 0, NULL, NULL);
if (p == NULL)
return NULL;
vs[vi++] = v;
} else if (*s >= 'b' && *s <= 'z') {
v = s_target->matchf(*s, p, &q);
goto reg;
} else if (*p == *s && *p == ',') {
p = skipws(p + 1);
} else if (toupper(*p) == *s) {
p++;
} else {
goto next;
}
freg:
s++;
goto loop;
reg:
if (v < 0) {
goto next;
} else {
assert(vi < sizeof(vs));
vs[vi++] = v;
p = q;
}
goto freg;
found:
// printf("%s\n", s_matchtab[n].pat);
gen(mtab[n].gen, vs);
return p;
}
static const char *
d_null(const char *p)
{
p = sync(p);
while (*p != '\0' && *p != '\\') {
if (!isspace(*p)) {
wprint(_("invalid characters after directive\n"));
eprcol(s_pline, p);
return sync(p);
} else {
p++;
}
}
return p;
}
static const char *d_end(const char *p)
{
enum expr_ecode ecode;
const char *q;
const char *ep;
if (s_pass == 0) {
if (s_end_seen) {
eprint(_("duplicate .END\n"));
eprcol(s_pline, s_pline_ep);
newerr();
} else {
s_end_seen = 1;
}
}
q = expr(p, NULL, s_pc, s_pass == 0, &ecode, &ep);
if (q == NULL && ecode == EXPR_E_NO_EXPR) {
return p;
} else if (q == NULL) {
exprint(ecode, s_pline, ep);
newerr();
return NULL;
} else {
return q;
}
}
static const char *d_codes(const char *p)
{
s_codes = 1;
return p;
}
static const char *d_module(const char *p)
{
p = sync(p);
while (*p != '\0' && *p != '\\') {
if (!isspace(*p)) {
wprint(_("invalid characters after directive\n"));
eprcol(s_pline, p);
return sync(p);
} else {
p++;
}
}
return p;
}
static const char *d_nocodes(const char *p)
{
s_codes = 0;
return p;
}
static const char *d_list(const char *p)
{
s_list_on = 1;
return p;
}
static const char *d_nolist(const char *p)
{
s_list_on = 0;
return p;
}
static const char *d_eject(const char *p)
{
list_eject();
return p;
}
static const char *d_echo(const char *p)
{
int n;
int mode;
enum expr_ecode ecode;
const char *ep;
mode = (s_pass == 0) ? STRMODE_NULL : STRMODE_ECHO;
if (*p == '\"') {
p = genstr(p, mode);
if (*p == '\"') {
p++;
} else if (s_pass == 0) {
wprint(_("no terminating quote\n"));
eprcol(s_pline, p);
}
} else if (*p != '\0') {
p = expr(p, &n, s_pc, s_pass == 0, &ecode, &ep);
if (p == NULL) {
exprint(ecode, s_pline, ep);
newerr();
return NULL;
}
if (mode == STRMODE_ECHO) {
fprintf(stderr, "%d", n);
}
}
return p;
}
static const char *d_equ(const char *p)
{
int n;
enum expr_ecode ecode;
const char *ep;
p = expr(p, &n, s_pc, 0, &ecode, &ep);
if (p == NULL) {
exprint(ecode, s_pline, ep);
newerr();
return NULL;
}
if (s_lastsym == NULL) {
eprint(_(".EQU without label\n"));
eprcol(s_pline, s_pline_ep);
newerr();
} else {
/* TODO: check label misalign? */
s_lastsym->val = n;
s_lastsym->isequ = 1;
}
return p;
}
static const char *d_set(const char *p)
{
int n;
enum expr_ecode ecode;
const char *ep;
p = expr(p, &n, s_pc, 0, &ecode, &ep);
if (p == NULL) {
exprint(ecode, s_pline, ep);
newerr();
return NULL;
}
if (s_lastsym == NULL) {
eprint(_(".EQU without label\n"));
eprcol(s_pline, s_pline_ep);
newerr();
} else {
/* TODO: check label misalign? */
s_lastsym->val = n;
s_lastsym->isequ = 1;
}
return p;
}
static const char *d_export(const char *p)
{
/* TODO */
return NULL;
}
static const char *d_fill(const char *p)
{
int n, v, er;
const char *q;
enum expr_ecode ecode;
const char *ep, *eps;
eps = p;
er = 0;
p = expr(p, &n, s_pc, 0, &ecode, &ep);
if (p == NULL) {
exprint(ecode, s_pline, ep);
newerr();
return NULL;
}
if (n < 0) {
eprint(_("number of positions to fill is negative (%d)\n"), n);
eprcol(s_pline, eps);
exit(EXIT_FAILURE);
}
v = 255;
p = skipws(p);
if (*p == ',') {
p = skipws(p + 1);
q = expr(p, &v, s_pc, s_pass == 0, &ecode, &ep);
if (q == NULL) {
er = 1;
exprint(ecode, s_pline, ep);
newerr();
} else {
p = q;
}
}
while (n--)
genb(v, eps);
if (er)
return NULL;
else
return p;
}
static const char *d_ds(const char *p)
{
int n, v, er;
const char *q;
enum expr_ecode ecode;
const char *ep, *eps;
eps = p;
er = 0;
p = expr(p, &n, s_pc, 0, &ecode, &ep);
if (p == NULL) {
exprint(ecode, s_pline, ep);
newerr();
return NULL;
}
if (n < 0) {
eprint(_("number of positions to space over is negative (%d)\n"), n);
eprcol(s_pline, eps);
exit(EXIT_FAILURE);
}
v = 255;
p = skipws(p);
if (*p == ',') {
p = skipws(p + 1);
q = expr(p, &v, s_pc, s_pass == 0, &ecode, &ep);
if (q == NULL) {
er = 1;
exprint(ecode, s_pline, ep);
newerr();
} else {
p = q;
}
}
s_pc += n;
if (er)
return NULL;
else
return p;
}
static const char *d_lsfirst(const char *p)
{
s_msbword = 0;
return p;
}
static const char *d_msfirst(const char *p)
{
s_msbword = 1;
return p;
}
static const char *d_org(const char *p)
{
int n;
enum expr_ecode ecode;
const char *ep, *eps;
eps = p;
p = expr(p, &n, s_pc, 0, &ecode, &ep);
if (p == NULL) {
exprint(ecode, s_pline, ep);
newerr();
return NULL;
}
if (n < 0 || n > 65536) {
eprint(_(".ORG address (%d) is not in range [0, 65536]\n"), n);
eprcol(s_pline, eps);
exit(EXIT_FAILURE);
}
s_pc = n;
/* Change the listing PC so in orgs we print the changed PC. */
if (s_pass > 0)
list_setpc(s_pc);
if (s_lastsym != NULL) {
/* TODO: check label misalign? */
s_lastsym->val = s_pc;
s_lastsym->isequ = 1;
}
return p;
}
static const char *d_lst(const char *p, int w)
{
enum strmode mode;
int n, linepc;
enum expr_ecode ecode;
const char *ep, *eps;
if (w)
mode = STRMODE_WORD;
else
mode = STRMODE_BYTE;
linepc = s_pc;
dnlst:
if (*p == '\"') {
p = genstr(p, mode);
if (*p == '\"') {
p++;
} else {
wprint(_("no terminating quote\n"));
eprcol(s_pline, p);
}
} else {
eps = p;
p = expr(p, &n, linepc, s_pass == 0, &ecode, &ep);
if (p == NULL) {
exprint(ecode, s_pline, ep);
newerr();
return NULL;
}
if (w)
genw(n, eps);
else
genb(n, eps);
}
p = skipws(p);
if (*p == ',') {
p++;
p = skipws(p);
goto dnlst;
}
return p;
}
static const char *d_align(const char *p)
{
int n, v, er;
const char *q;
enum expr_ecode ecode;
const char *ep, *eps;
eps = p;
er = 0;
p = expr(p, &n, s_pc, 0, &ecode, &ep);
if (p == NULL) {
exprint(ecode, s_pline, ep);
newerr();
return NULL;
}
if (n < 0) {
eprint(_("align is negative (%d)\n"), n);
eprcol(s_pline, eps);
exit(EXIT_FAILURE);
}
while (s_pc % n) {
genb(0, eps);
}
if (er)
return NULL;
else
return p;
}
static const char *d_byte(const char *p)
{
return d_lst(p, 0);
}
static const char *d_word(const char *p)
{
return d_lst(p, 1);
}
static const char *d_text(const char *p)
{
if (*p == '\"') {
p = genstr(p, STRMODE_BYTE);
if (*p == '\"') {
p++;
} else {
wprint(_("no terminating quote\n"));
eprcol(s_pline, p);
}
return p;
} else {
eprint(_(".TEXT directive needs a quoted string argument\n"));
eprcol(s_pline, p);
newerr();
return NULL;
}
}
static const char *d_title(const char *p)
{
return NULL;
}
static const char *d_block(const char *p)
{
int n;
enum expr_ecode ecode;
const char *ep, *eps;
eps = p;
p = expr(p, &n, s_pc, 0, &ecode, &ep);
if (p == NULL) {
exprint(ecode, s_pline, ep);
newerr();
return NULL;
}
s_pc += n;
if (s_pc < 0 || s_pc > 65536) {
eprint(_("address (%d) set by .BLOCK is not in range "
"[0, 65536]\n"), s_pc);
eprcol(s_pline, eps);
exit(EXIT_FAILURE);
}
return p;
}
/* a must be < b. */
static int checksum(int a, int b)
{
int n;
assert(a < b);
n = 0;
while (a < b)
n += s_mem[a++];
return n;
}
static const char *d_chk(const char *p)
{
int n;
enum expr_ecode ecode;
const char *ep, *eps;
eps = p;
p = expr(p, &n, s_pc, s_pass == 0, &ecode, &ep);
if (p == NULL) {
exprint(ecode, s_pline, ep);
newerr();
genb(0, eps);
return NULL;
}
if (s_pass == 0) {
genb(0, s_pline_ep);
} else if (n < 0 || n >= s_pc) {
eprint(_(".CHK address (%d) is not in range [0, %d[\n"), n,
s_pc);
eprcol(s_pline, eps);
newerr();
genb(0, eps);
} else {
genb(checksum(n, s_pc), eps);
}
return p;
}
/* Parses an internal directive (those that start with '.').
* Returns NULL on error;
* If no error returns position past the parsed directive and arguments. */
static const char *parse_direc(const char *cp)
{
const char *cq, *p;
int a, b, m = 0;
a = 0;
b = NELEMS(s_directab) - 1;
while (a <= b) {
m = (a + b) / 2;
cq = cp;
p = s_directab[m].name;
while (*p != '\0' && toupper(*cq) == *p) {
p++;
cq++;
}
if (*p == '\0' && (*cq == '\0' || isspace(*cq)))
break;
else if (toupper(*cq) < *p)
b = m - 1;
else
a = m + 1;
}
if (a <= b) {
cq = skipws(cq);
return s_directab[m].fun(cq);
} else {
eprint(_("unrecognized directive\n"));
eprcol(s_pline, s_pline_ep);
newerr();
return NULL;
}
}
static void parselin(const char *cp)
{
int col0, alloweq;
const char *q;
s_pline_ep = cp;
start: s_lastsym = NULL;
alloweq = 0;
col0 = 1;
loop:
if (*cp == '\0' || *cp == ';') {
return;
} else if (*cp == '\\') {
if (s_pass == 1) {
list_endln();
list_startln(s_empty_line, curfile()->linenum, s_pc,
nfiles());
}
cp++;
goto start;
} else if (*cp == '.') {
s_pline_ep = cp;
cp++;
q = parse_direc(cp);
if (q == NULL) {
cp = sync(cp);
} else {
cp = d_null(q);
}
} else if ((*cp == '$' || *cp == '*') && cp[1] == '=') {
/* Alternative form of .ORG: *= or $= */
cp += 2;
q = d_org(cp);
if (q == NULL) {
cp = sync(cp);
} else {
cp = d_null(q);
}
} else if (*cp == '=' && alloweq) {
/* equ */
s_pline_ep = cp;
cp++;
q = d_equ(cp);
if (q == NULL) {
cp = sync(cp);
} else {
cp = d_null(q);
}
} else if (isidc0(*cp)) {
if (col0 && *cp != '.') {
/* take label */
s_pline_ep = cp;
q = cp;
col0 = 0;
while (isidc(*cp))
cp++;
s_lastsym = lookup(q, cp, s_pass == 0, s_pc);
if (*cp == ':' || isspace(*cp)) {
alloweq = 1;
cp++;
} else if (*cp == '=') {
alloweq = 1;
}
if (s_pass == 1 && !s_lastsym->isequ &&
s_lastsym->val != s_pc)
{
eprint(_("misaligned label %s\n"),
s_lastsym->name);
fprintf(stderr, _(" Previous value was %XH, "
"new value %XH."), s_lastsym->val,
s_pc);
eprcol(s_pline, s_pline_ep);
newerr();
}
} else {
cp = skipws(cp);
s_pline_ep = cp;
q = match(cp);
if (q == NULL) {
eprint(_("syntax error\n"));
newerr();
cp = sync(cp);
} else {
cp = d_null(q);
}
}
} else if (isspace(*cp)) {
col0 = 0;
while (isspace(*cp))
cp++;
} else {
eprint(_("unexpected character (%c)\n"), *cp);
eprcol(s_pline, cp);
newerr();
cp = sync(cp + 1);
}
goto loop;
}
/*
* Gets a new line into 's_line from 'fin.
* Terminates the line with '\0'.
* Does not read more than LINESZ - 1 characters.
* Does not add a '\n' character, thus a line of length 0 it's possible.
* Always advances to the next line.
* Returns -1 for EOF or the line length.
*/
static int getlin(FILE *fin)
{
int i, c;
c = EOF;
i = 0;
while (i < LINESZ - 1) {
c = getc(fin);
if (c == EOF || c == '\n')
break;
s_line[i++] = (char) c;
}
if (c != EOF && c != '\n') {
wprint(_("line too long, truncated to %d characters\n"),
LINESZ);
}
while (c != EOF && c != '\n')
c = getc(fin);
if (i == 0 && c == EOF)
return -1;
s_line[i] = '\0';
return i;
}
/* Preinstall the macros defined in the command line. */
static void install_predefs(void)
{
struct predef *pdef;
for (pdef = s_predefs; pdef != NULL; pdef = pdef->next)
pp_define(pdef->name);
}
/* Do a pass through the source. */
static void dopass(const char *fname)
{
/* Fill memory with default value. */
if ((s_pass == 0 && s_mem_fillval != 0) || s_pass > 0) {
memset(s_mem, s_mem_fillval, sizeof(s_mem));
}
if (s_pass > 0) {
pp_reset();
list_open(s_lstfname);
s_codes = 1;
s_list_on = 1;
}
install_predefs();
s_minpc = -1;
s_maxpc = -1;
s_pc = 0;
s_lastsym = NULL;
s_msbword = 0;
pushfile(fname, fname + strlen(fname));
while (nfiles() > 0) {
curfile()->linenum++;
if (getlin(curfile()->fin) >= 0) {
if (s_pass == 1) {
list_startln(s_line, curfile()->linenum, s_pc,
nfiles());
}
pp_line(s_line);
if (s_pass == 1)
list_skip(s_skipon);
parselin(s_pline);
if (s_pass == 1)
list_endln();
} else {
popfile();
}
}
if (s_pass > 0) {
list_close();
}
}
/*
* Write the object file in memory order
*/
static void output()
{
int i;
// fprintf(stderr, "output: min: %x max: %x\n", s_minpc, s_maxpc);
if (s_minpc < 0)
s_minpc = 0;
if (s_maxpc < 0)
s_maxpc = 0;
for (i = s_minpc; i < s_maxpc; i++) {
if (isset(i)) {
fwrite(&s_mem[i], 1, 1, fout);
}
}
if (ferror(fout)) {
eprint(_("cannot write to file %s\n"), s_objfname);
clearerr(fout);
}
}
/* Start the assembly using the config in options.c. */
void uz80as(void)
{
s_target = find_target(s_target_id);
if (s_target == NULL) {
eprint(_("target '%s' not supported\n"), s_target_id);
exit(EXIT_FAILURE);
}
for (s_pass = 0; s_nerrors == 0 && s_pass < 2; s_pass++) {
if ((s_pass > 0) && (s_nerrors == 0)) {
open_output();
}
dopass(s_asmfname);
if (s_pass == 0 && !s_end_seen) {
wprint(_("no .END statement in the source\n"));
}
if (s_nerrors == 0) {
if (verbose) printf("Pass %d completed.\n", s_pass + 1);
}
}
if (s_nerrors > 0) {
exit(EXIT_FAILURE);
}
if (!b_flag) {
output();
}
close_output();
}
View Git Blame Copy Permalink