const char *
define_macro (int idx, sb *in, sb *label,
int (*get_line) (sb *), const char **namep)
{
macro_entry *macro;
sb name;
const char *namestr;
macro = (macro_entry *) xmalloc (sizeof (macro_entry));
sb_new (¯o->sub);
sb_new (&name);
macro->formal_count = 0;
macro->formals = 0;
idx = sb_skip_white (idx, in);
if (! buffer_and_nest ("MACRO", "ENDM", ¯o->sub, get_line))
return _("unexpected end of file in macro definition");
if (label != NULL && label->len != 0)
{
sb_add_sb (&name, label);
if (idx < in->len && in->ptr[idx] == '(')
{
/* It's the label: MACRO (formals,...) sort */
idx = do_formals (macro, idx + 1, in);
if (in->ptr[idx] != ')')
return _("missing ) after formals");
}
else
{
/* It's the label: MACRO formals,... sort */
idx = do_formals (macro, idx, in);
}
}
else
{
idx = get_token (idx, in, &name);
idx = sb_skip_comma (idx, in);
idx = do_formals (macro, idx, in);
}
/* And stick it in the macro hash table. */
for (idx = 0; idx < name.len; idx++)
name.ptr[idx] = TOLOWER (name.ptr[idx]);
namestr = sb_terminate (&name);
hash_jam (macro_hash, namestr, (PTR) macro);
macro_defined = 1;
if (namep != NULL)
*namep = namestr;
return NULL;
}
static size_t
sub_actual (size_t start, sb *in, sb *t, struct hash_control *formal_hash,
int kind, sb *out, int copyifnotthere)
{
size_t src;
formal_entry *ptr;
src = get_apost_token (start, in, t, kind);
/* See if it's in the macro's hash table, unless this is
macro_strip_at and kind is '@' and the token did not end in '@'. */
if (macro_strip_at
&& kind == '@'
&& (src == start || in->ptr[src - 1] != '@'))
ptr = NULL;
else
ptr = (formal_entry *) hash_find (formal_hash, sb_terminate (t));
if (ptr)
{
if (ptr->actual.len)
{
sb_add_sb (out, &ptr->actual);
}
else
{
sb_add_sb (out, &ptr->def);
}
}
else if (kind == '&')
{
/* Doing this permits people to use & in macro bodies. */
sb_add_char (out, '&');
sb_add_sb (out, t);
if (src != start && in->ptr[src - 1] == '&')
sb_add_char (out, '&');
}
else if (copyifnotthere)
{
sb_add_sb (out, t);
}
else
{
sb_add_char (out, '\\');
sb_add_sb (out, t);
}
return src;
}
void
input_scrub_include_sb (sb *from, char *position, int is_expansion)
{
int newline;
if (macro_nest > max_macro_nest)
as_fatal (_("macros nested too deeply"));
++macro_nest;
#ifdef md_macro_start
if (is_expansion)
{
md_macro_start ();
}
#endif
next_saved_file = input_scrub_push (position);
/* Allocate sufficient space: from->len + optional newline. */
newline = from->len >= 1 && from->ptr[0] != '\n';
sb_build (&from_sb, from->len + newline);
from_sb_is_expansion = is_expansion;
if (newline)
{
/* Add the sentinel required by read.c. */
sb_add_char (&from_sb, '\n');
}
sb_scrub_and_add_sb (&from_sb, from);
/* Make sure the parser looks at defined contents when it scans for
e.g. end-of-line at the end of a macro. */
sb_terminate (&from_sb);
sb_index = 1;
/* These variables are reset by input_scrub_push. Restore them
since we are, after all, still at the same point in the file. */
logical_input_line = next_saved_file->logical_input_line;
logical_input_file = next_saved_file->logical_input_file;
}
static const char *
macro_expand (int idx, sb *in, macro_entry *m, sb *out)
{
sb t;
formal_entry *ptr;
formal_entry *f;
int is_keyword = 0;
int narg = 0;
const char *err = NULL;
sb_new (&t);
/* Reset any old value the actuals may have. */
for (f = m->formals; f; f = f->next)
sb_reset (&f->actual);
f = m->formals;
while (f != NULL && f->index < 0)
f = f->next;
if (macro_mri)
{
/* The macro may be called with an optional qualifier, which may
be referred to in the macro body as \0. */
if (idx < in->len && in->ptr[idx] == '.')
{
/* The Microtec assembler ignores this if followed by a white space.
(Macro invocation with empty extension) */
idx++;
if ( idx < in->len
&& in->ptr[idx] != ' '
&& in->ptr[idx] != '\t')
{
formal_entry *n = new_formal ();
n->index = QUAL_INDEX;
n->next = m->formals;
m->formals = n;
idx = get_any_string (idx, in, &n->actual);
}
}
}
/* Peel off the actuals and store them away in the hash tables' actuals. */
idx = sb_skip_white (idx, in);
while (idx < in->len)
{
int scan;
/* Look and see if it's a positional or keyword arg. */
scan = idx;
while (scan < in->len
&& !ISSEP (in->ptr[scan])
&& !(macro_mri && in->ptr[scan] == '\'')
&& (!macro_alternate && in->ptr[scan] != '='))
scan++;
if (scan < in->len && !macro_alternate && in->ptr[scan] == '=')
{
is_keyword = 1;
/* It's OK to go from positional to keyword. */
/* This is a keyword arg, fetch the formal name and
then the actual stuff. */
sb_reset (&t);
idx = get_token (idx, in, &t);
if (in->ptr[idx] != '=')
{
err = _("confusion in formal parameters");
break;
}
/* Lookup the formal in the macro's list. */
ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t));
if (!ptr)
as_bad (_("Parameter named `%s' does not exist for macro `%s'"),
t.ptr,
m->name);
else
{
/* Insert this value into the right place. */
if (ptr->actual.len)
{
as_warn (_("Value for parameter `%s' of macro `%s' was already specified"),
ptr->name.ptr,
m->name);
sb_reset (&ptr->actual);
}
idx = get_any_string (idx + 1, in, &ptr->actual);
if (ptr->actual.len > 0)
++narg;
}
}
else
{
if (is_keyword)
{
err = _("can't mix positional and keyword arguments");
break;
}
if (!f)
{
formal_entry **pf;
int c;
if (!macro_mri)
{
err = _("too many positional arguments");
break;
}
f = new_formal ();
c = -1;
for (pf = &m->formals; *pf != NULL; pf = &(*pf)->next)
if ((*pf)->index >= c)
c = (*pf)->index + 1;
if (c == -1)
c = 0;
*pf = f;
f->index = c;
}
if (f->type != FORMAL_VARARG)
idx = get_any_string (idx, in, &f->actual);
else
{
sb_add_buffer (&f->actual, in->ptr + idx, in->len - idx);
idx = in->len;
}
if (f->actual.len > 0)
++narg;
do
{
f = f->next;
}
while (f != NULL && f->index < 0);
}
if (! macro_mri)
idx = sb_skip_comma (idx, in);
else
{
if (in->ptr[idx] == ',')
++idx;
if (ISWHITE (in->ptr[idx]))
break;
}
}
if (! err)
{
for (ptr = m->formals; ptr; ptr = ptr->next)
{
if (ptr->type == FORMAL_REQUIRED && ptr->actual.len == 0)
as_bad (_("Missing value for required parameter `%s' of macro `%s'"),
ptr->name.ptr,
m->name);
}
if (macro_mri)
{
char buffer[20];
sb_reset (&t);
sb_add_string (&t, macro_strip_at ? "$NARG" : "NARG");
ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t));
sprintf (buffer, "%d", narg);
sb_add_string (&ptr->actual, buffer);
}
err = macro_expand_body (&m->sub, out, m->formals, m->formal_hash, m);
}
/* Discard any unnamed formal arguments. */
if (macro_mri)
{
formal_entry **pf;
pf = &m->formals;
while (*pf != NULL)
{
if ((*pf)->name.len != 0)
pf = &(*pf)->next;
else
{
f = (*pf)->next;
del_formal (*pf);
*pf = f;
}
}
}
sb_kill (&t);
if (!err)
macro_number++;
return err;
}
static const char *
macro_expand_body (sb *in, sb *out, formal_entry *formals,
struct hash_control *formal_hash, const macro_entry *macro)
{
sb t;
int src = 0, inquote = 0, macro_line = 0;
formal_entry *loclist = NULL;
const char *err = NULL;
sb_new (&t);
while (src < in->len && !err)
{
if (in->ptr[src] == '&')
{
sb_reset (&t);
if (macro_mri)
{
if (src + 1 < in->len && in->ptr[src + 1] == '&')
src = sub_actual (src + 2, in, &t, formal_hash, '\'', out, 1);
else
sb_add_char (out, in->ptr[src++]);
}
else
{
/* FIXME: Why do we do this? */
/* At least in alternate mode this seems correct; without this
one can't append a literal to a parameter. */
src = sub_actual (src + 1, in, &t, formal_hash, '&', out, 0);
}
}
else if (in->ptr[src] == '\\')
{
src++;
if (src < in->len && in->ptr[src] == '(')
{
/* Sub in till the next ')' literally. */
src++;
while (src < in->len && in->ptr[src] != ')')
{
sb_add_char (out, in->ptr[src++]);
}
if (src < in->len)
src++;
else if (!macro)
err = _("missing `)'");
else
as_bad_where (macro->file, macro->line + macro_line, _("missing `)'"));
}
else if (src < in->len && in->ptr[src] == '@')
{
/* Sub in the macro invocation number. */
char buffer[10];
src++;
sprintf (buffer, "%d", macro_number);
sb_add_string (out, buffer);
}
else if (src < in->len && in->ptr[src] == '&')
{
/* This is a preprocessor variable name, we don't do them
here. */
sb_add_char (out, '\\');
sb_add_char (out, '&');
src++;
}
else if (macro_mri && src < in->len && ISALNUM (in->ptr[src]))
{
int ind;
formal_entry *f;
if (ISDIGIT (in->ptr[src]))
ind = in->ptr[src] - '0';
else if (ISUPPER (in->ptr[src]))
ind = in->ptr[src] - 'A' + 10;
else
ind = in->ptr[src] - 'a' + 10;
++src;
for (f = formals; f != NULL; f = f->next)
{
if (f->index == ind - 1)
{
if (f->actual.len != 0)
sb_add_sb (out, &f->actual);
else
sb_add_sb (out, &f->def);
break;
}
}
}
else
{
sb_reset (&t);
src = sub_actual (src, in, &t, formal_hash, '\'', out, 0);
}
}
else if ((macro_alternate || macro_mri)
&& is_name_beginner (in->ptr[src])
&& (! inquote
|| ! macro_strip_at
|| (src > 0 && in->ptr[src - 1] == '@')))
{
if (! macro
|| src + 5 >= in->len
|| strncasecmp (in->ptr + src, "LOCAL", 5) != 0
|| ! ISWHITE (in->ptr[src + 5]))
{
sb_reset (&t);
src = sub_actual (src, in, &t, formal_hash,
(macro_strip_at && inquote) ? '@' : '\'',
out, 1);
}
else
{
src = sb_skip_white (src + 5, in);
while (in->ptr[src] != '\n')
{
const char *name;
formal_entry *f = new_formal ();
src = get_token (src, in, &f->name);
name = sb_terminate (&f->name);
if (! hash_find (formal_hash, name))
{
static int loccnt;
char buf[20];
f->index = LOCAL_INDEX;
f->next = loclist;
loclist = f;
sprintf (buf, IS_ELF ? ".LL%04x" : "LL%04x", ++loccnt);
sb_add_string (&f->actual, buf);
err = hash_jam (formal_hash, name, f);
if (err != NULL)
break;
}
else
{
as_bad_where (macro->file,
macro->line + macro_line,
_("`%s' was already used as parameter (or another local) name"),
name);
del_formal (f);
}
src = sb_skip_comma (src, in);
}
}
}
else if (in->ptr[src] == '"'
|| (macro_mri && in->ptr[src] == '\''))
{
inquote = !inquote;
sb_add_char (out, in->ptr[src++]);
}
else if (in->ptr[src] == '@' && macro_strip_at)
{
++src;
if (src < in->len
&& in->ptr[src] == '@')
{
sb_add_char (out, '@');
++src;
}
}
else if (macro_mri
&& in->ptr[src] == '='
&& src + 1 < in->len
&& in->ptr[src + 1] == '=')
{
formal_entry *ptr;
sb_reset (&t);
src = get_token (src + 2, in, &t);
ptr = (formal_entry *) hash_find (formal_hash, sb_terminate (&t));
if (ptr == NULL)
{
/* FIXME: We should really return a warning string here,
but we can't, because the == might be in the MRI
comment field, and, since the nature of the MRI
comment field depends upon the exact instruction
being used, we don't have enough information here to
figure out whether it is or not. Instead, we leave
the == in place, which should cause a syntax error if
it is not in a comment. */
sb_add_char (out, '=');
sb_add_char (out, '=');
sb_add_sb (out, &t);
}
else
{
if (ptr->actual.len)
{
sb_add_string (out, "-1");
}
else
{
sb_add_char (out, '0');
}
}
}
else
{
if (in->ptr[src] == '\n')
++macro_line;
sb_add_char (out, in->ptr[src++]);
}
}
sb_kill (&t);
while (loclist != NULL)
{
formal_entry *f;
f = loclist->next;
/* Setting the value to NULL effectively deletes the entry. We
avoid calling hash_delete because it doesn't reclaim memory. */
hash_jam (formal_hash, sb_terminate (&loclist->name), NULL);
del_formal (loclist);
loclist = f;
}
return err;
}
const char *
define_macro (int idx, sb *in, sb *label,
int (*get_line) (sb *),
char *file, unsigned int line,
const char **namep)
{
macro_entry *macro;
sb name;
const char *error = NULL;
macro = (macro_entry *) xmalloc (sizeof (macro_entry));
sb_new (¯o->sub);
sb_new (&name);
macro->file = file;
macro->line = line;
macro->formal_count = 0;
macro->formals = 0;
macro->formal_hash = hash_new ();
idx = sb_skip_white (idx, in);
if (! buffer_and_nest ("MACRO", "ENDM", ¯o->sub, get_line))
error = _("unexpected end of file in macro `%s' definition");
if (label != NULL && label->len != 0)
{
sb_add_sb (&name, label);
macro->name = sb_terminate (&name);
if (idx < in->len && in->ptr[idx] == '(')
{
/* It's the label: MACRO (formals,...) sort */
idx = do_formals (macro, idx + 1, in);
if (idx < in->len && in->ptr[idx] == ')')
idx = sb_skip_white (idx + 1, in);
else if (!error)
error = _("missing `)' after formals in macro definition `%s'");
}
else
{
/* It's the label: MACRO formals,... sort */
idx = do_formals (macro, idx, in);
}
}
else
{
int cidx;
idx = get_token (idx, in, &name);
macro->name = sb_terminate (&name);
if (name.len == 0)
error = _("Missing macro name");
cidx = sb_skip_white (idx, in);
idx = sb_skip_comma (cidx, in);
if (idx == cidx || idx < in->len)
idx = do_formals (macro, idx, in);
else
idx = cidx;
}
if (!error && idx < in->len)
error = _("Bad parameter list for macro `%s'");
/* And stick it in the macro hash table. */
for (idx = 0; idx < name.len; idx++)
name.ptr[idx] = TOLOWER (name.ptr[idx]);
if (hash_find (macro_hash, macro->name))
error = _("Macro `%s' was already defined");
if (!error)
error = hash_jam (macro_hash, macro->name, (PTR) macro);
if (namep != NULL)
*namep = macro->name;
if (!error)
macro_defined = 1;
else
free_macro (macro);
return error;
}
static int
do_formals (macro_entry *macro, int idx, sb *in)
{
formal_entry **p = ¯o->formals;
const char *name;
idx = sb_skip_white (idx, in);
while (idx < in->len)
{
formal_entry *formal = new_formal ();
int cidx;
idx = get_token (idx, in, &formal->name);
if (formal->name.len == 0)
{
if (macro->formal_count)
--idx;
break;
}
idx = sb_skip_white (idx, in);
/* This is a formal. */
name = sb_terminate (&formal->name);
if (! macro_mri
&& idx < in->len
&& in->ptr[idx] == ':'
&& (! is_name_beginner (':')
|| idx + 1 >= in->len
|| ! is_part_of_name (in->ptr[idx + 1])))
{
/* Got a qualifier. */
sb qual;
sb_new (&qual);
idx = get_token (sb_skip_white (idx + 1, in), in, &qual);
sb_terminate (&qual);
if (qual.len == 0)
as_bad_where (macro->file,
macro->line,
_("Missing parameter qualifier for `%s' in macro `%s'"),
name,
macro->name);
else if (strcmp (qual.ptr, "req") == 0)
formal->type = FORMAL_REQUIRED;
else if (strcmp (qual.ptr, "vararg") == 0)
formal->type = FORMAL_VARARG;
else
as_bad_where (macro->file,
macro->line,
_("`%s' is not a valid parameter qualifier for `%s' in macro `%s'"),
qual.ptr,
name,
macro->name);
sb_kill (&qual);
idx = sb_skip_white (idx, in);
}
if (idx < in->len && in->ptr[idx] == '=')
{
/* Got a default. */
idx = get_any_string (idx + 1, in, &formal->def);
idx = sb_skip_white (idx, in);
if (formal->type == FORMAL_REQUIRED)
{
sb_reset (&formal->def);
as_warn_where (macro->file,
macro->line,
_("Pointless default value for required parameter `%s' in macro `%s'"),
name,
macro->name);
}
}
/* Add to macro's hash table. */
if (! hash_find (macro->formal_hash, name))
hash_jam (macro->formal_hash, name, formal);
else
as_bad_where (macro->file,
macro->line,
_("A parameter named `%s' already exists for macro `%s'"),
name,
macro->name);
formal->index = macro->formal_count++;
*p = formal;
p = &formal->next;
if (formal->type == FORMAL_VARARG)
break;
cidx = idx;
idx = sb_skip_comma (idx, in);
if (idx != cidx && idx >= in->len)
{
idx = cidx;
break;
}
}
if (macro_mri)
{
formal_entry *formal = new_formal ();
/* Add a special NARG formal, which macro_expand will set to the
number of arguments. */
/* The same MRI assemblers which treat '@' characters also use
the name $NARG. At least until we find an exception. */
if (macro_strip_at)
name = "$NARG";
else
name = "NARG";
sb_add_string (&formal->name, name);
/* Add to macro's hash table. */
if (hash_find (macro->formal_hash, name))
as_bad_where (macro->file,
macro->line,
_("Reserved word `%s' used as parameter in macro `%s'"),
name,
macro->name);
hash_jam (macro->formal_hash, name, formal);
formal->index = NARG_INDEX;
*p = formal;
}
return idx;
}
const char *
expand_irp (int irpc, int idx, sb *in, sb *out, int (*get_line) (sb *))
{
sb sub;
formal_entry f;
struct hash_control *h;
const char *err;
idx = sb_skip_white (idx, in);
sb_new (&sub);
if (! buffer_and_nest (NULL, "ENDR", &sub, get_line))
return _("unexpected end of file in irp or irpc");
sb_new (&f.name);
sb_new (&f.def);
sb_new (&f.actual);
idx = get_token (idx, in, &f.name);
if (f.name.len == 0)
return _("missing model parameter");
h = hash_new ();
err = hash_jam (h, sb_terminate (&f.name), &f);
if (err != NULL)
return err;
f.index = 1;
f.next = NULL;
f.type = FORMAL_OPTIONAL;
sb_reset (out);
idx = sb_skip_comma (idx, in);
if (idx >= in->len)
{
/* Expand once with a null string. */
err = macro_expand_body (&sub, out, &f, h, 0);
}
else
{
bfd_boolean in_quotes = FALSE;
if (irpc && in->ptr[idx] == '"')
{
in_quotes = TRUE;
++idx;
}
while (idx < in->len)
{
if (!irpc)
idx = get_any_string (idx, in, &f.actual);
else
{
if (in->ptr[idx] == '"')
{
int nxt;
if (irpc)
in_quotes = ! in_quotes;
nxt = sb_skip_white (idx + 1, in);
if (nxt >= in->len)
{
idx = nxt;
break;
}
}
sb_reset (&f.actual);
sb_add_char (&f.actual, in->ptr[idx]);
++idx;
}
err = macro_expand_body (&sub, out, &f, h, 0);
if (err != NULL)
break;
if (!irpc)
idx = sb_skip_comma (idx, in);
else if (! in_quotes)
idx = sb_skip_white (idx, in);
}
}
hash_die (h);
sb_kill (&f.actual);
sb_kill (&f.def);
sb_kill (&f.name);
sb_kill (&sub);
return err;
}
static int
do_formals (macro_entry *macro, int idx, sb *in)
{
formal_entry **p = ¯o->formals;
macro->formal_count = 0;
macro->formal_hash = hash_new ();
while (idx < in->len)
{
formal_entry *formal;
formal = (formal_entry *) xmalloc (sizeof (formal_entry));
sb_new (&formal->name);
sb_new (&formal->def);
sb_new (&formal->actual);
idx = sb_skip_white (idx, in);
idx = get_token (idx, in, &formal->name);
if (formal->name.len == 0)
break;
idx = sb_skip_white (idx, in);
if (formal->name.len)
{
/* This is a formal. */
if (idx < in->len && in->ptr[idx] == '=')
{
/* Got a default. */
idx = get_any_string (idx + 1, in, &formal->def, 1, 0);
}
}
/* Add to macro's hash table. */
hash_jam (macro->formal_hash, sb_terminate (&formal->name), formal);
formal->index = macro->formal_count;
idx = sb_skip_comma (idx, in);
macro->formal_count++;
*p = formal;
p = &formal->next;
*p = NULL;
}
if (macro_mri)
{
formal_entry *formal;
const char *name;
/* Add a special NARG formal, which macro_expand will set to the
number of arguments. */
formal = (formal_entry *) xmalloc (sizeof (formal_entry));
sb_new (&formal->name);
sb_new (&formal->def);
sb_new (&formal->actual);
/* The same MRI assemblers which treat '@' characters also use
the name $NARG. At least until we find an exception. */
if (macro_strip_at)
name = "$NARG";
else
name = "NARG";
sb_add_string (&formal->name, name);
/* Add to macro's hash table. */
hash_jam (macro->formal_hash, name, formal);
formal->index = NARG_INDEX;
*p = formal;
formal->next = NULL;
}
return idx;
}