/*
* cause the alignment to become a multiple of n
*/
void
defalign(int n)
{
#if 0
char *s;
n /= SZCHAR;
if (lastloc == PROG || n == 1)
return;
s = (isinlining ? permalloc(40) : tmpalloc(40));
sprintf(s, ".align %d", n);
send_passt(IP_ASM, s);
#endif
}
static struct symtab *
addftn(char *n, TWORD t)
{
NODE *p = block(TYPE, 0, 0, 0, 0, 0);
struct symtab *sp;
sp = lookup(addname(n), 0);
p->n_type = INCREF(t) + (FTN-PTR);
p->n_sp = sp;
p->n_df = memset(permalloc(sizeof(union dimfun)), 0,
sizeof(union dimfun));
defid(p, EXTERN);
nfree(p);
return sp;
}
/*
* Allocate space on the permanent stack for a string of length len+1
* and copy it there.
* Return the new address.
*/
char *
newstring(char *s, int len)
{
char *u, *c;
len++;
if (allocleft < len) {
u = c = permalloc(len);
} else {
u = c = &allocpole[MEMCHUNKSZ-allocleft];
allocleft -= ROUNDUP(len+1);
}
while (len--)
*c++ = *s++;
return u;
}
void
addsym(struct symtab *q)
{
struct symlst *w = sympole;
if (q == NULL)
return;
while (w) {
if (q == w->sp)
return; /* exists */
w = w->next;
}
w = permalloc(sizeof(struct symlst));
w->sp = q;
w->next = sympole;
sympole = w;
}
/*
* For unimplemented "builtin" functions, try to invoke the
* non-builtin name
*/
static NODE *
binhelp(NODE *a, TWORD rt, char *n)
{
NODE *f = block(NAME, NIL, NIL, INT, 0, 0);
int oblvl = blevel;
blevel = 0;
f->n_sp = lookup(addname(n), SNORMAL);
blevel = oblvl;
if (f->n_sp->sclass == SNULL) {
f->n_sp->sclass = EXTERN;
f->n_sp->stype = INCREF(rt)+(FTN-PTR);
f->n_sp->sdf = permalloc(sizeof(union dimfun));
f->n_sp->sdf->dfun = NULL;
}
f->n_type = f->n_sp->stype;
f = clocal(f);
return buildtree(CALL, f, a);
}
NODE *
talloc()
{
register NODE *p;
usednodes++;
if (freelink != NULL) {
p = freelink;
freelink = p->next;
if (p->n_op != FREE)
cerror("node not FREE: %p", p);
if (nflag)
printf("alloc node %p from freelist\n", p);
return p;
}
p = permalloc(sizeof(NODE));
p->n_op = FREE;
if (nflag)
printf("alloc node %p from memory\n", p);
return p;
}
static int MainShadow(int ac, char **av, bool *pbTableSort )
{
int nError = ERROR_NONE;
bool bDoAllPasses = false;
int nMaxPasses = 10;
char buf[MAXLINE];
int i;
MNEMONIC *mne;
int oldredo = -1;
unsigned long oldwhy = 0;
int oldeval = 0;
addhashtable(Ops);
pass = 1;
if (ac < 2)
{
fail:
puts(dasm_id);
puts("Copyright (c) 1988-2008 by various authors (see file AUTHORS).");
puts("License GPLv2+: GNU GPL version 2 or later (see file COPYING).");
puts("DASM is free software: you are free to change and redistribute it.");
puts("There is ABSOLUTELY NO WARRANTY, to the extent permitted by law.");
puts("");
puts("Usage: dasm sourcefile [options]");
puts("");
puts("-f# output format 1-3 (default 1)");
puts("-oname output file name (else a.out)");
puts("-lname list file name (else none generated)");
puts("-Lname list file, containing all passes");
puts("-sname symbol dump file name (else none generated)");
puts("-v# verboseness 0-4 (default 0)");
puts("-d debug mode (for developers)");
puts("-Dsymbol define symbol, set to 0");
puts("-Dsymbol=expression define symbol, set to expression");
puts("-Msymbol=expression define symbol using EQM (same as -D)");
puts("-Idir search directory for INCLUDE and INCBIN");
puts("-p# maximum number of passes");
puts("-P# maximum number of passes, with fewer checks");
puts("-T# symbol table sorting (default 0 = alphabetical, 1 = address/value)");
puts("-E# error format (default 0 = MS, 1 = Dillon, 2 = GNU)");
puts("");
puts("Report bugs to [email protected] please!");
return ERROR_COMMAND_LINE;
}
for (i = 2; i < ac; ++i)
{
if ( ( av[i][0] == '-' ) || ( av[i][0] == '/' ) )
{
char *str = av[i]+2;
switch(av[i][1])
{
/* TODO: need to improve option parsing and errors for it */
case 'E':
F_errorformat = atoi(str);
if (F_errorformat < ERRORFORMAT_DEFAULT
|| F_errorformat >= ERRORFORMAT_MAX )
{
panic("Invalid error format for -E, must be 0, 1, 2");
}
break;
case 'T':
F_sortmode = atoi(str);
if (F_sortmode < SORTMODE_DEFAULT
|| F_sortmode >= SORTMODE_MAX )
{
panic("Invalid sorting mode for -T option, must be 0 or 1");
}
/* TODO: refactor into regular configuration [phf] */
*pbTableSort = (F_sortmode != SORTMODE_DEFAULT);
break;
case 'd':
Xdebug = atoi(str) != 0;
printf( "Debug trace %s\n", Xdebug ? "ON" : "OFF" );
break;
case 'M':
case 'D':
while (*str && *str != '=')
++str;
if (*str == '=')
{
*str = 0;
++str;
}
else
{
str = "0";
}
Av[0] = av[i]+2;
if (av[i][1] == 'M')
v_eqm(str, NULL);
else
v_set(str, NULL);
break;
case 'f': /* F_format */
F_format = atoi(str);
if (F_format < FORMAT_DEFAULT || F_format >= FORMAT_MAX )
panic("Illegal format specification");
break;
case 'o': /* F_outfile */
F_outfile = str;
nofile:
if (*str == 0)
panic("-o Switch requires file name.");
break;
case 'L':
F_ListAllPasses = 1;
/* fall through to 'l' */
case 'l': /* F_listfile */
F_listfile = str;
goto nofile;
case 'P': /* F_Passes */
bDoAllPasses = true;
/* fall through to 'p' */
case 'p': /* F_passes */
nMaxPasses = atoi(str);
break;
case 's': /* F_symfile */
F_symfile = str;
goto nofile;
case 'v': /* F_verbose */
F_verbose = atoi(str);
break;
case 'I':
v_incdir(str, NULL);
break;
default:
goto fail;
}
continue;
}
goto fail;
}
/* INITIAL SEGMENT */
{
SEGMENT *seg = (SEGMENT *)permalloc(sizeof(SEGMENT));
seg->name = strcpy(permalloc(sizeof(ISEGNAME)), ISEGNAME);
seg->flags= seg->rflags = seg->initflags = seg->initrflags = SF_UNKNOWN;
Csegment = Seglist = seg;
}
/* TOP LEVEL IF */
{
IFSTACK *ifs = (IFSTACK *)zmalloc(sizeof(IFSTACK));
ifs->file = NULL;
ifs->flags = IFF_BASE;
ifs->acctrue = 1;
ifs->xtrue = 1;
Ifstack = ifs;
}
nextpass:
if ( F_verbose )
{
puts("");
printf("START OF PASS: %d\n", pass);
}
Localindex = Lastlocalindex = 0;
Localdollarindex = Lastlocaldollarindex = 0;
/*_fmode = 0x8000;*/
FI_temp = fopen(F_outfile, "wb");
/*_fmode = 0;*/
Fisclear = 1;
CheckSum = 0;
if (FI_temp == NULL) {
printf("Warning: Unable to [re]open '%s'\n", F_outfile);
return ERROR_FILE_ERROR;
}
if (F_listfile) {
FI_listfile = fopen(F_listfile,
F_ListAllPasses && (pass > 1)? "a" : "w");
if (FI_listfile == NULL) {
printf("Warning: Unable to [re]open '%s'\n", F_listfile);
return ERROR_FILE_ERROR;
}
}
pushinclude(av[1]);
while ( pIncfile )
{
for (;;) {
const char *comment;
if ( pIncfile->flags & INF_MACRO) {
if ( pIncfile->strlist == NULL) {
Av[0] = "";
v_mexit(NULL, NULL);
continue;
}
strcpy(buf, pIncfile->strlist->buf);
pIncfile->strlist = pIncfile->strlist->next;
}
else
{
if (fgets(buf, MAXLINE, pIncfile->fi) == NULL)
break;
}
if (Xdebug)
printf("%08lx %s\n", (unsigned long) pIncfile, buf);
comment = cleanup(buf, false);
++pIncfile->lineno;
mne = parse(buf);
if (Av[1][0])
{
if (mne)
{
if ((mne->flags & MF_IF) || (Ifstack->xtrue && Ifstack->acctrue))
(*mne->vect)(Av[2], mne);
}
else
{
if (Ifstack->xtrue && Ifstack->acctrue)
asmerr( ERROR_UNKNOWN_MNEMONIC, false, Av[1] );
}
}
else
{
if (Ifstack->xtrue && Ifstack->acctrue)
programlabel();
}
if (F_listfile && ListMode)
outlistfile(comment);
}
while (Reploop && Reploop->file == pIncfile)
rmnode((void **)&Reploop, sizeof(REPLOOP));
while (Ifstack->file == pIncfile)
rmnode((void **)&Ifstack, sizeof(IFSTACK));
fclose( pIncfile->fi );
free( pIncfile->name );
--Inclevel;
rmnode((void **)&pIncfile, sizeof(INCFILE));
if ( pIncfile )
{
/*
if (F_verbose > 1)
printf("back to: %s\n", Incfile->name);
*/
if (F_listfile)
fprintf(FI_listfile, "------- FILE %s\n", pIncfile->name);
}
}
if ( F_verbose >= 1 )
ShowSegments();
if ( F_verbose >= 3 )
{
if ( !Redo || ( F_verbose == 4 ) )
ShowSymbols( stdout, *pbTableSort );
ShowUnresolvedSymbols();
}
closegenerate();
fclose(FI_temp);
if (FI_listfile)
fclose(FI_listfile);
if (Redo)
{
if ( !bDoAllPasses )
if (Redo == oldredo && Redo_why == oldwhy && Redo_eval == oldeval)
{
ShowUnresolvedSymbols();
return ERROR_NOT_RESOLVABLE;
}
oldredo = Redo;
oldwhy = Redo_why;
oldeval = Redo_eval;
Redo = 0;
Redo_why = 0;
Redo_eval = 0;
Redo_if <<= 1;
++pass;
if ( bStopAtEnd )
{
printf("Unrecoverable error(s) in pass, aborting assembly!\n");
}
else if ( pass > nMaxPasses )
{
char sBuffer[64];
sprintf( sBuffer, "%d", pass );
return asmerr( ERROR_TOO_MANY_PASSES, false, sBuffer );
}
else
{
clearrefs();
clearsegs();
goto nextpass;
}
}
return nError;
}
