/* macro.c - macro support for gas
- Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
- 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 1994-2020 Free Software Foundation, Inc.
Written by Steve and Judy Chamberlain of Cygnus Support,
sac@cygnus.com
GAS is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2, or (at your option)
+ the Free Software Foundation; either version 3, or (at your option)
any later version.
GAS is distributed in the hope that it will be useful,
Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
02110-1301, USA. */
-#include "config.h"
-
-#ifndef __GNUC__
-# if HAVE_ALLOCA_H
-# include <alloca.h>
-# else
-# ifdef _AIX
-/* Indented so that pre-ansi C compilers will ignore it, rather than
- choke on it. Some versions of AIX require this to be the first
- thing in the file. */
- #pragma alloca
-# else
-# ifndef alloca /* predefined by HP cc +Olibcalls */
-# if !defined (__STDC__) && !defined (__hpux)
-extern char *alloca ();
-# else
-extern void *alloca ();
-# endif /* __STDC__, __hpux */
-# endif /* alloca */
-# endif /* _AIX */
-# endif /* HAVE_ALLOCA_H */
-#endif /* __GNUC__ */
-
-#include <stdio.h>
-#ifdef HAVE_STRING_H
-#include <string.h>
-#else
-#include <strings.h>
-#endif
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
#include "as.h"
-#include "libiberty.h"
#include "safe-ctype.h"
#include "sb.h"
-#include "hash.h"
#include "macro.h"
-#include "asintl.h"
-
/* The routines in this file handle macro definition and expansion.
They are called by gas. */
-/* Internal functions. */
-
-static int get_token (int, sb *, sb *);
-static int getstring (int, sb *, sb *);
-static int get_any_string (int, sb *, sb *);
-static formal_entry *new_formal (void);
-static void del_formal (formal_entry *);
-static int do_formals (macro_entry *, int, sb *);
-static int get_apost_token (int, sb *, sb *, int);
-static int sub_actual (int, sb *, sb *, struct hash_control *, int, sb *, int);
-static const char *macro_expand_body
- (sb *, sb *, formal_entry *, struct hash_control *, const macro_entry *);
-static const char *macro_expand (int, sb *, macro_entry *, sb *);
-static void free_macro(macro_entry *);
-
#define ISWHITE(x) ((x) == ' ' || (x) == '\t')
#define ISSEP(x) \
/* Function to use to parse an expression. */
-static int (*macro_expr) (const char *, int, sb *, int *);
+static size_t (*macro_expr) (const char *, size_t, sb *, offsetT *);
/* Number of macro expansions that have been done. */
void
macro_init (int alternate, int mri, int strip_at,
- int (*expr) (const char *, int, sb *, int *))
+ size_t (*exp) (const char *, size_t, sb *, offsetT *))
{
macro_hash = hash_new ();
macro_defined = 0;
macro_alternate = alternate;
macro_mri = mri;
macro_strip_at = strip_at;
- macro_expr = expr;
+ macro_expr = exp;
}
/* Switch in and out of alternate mode on the fly. */
int
buffer_and_nest (const char *from, const char *to, sb *ptr,
- int (*get_line) (sb *))
+ size_t (*get_line) (sb *))
{
- int from_len;
- int to_len = strlen (to);
+ size_t from_len;
+ size_t to_len = strlen (to);
int depth = 1;
- int line_start = ptr->len;
-
- int more = get_line (ptr);
+ size_t line_start = ptr->len;
+ size_t more = get_line (ptr);
- if (to_len == 4 && strcasecmp(to, "ENDR") == 0)
+ if (to_len == 4 && strcasecmp (to, "ENDR") == 0)
{
from = NULL;
from_len = 0;
while (more)
{
- /* Try and find the first pseudo op on the line. */
- int i = line_start;
+ /* Try to find the first pseudo op on the line. */
+ size_t i = line_start;
+ bfd_boolean had_colon = FALSE;
- if (! NO_PSEUDO_DOT && ! flag_m68k_mri)
- {
- /* With normal syntax we can suck what we want till we get
- to the dot. With the alternate, labels have to start in
- the first column, since we can't tell what's a label and
- whats a pseudoop. */
+ /* With normal syntax we can suck what we want till we get
+ to the dot. With the alternate, labels have to start in
+ the first column, since we can't tell what's a label and
+ what's a pseudoop. */
- if (! LABELS_WITHOUT_COLONS)
- {
- /* Skip leading whitespace. */
- while (i < ptr->len && ISWHITE (ptr->ptr[i]))
- i++;
- }
+ if (! LABELS_WITHOUT_COLONS)
+ {
+ /* Skip leading whitespace. */
+ while (i < ptr->len && ISWHITE (ptr->ptr[i]))
+ i++;
+ }
- for (;;)
+ for (;;)
+ {
+ /* Skip over a label, if any. */
+ if (i >= ptr->len || ! is_name_beginner (ptr->ptr[i]))
+ break;
+ i++;
+ while (i < ptr->len && is_part_of_name (ptr->ptr[i]))
+ i++;
+ if (i < ptr->len && is_name_ender (ptr->ptr[i]))
+ i++;
+ /* Skip whitespace. */
+ while (i < ptr->len && ISWHITE (ptr->ptr[i]))
+ i++;
+ /* Check for the colon. */
+ if (i >= ptr->len || ptr->ptr[i] != ':')
{
- /* Skip over a label, if any. */
- if (i >= ptr->len || ! is_name_beginner (ptr->ptr[i]))
- break;
- i++;
- while (i < ptr->len && is_part_of_name (ptr->ptr[i]))
- i++;
- if (i < ptr->len && is_name_ender (ptr->ptr[i]))
- i++;
- if (LABELS_WITHOUT_COLONS)
+ /* LABELS_WITHOUT_COLONS doesn't mean we cannot have a
+ colon after a label. If we do have a colon on the
+ first label then handle more than one label on the
+ line, assuming that each label has a colon. */
+ if (LABELS_WITHOUT_COLONS && !had_colon)
break;
- /* Skip whitespace. */
- while (i < ptr->len && ISWHITE (ptr->ptr[i]))
- i++;
- /* Check for the colon. */
- if (i >= ptr->len || ptr->ptr[i] != ':')
- {
- i = line_start;
- break;
- }
- i++;
- line_start = i;
+ i = line_start;
+ break;
}
-
+ i++;
+ line_start = i;
+ had_colon = TRUE;
}
+
/* Skip trailing whitespace. */
while (i < ptr->len && ISWHITE (ptr->ptr[i]))
i++;
break;
}
}
+
+ /* PR gas/16908
+ Apply and discard .linefile directives that appear within
+ the macro. For long macros, one might want to report the
+ line number information associated with the lines within
+ the macro definition, but we would need more infrastructure
+ to make that happen correctly (e.g. resetting the line
+ number when expanding the macro), and since for short
+ macros we clearly prefer reporting the point of expansion
+ anyway, there's not an obviously better fix here. */
+ if (strncasecmp (ptr->ptr + i, "linefile", 8) == 0)
+ {
+ char saved_eol_char = ptr->ptr[ptr->len];
+
+ ptr->ptr[ptr->len] = '\0';
+ temp_ilp (ptr->ptr + i + 8);
+ s_app_line (0);
+ restore_ilp ();
+ ptr->ptr[ptr->len] = saved_eol_char;
+ ptr->len = line_start;
+ }
}
/* Add the original end-of-line char to the end and keep running. */
/* Pick up a token. */
-static int
-get_token (int idx, sb *in, sb *name)
+static size_t
+get_token (size_t idx, sb *in, sb *name)
{
if (idx < in->len
&& is_name_beginner (in->ptr[idx]))
/* Pick up a string. */
-static int
-getstring (int idx, sb *in, sb *acc)
+static size_t
+getstring (size_t idx, sb *in, sb *acc)
{
while (idx < in->len
&& (in->ptr[idx] == '"'
- || in->ptr[idx] == '('
|| (in->ptr[idx] == '<' && (macro_alternate || macro_mri))
|| (in->ptr[idx] == '\'' && macro_alternate)))
{
- if (in->ptr[idx] == '<'
- || in->ptr[idx] == '(')
+ if (in->ptr[idx] == '<')
{
int nest = 0;
- char start_char = in->ptr[idx];
- char end_char = in->ptr[idx] == '<' ? '>' : ')';
-
idx++;
- while ((in->ptr[idx] != end_char || nest)
- && idx < in->len)
+ while (idx < in->len
+ && (in->ptr[idx] != '>' || nest))
{
if (in->ptr[idx] == '!')
{
}
else
{
- if (in->ptr[idx] == end_char)
+ if (in->ptr[idx] == '>')
nest--;
- if (in->ptr[idx] == start_char)
+ if (in->ptr[idx] == '<')
nest++;
sb_add_char (acc, in->ptr[idx++]);
}
'Bxyx<whitespace> -> return 'Bxyza
%<expr> -> return string of decimal value of <expr>
"string" -> return string
- (string) -> return string
+ (string) -> return (string-including-whitespaces)
xyx<whitespace> -> return xyz. */
-static int
-get_any_string (int idx, sb *in, sb *out)
+static size_t
+get_any_string (size_t idx, sb *in, sb *out)
{
sb_reset (out);
idx = sb_skip_white (idx, in);
{
if (in->len > idx + 2 && in->ptr[idx + 1] == '\'' && ISBASE (in->ptr[idx]))
{
- while (!ISSEP (in->ptr[idx]))
+ while (idx < in->len && !ISSEP (in->ptr[idx]))
sb_add_char (out, in->ptr[idx++]);
}
else if (in->ptr[idx] == '%' && macro_alternate)
{
- int val;
- char buf[20];
+ offsetT val;
+ char buf[64];
/* Turns the next expression into a string. */
/* xgettext: no-c-format */
idx + 1,
in,
&val);
- sprintf (buf, "%d", val);
+ sprintf (buf, "%" BFD_VMA_FMT "d", val);
sb_add_string (out, buf);
}
else if (in->ptr[idx] == '"'
- || in->ptr[idx] == '('
|| (in->ptr[idx] == '<' && (macro_alternate || macro_mri))
|| (macro_alternate && in->ptr[idx] == '\''))
{
- if (macro_alternate && ! macro_strip_at)
+ if (macro_alternate && ! macro_strip_at && in->ptr[idx] != '<')
{
/* Keep the quotes. */
- sb_add_char (out, '\"');
-
+ sb_add_char (out, '"');
idx = getstring (idx, in, out);
- sb_add_char (out, '\"');
+ sb_add_char (out, '"');
}
else
{
}
else
{
+ char *br_buf = XNEWVEC (char, 1);
+ char *in_br = br_buf;
+
+ *in_br = '\0';
while (idx < in->len
- && in->ptr[idx] != ' '
- && in->ptr[idx] != '\t'
+ && (*in_br
+ || (in->ptr[idx] != ' '
+ && in->ptr[idx] != '\t'))
&& in->ptr[idx] != ','
&& (in->ptr[idx] != '<'
|| (! macro_alternate && ! macro_mri)))
{
- if (in->ptr[idx] == '"'
- || in->ptr[idx] == '\'')
- {
- char tchar = in->ptr[idx];
+ char tchar = in->ptr[idx];
+ switch (tchar)
+ {
+ case '"':
+ case '\'':
sb_add_char (out, in->ptr[idx++]);
while (idx < in->len
&& in->ptr[idx] != tchar)
sb_add_char (out, in->ptr[idx++]);
if (idx == in->len)
- return idx;
+ {
+ free (br_buf);
+ return idx;
+ }
+ break;
+ case '(':
+ case '[':
+ if (in_br > br_buf)
+ --in_br;
+ else
+ {
+ br_buf = XNEWVEC (char, strlen (in_br) + 2);
+ strcpy (br_buf + 1, in_br);
+ free (in_br);
+ in_br = br_buf;
+ }
+ *in_br = tchar;
+ break;
+ case ')':
+ if (*in_br == '(')
+ ++in_br;
+ break;
+ case ']':
+ if (*in_br == '[')
+ ++in_br;
+ break;
}
- sb_add_char (out, in->ptr[idx++]);
+ sb_add_char (out, tchar);
+ ++idx;
}
+ free (br_buf);
}
}
{
formal_entry *formal;
- formal = xmalloc (sizeof (formal_entry));
+ formal = XNEW (formal_entry);
sb_new (&formal->name);
sb_new (&formal->def);
/* Pick up the formal parameters of a macro definition. */
-static int
-do_formals (macro_entry *macro, int idx, sb *in)
+static size_t
+do_formals (macro_entry *macro, size_t idx, sb *in)
{
formal_entry **p = ¯o->formals;
const char *name;
while (idx < in->len)
{
formal_entry *formal = new_formal ();
- int cidx;
+ size_t cidx;
idx = get_token (idx, in, &formal->name);
if (formal->name.len == 0)
{
if (macro->formal_count)
--idx;
+ del_formal (formal); /* 'formal' goes out of scope. */
break;
}
idx = sb_skip_white (idx, in);
formal_entry *formal = new_formal ();
/* Add a special NARG formal, which macro_expand will set to the
- number of arguments. */
+ number of arguments. */
/* The same MRI assemblers which treat '@' characters also use
- the name $NARG. At least until we find an exception. */
+ the name $NARG. At least until we find an exception. */
if (macro_strip_at)
name = "$NARG";
else
return idx;
}
+/* Free the memory allocated to a macro. */
+
+static void
+free_macro (macro_entry *macro)
+{
+ formal_entry *formal;
+
+ for (formal = macro->formals; formal; )
+ {
+ formal_entry *f;
+
+ f = formal;
+ formal = formal->next;
+ del_formal (f);
+ }
+ hash_die (macro->formal_hash);
+ sb_kill (¯o->sub);
+ free (macro);
+}
+
/* Define a new macro. Returns NULL on success, otherwise returns an
error message. If NAMEP is not NULL, *NAMEP is set to the name of
the macro which was defined. */
const char *
-define_macro (int idx, sb *in, sb *label,
- int (*get_line) (sb *),
- char *file, unsigned int line,
+define_macro (size_t idx, sb *in, sb *label,
+ size_t (*get_line) (sb *),
+ const char *file, unsigned int line,
const char **namep)
{
macro_entry *macro;
sb name;
const char *error = NULL;
- macro = (macro_entry *) xmalloc (sizeof (macro_entry));
+ macro = XNEW (macro_entry);
sb_new (¯o->sub);
sb_new (&name);
macro->file = file;
macro->formal_count = 0;
macro->formals = 0;
- macro->formal_hash = hash_new ();
+ macro->formal_hash = hash_new_sized (7);
idx = sb_skip_white (idx, in);
if (! buffer_and_nest ("MACRO", "ENDM", ¯o->sub, get_line))
}
else
{
- int cidx;
+ size_t cidx;
idx = get_token (idx, in, &name);
macro->name = sb_terminate (&name);
if (hash_find (macro_hash, macro->name))
error = _("Macro `%s' was already defined");
if (!error)
- error = hash_jam (macro_hash, macro->name, (PTR) macro);
+ error = hash_jam (macro_hash, macro->name, (void *) macro);
if (namep != NULL)
*namep = macro->name;
/* Scan a token, and then skip KIND. */
-static int
-get_apost_token (int idx, sb *in, sb *name, int kind)
+static size_t
+get_apost_token (size_t idx, sb *in, sb *name, int kind)
{
idx = get_token (idx, in, name);
if (idx < in->len
/* Substitute the actual value for a formal parameter. */
-static int
-sub_actual (int start, sb *in, sb *t, struct hash_control *formal_hash,
+static size_t
+sub_actual (size_t start, sb *in, sb *t, struct hash_control *formal_hash,
int kind, sb *out, int copyifnotthere)
{
- int src;
+ size_t src;
formal_entry *ptr;
src = get_apost_token (start, in, t, 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)
{
struct hash_control *formal_hash, const macro_entry *macro)
{
sb t;
- int src = 0, inquote = 0, macro_line = 0;
+ size_t src = 0;
+ int inquote = 0, macro_line = 0;
formal_entry *loclist = NULL;
const char *err = NULL;
}
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. */
+ /* Permit macro parameter substitution delineated with
+ an '&' prefix and optional '&' suffix. */
src = sub_actual (src + 1, in, &t, formal_hash, '&', out, 0);
}
}
{
/* Sub in the macro invocation number. */
- char buffer[10];
+ char buffer[12];
src++;
sprintf (buffer, "%d", macro_number);
sb_add_string (out, buffer);
if (! macro
|| src + 5 >= in->len
|| strncasecmp (in->ptr + src, "LOCAL", 5) != 0
- || ! ISWHITE (in->ptr[src + 5]))
+ || ! ISWHITE (in->ptr[src + 5])
+ /* PR 11507: Skip keyword LOCAL if it is found inside a quoted string. */
+ || inquote)
{
sb_reset (&t);
src = sub_actual (src, in, &t, formal_hash,
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. */
+ 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);
while (loclist != NULL)
{
formal_entry *f;
+ const char *name;
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);
+ name = sb_terminate (&loclist->name);
+ hash_delete (formal_hash, name, f == NULL);
del_formal (loclist);
loclist = f;
}
body. */
static const char *
-macro_expand (int idx, sb *in, macro_entry *m, sb *out)
+macro_expand (size_t idx, sb *in, macro_entry *m, sb *out)
{
sb t;
formal_entry *ptr;
formal_entry *f;
- int is_positional = 0;
int is_keyword = 0;
int narg = 0;
const char *err = NULL;
if (macro_mri)
{
/* The macro may be called with an optional qualifier, which may
- be referred to in the macro body as \0. */
+ 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.
idx = sb_skip_white (idx, in);
while (idx < in->len)
{
- int scan;
+ size_t scan;
/* Look and see if it's a positional or keyword arg. */
scan = idx;
/* 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);
+ {
+ as_bad (_("Parameter named `%s' does not exist for macro `%s'"),
+ t.ptr,
+ m->name);
+ sb_reset (&t);
+ idx = get_any_string (idx + 1, in, &t);
+ }
else
{
/* Insert this value into the right place. */
}
else
{
- /* This is a positional arg. */
- is_positional = 1;
if (is_keyword)
{
err = _("can't mix positional and keyword arguments");
const char **error, macro_entry **info)
{
const char *s;
- char *copy, *cs;
+ char *copy, *cls;
macro_entry *macro;
sb line_sb;
if (is_name_ender (*s))
++s;
- copy = (char *) alloca (s - line + 1);
- memcpy (copy, line, s - line);
- copy[s - line] = '\0';
- for (cs = copy; *cs != '\0'; cs++)
- *cs = TOLOWER (*cs);
+ copy = xmemdup0 (line, s - line);
+ for (cls = copy; *cls != '\0'; cls ++)
+ *cls = TOLOWER (*cls);
macro = (macro_entry *) hash_find (macro_hash, copy);
+ free (copy);
if (macro == NULL)
return 0;
return 1;
}
-/* Free the memory allocated to a macro. */
-
-static void
-free_macro(macro_entry *macro)
-{
- formal_entry *formal;
-
- for (formal = macro->formals; formal; )
- {
- formal_entry *f;
-
- f = formal;
- formal = formal->next;
- del_formal (f);
- }
- hash_die (macro->formal_hash);
- sb_kill (¯o->sub);
- free (macro);
-}
-
/* Delete a macro. */
void
macro_entry *macro;
len = strlen (name);
- copy = (char *) alloca (len + 1);
+ copy = XNEWVEC (char, len + 1);
for (i = 0; i < len; ++i)
copy[i] = TOLOWER (name[i]);
copy[i] = '\0';
- /* Since hash_delete doesn't free memory, just clear out the entry. */
- if ((macro = hash_find (macro_hash, copy)) != NULL)
+ /* We can only ask hash_delete to free memory if we are deleting
+ macros in reverse order to their definition.
+ So just clear out the entry. */
+ if ((macro = (macro_entry *) hash_find (macro_hash, copy)) != NULL)
{
hash_jam (macro_hash, copy, NULL);
free_macro (macro);
}
else
- as_warn (_("Attempt to purge non-existant macro `%s'"), copy);
+ as_warn (_("Attempt to purge non-existing macro `%s'"), copy);
+ free (copy);
}
/* Handle the MRI IRP and IRPC pseudo-ops. These are handled as a
success, or an error message otherwise. */
const char *
-expand_irp (int irpc, int idx, sb *in, sb *out, int (*get_line) (sb *))
+expand_irp (int irpc, size_t idx, sb *in, sb *out, size_t (*get_line) (sb *))
{
sb sub;
formal_entry f;
}
else
{
+ bfd_boolean in_quotes = FALSE;
+
if (irpc && in->ptr[idx] == '"')
- ++idx;
+ {
+ in_quotes = TRUE;
+ ++idx;
+ }
+
while (idx < in->len)
{
if (!irpc)
{
if (in->ptr[idx] == '"')
{
- int nxt;
+ size_t nxt;
+
+ if (irpc)
+ in_quotes = ! in_quotes;
nxt = sb_skip_white (idx + 1, in);
if (nxt >= in->len)
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
+ else if (! in_quotes)
idx = sb_skip_white (idx, in);
}
}
projects / deliverable / binutils-gdb.git / blobdiff