1187 lines
26 KiB
C
1187 lines
26 KiB
C
/* macro.c - macro support for gas
|
|
Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
|
|
Free Software Foundation, Inc.
|
|
|
|
Written by Steve and Judy Chamberlain of Cygnus Support,
|
|
sac@cygnus.com
|
|
|
|
This file is part of GAS, the GNU Assembler.
|
|
|
|
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)
|
|
any later version.
|
|
|
|
GAS is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GAS; see the file COPYING. If not, write to the Free
|
|
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|
02111-1307, 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 "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 *, int, int);
|
|
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 *, int);
|
|
static const char *macro_expand (int, sb *, macro_entry *, sb *);
|
|
|
|
#define ISWHITE(x) ((x) == ' ' || (x) == '\t')
|
|
|
|
#define ISSEP(x) \
|
|
((x) == ' ' || (x) == '\t' || (x) == ',' || (x) == '"' || (x) == ';' \
|
|
|| (x) == ')' || (x) == '(' \
|
|
|| ((macro_alternate || macro_mri) && ((x) == '<' || (x) == '>')))
|
|
|
|
#define ISBASE(x) \
|
|
((x) == 'b' || (x) == 'B' \
|
|
|| (x) == 'q' || (x) == 'Q' \
|
|
|| (x) == 'h' || (x) == 'H' \
|
|
|| (x) == 'd' || (x) == 'D')
|
|
|
|
/* The macro hash table. */
|
|
|
|
struct hash_control *macro_hash;
|
|
|
|
/* Whether any macros have been defined. */
|
|
|
|
int macro_defined;
|
|
|
|
/* Whether we are in alternate syntax mode. */
|
|
|
|
static int macro_alternate;
|
|
|
|
/* Whether we are in MRI mode. */
|
|
|
|
static int macro_mri;
|
|
|
|
/* Whether we should strip '@' characters. */
|
|
|
|
static int macro_strip_at;
|
|
|
|
/* Function to use to parse an expression. */
|
|
|
|
static int (*macro_expr) (const char *, int, sb *, int *);
|
|
|
|
/* Number of macro expansions that have been done. */
|
|
|
|
static int macro_number;
|
|
|
|
/* Initialize macro processing. */
|
|
|
|
void
|
|
macro_init (int alternate, int mri, int strip_at,
|
|
int (*expr) (const char *, int, sb *, int *))
|
|
{
|
|
macro_hash = hash_new ();
|
|
macro_defined = 0;
|
|
macro_alternate = alternate;
|
|
macro_mri = mri;
|
|
macro_strip_at = strip_at;
|
|
macro_expr = expr;
|
|
}
|
|
|
|
/* Switch in and out of alternate mode on the fly. */
|
|
|
|
void
|
|
macro_set_alternate(alternate)
|
|
int alternate;
|
|
{
|
|
macro_alternate = alternate;
|
|
}
|
|
|
|
/* Switch in and out of MRI mode on the fly. */
|
|
|
|
void
|
|
macro_mri_mode (int mri)
|
|
{
|
|
macro_mri = mri;
|
|
}
|
|
|
|
/* Read input lines till we get to a TO string.
|
|
Increase nesting depth if we get a FROM string.
|
|
Put the results into sb at PTR.
|
|
Add a new input line to an sb using GET_LINE.
|
|
Return 1 on success, 0 on unexpected EOF. */
|
|
|
|
int
|
|
buffer_and_nest (const char *from, const char *to, sb *ptr,
|
|
int (*get_line) (sb *))
|
|
{
|
|
int from_len = strlen (from);
|
|
int to_len = strlen (to);
|
|
int depth = 1;
|
|
int line_start = ptr->len;
|
|
|
|
int more = get_line (ptr);
|
|
|
|
while (more)
|
|
{
|
|
/* Try and find the first pseudo op on the line. */
|
|
int i = line_start;
|
|
|
|
if (! macro_alternate && ! macro_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 cant tell what's a label and
|
|
whats a pseudoop. */
|
|
|
|
/* Skip leading whitespace. */
|
|
while (i < ptr->len && ISWHITE (ptr->ptr[i]))
|
|
i++;
|
|
|
|
/* Skip over a label. */
|
|
while (i < ptr->len
|
|
&& (ISALNUM (ptr->ptr[i])
|
|
|| ptr->ptr[i] == '_'
|
|
|| ptr->ptr[i] == '$'))
|
|
i++;
|
|
|
|
/* And a colon. */
|
|
if (i < ptr->len
|
|
&& ptr->ptr[i] == ':')
|
|
i++;
|
|
|
|
}
|
|
/* Skip trailing whitespace. */
|
|
while (i < ptr->len && ISWHITE (ptr->ptr[i]))
|
|
i++;
|
|
|
|
if (i < ptr->len && (ptr->ptr[i] == '.'
|
|
|| macro_alternate
|
|
|| macro_mri))
|
|
{
|
|
if (ptr->ptr[i] == '.')
|
|
i++;
|
|
if (strncasecmp (ptr->ptr + i, from, from_len) == 0
|
|
&& (ptr->len == (i + from_len)
|
|
|| ! ISALNUM (ptr->ptr[i + from_len])))
|
|
depth++;
|
|
if (strncasecmp (ptr->ptr + i, to, to_len) == 0
|
|
&& (ptr->len == (i + to_len)
|
|
|| ! ISALNUM (ptr->ptr[i + to_len])))
|
|
{
|
|
depth--;
|
|
if (depth == 0)
|
|
{
|
|
/* Reset the string to not include the ending rune. */
|
|
ptr->len = line_start;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Add the original end-of-line char to the end and keep running. */
|
|
sb_add_char (ptr, more);
|
|
line_start = ptr->len;
|
|
more = get_line (ptr);
|
|
}
|
|
|
|
/* Return 1 on success, 0 on unexpected EOF. */
|
|
return depth == 0;
|
|
}
|
|
|
|
/* Pick up a token. */
|
|
|
|
static int
|
|
get_token (int idx, sb *in, sb *name)
|
|
{
|
|
if (idx < in->len
|
|
&& (ISALPHA (in->ptr[idx])
|
|
|| in->ptr[idx] == '_'
|
|
|| in->ptr[idx] == '$'))
|
|
{
|
|
sb_add_char (name, in->ptr[idx++]);
|
|
while (idx < in->len
|
|
&& (ISALNUM (in->ptr[idx])
|
|
|| in->ptr[idx] == '_'
|
|
|| in->ptr[idx] == '$'))
|
|
{
|
|
sb_add_char (name, in->ptr[idx++]);
|
|
}
|
|
}
|
|
/* Ignore trailing &. */
|
|
if (macro_alternate && idx < in->len && in->ptr[idx] == '&')
|
|
idx++;
|
|
return idx;
|
|
}
|
|
|
|
/* Pick up a string. */
|
|
|
|
static int
|
|
getstring (int idx, sb *in, sb *acc)
|
|
{
|
|
idx = sb_skip_white (idx, in);
|
|
|
|
while (idx < in->len
|
|
&& (in->ptr[idx] == '"'
|
|
|| (in->ptr[idx] == '<' && (macro_alternate || macro_mri))
|
|
|| (in->ptr[idx] == '\'' && macro_alternate)))
|
|
{
|
|
if (in->ptr[idx] == '<')
|
|
{
|
|
int nest = 0;
|
|
idx++;
|
|
while ((in->ptr[idx] != '>' || nest)
|
|
&& idx < in->len)
|
|
{
|
|
if (in->ptr[idx] == '!')
|
|
{
|
|
idx++;
|
|
sb_add_char (acc, in->ptr[idx++]);
|
|
}
|
|
else
|
|
{
|
|
if (in->ptr[idx] == '>')
|
|
nest--;
|
|
if (in->ptr[idx] == '<')
|
|
nest++;
|
|
sb_add_char (acc, in->ptr[idx++]);
|
|
}
|
|
}
|
|
idx++;
|
|
}
|
|
else if (in->ptr[idx] == '"' || in->ptr[idx] == '\'')
|
|
{
|
|
char tchar = in->ptr[idx];
|
|
int escaped = 0;
|
|
|
|
idx++;
|
|
|
|
while (idx < in->len)
|
|
{
|
|
if (in->ptr[idx - 1] == '\\')
|
|
escaped ^= 1;
|
|
else
|
|
escaped = 0;
|
|
|
|
if (macro_alternate && in->ptr[idx] == '!')
|
|
{
|
|
idx ++;
|
|
|
|
sb_add_char (acc, in->ptr[idx]);
|
|
|
|
idx ++;
|
|
}
|
|
else if (escaped && in->ptr[idx] == tchar)
|
|
{
|
|
sb_add_char (acc, tchar);
|
|
idx ++;
|
|
}
|
|
else
|
|
{
|
|
if (in->ptr[idx] == tchar)
|
|
{
|
|
idx ++;
|
|
|
|
if (idx >= in->len || in->ptr[idx] != tchar)
|
|
break;
|
|
}
|
|
|
|
sb_add_char (acc, in->ptr[idx]);
|
|
idx ++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return idx;
|
|
}
|
|
|
|
/* Fetch string from the input stream,
|
|
rules:
|
|
'Bxyx<whitespace> -> return 'Bxyza
|
|
%<char> -> return string of decimal value of x
|
|
"<string>" -> return string
|
|
xyx<whitespace> -> return xyz
|
|
*/
|
|
|
|
static int
|
|
get_any_string (int idx, sb *in, sb *out, int expand, int pretend_quoted)
|
|
{
|
|
sb_reset (out);
|
|
idx = sb_skip_white (idx, in);
|
|
|
|
if (idx < in->len)
|
|
{
|
|
if (in->len > idx + 2 && in->ptr[idx + 1] == '\'' && ISBASE (in->ptr[idx]))
|
|
{
|
|
while (!ISSEP (in->ptr[idx]))
|
|
sb_add_char (out, in->ptr[idx++]);
|
|
}
|
|
else if (in->ptr[idx] == '%'
|
|
&& macro_alternate
|
|
&& expand)
|
|
{
|
|
int val;
|
|
char buf[20];
|
|
/* Turns the next expression into a string. */
|
|
/* xgettext: no-c-format */
|
|
idx = (*macro_expr) (_("% operator needs absolute expression"),
|
|
idx + 1,
|
|
in,
|
|
&val);
|
|
sprintf (buf, "%d", val);
|
|
sb_add_string (out, buf);
|
|
}
|
|
else if (in->ptr[idx] == '"'
|
|
|| (in->ptr[idx] == '<' && (macro_alternate || macro_mri))
|
|
|| (macro_alternate && in->ptr[idx] == '\''))
|
|
{
|
|
if (macro_alternate
|
|
&& ! macro_strip_at
|
|
&& expand)
|
|
{
|
|
/* Keep the quotes. */
|
|
sb_add_char (out, '\"');
|
|
|
|
idx = getstring (idx, in, out);
|
|
sb_add_char (out, '\"');
|
|
}
|
|
else
|
|
{
|
|
idx = getstring (idx, in, out);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (idx < in->len
|
|
&& (in->ptr[idx] == '"'
|
|
|| in->ptr[idx] == '\''
|
|
|| pretend_quoted
|
|
|| (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];
|
|
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;
|
|
}
|
|
sb_add_char (out, in->ptr[idx++]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return idx;
|
|
}
|
|
|
|
/* Pick up the formal parameters of a macro definition. */
|
|
|
|
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;
|
|
}
|
|
|
|
/* 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 *), 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;
|
|
}
|
|
|
|
/* Scan a token, and then skip KIND. */
|
|
|
|
static int
|
|
get_apost_token (int idx, sb *in, sb *name, int kind)
|
|
{
|
|
idx = get_token (idx, in, name);
|
|
if (idx < in->len
|
|
&& in->ptr[idx] == kind
|
|
&& (! macro_mri || macro_strip_at)
|
|
&& (! macro_strip_at || kind == '@'))
|
|
idx++;
|
|
return idx;
|
|
}
|
|
|
|
/* Substitute the actual value for a formal parameter. */
|
|
|
|
static int
|
|
sub_actual (int start, sb *in, sb *t, struct hash_control *formal_hash,
|
|
int kind, sb *out, int copyifnotthere)
|
|
{
|
|
int 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);
|
|
}
|
|
else if (copyifnotthere)
|
|
{
|
|
sb_add_sb (out, t);
|
|
}
|
|
else
|
|
{
|
|
sb_add_char (out, '\\');
|
|
sb_add_sb (out, t);
|
|
}
|
|
return src;
|
|
}
|
|
|
|
/* Expand the body of a macro. */
|
|
|
|
static const char *
|
|
macro_expand_body (sb *in, sb *out, formal_entry *formals,
|
|
struct hash_control *formal_hash, int locals)
|
|
{
|
|
sb t;
|
|
int src = 0;
|
|
int inquote = 0;
|
|
formal_entry *loclist = NULL;
|
|
|
|
sb_new (&t);
|
|
|
|
while (src < in->len)
|
|
{
|
|
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? */
|
|
src = sub_actual (src + 1, in, &t, formal_hash, '&', out, 0);
|
|
}
|
|
}
|
|
else if (in->ptr[src] == '\\')
|
|
{
|
|
src++;
|
|
if (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 (in->ptr[src] == ')')
|
|
src++;
|
|
else
|
|
return _("missplaced )");
|
|
}
|
|
else if (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 (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 && 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)
|
|
&& (ISALPHA (in->ptr[src])
|
|
|| in->ptr[src] == '_'
|
|
|| in->ptr[src] == '$')
|
|
&& (! inquote
|
|
|| ! macro_strip_at
|
|
|| (src > 0 && in->ptr[src - 1] == '@')))
|
|
{
|
|
if (! locals
|
|
|| 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
|
|
{
|
|
formal_entry *f;
|
|
|
|
src = sb_skip_white (src + 5, in);
|
|
while (in->ptr[src] != '\n')
|
|
{
|
|
static int loccnt;
|
|
char buf[20];
|
|
const char *err;
|
|
|
|
f = (formal_entry *) xmalloc (sizeof (formal_entry));
|
|
sb_new (&f->name);
|
|
sb_new (&f->def);
|
|
sb_new (&f->actual);
|
|
f->index = LOCAL_INDEX;
|
|
f->next = loclist;
|
|
loclist = f;
|
|
|
|
src = get_token (src, in, &f->name);
|
|
++loccnt;
|
|
sprintf (buf, "LL%04x", loccnt);
|
|
sb_add_string (&f->actual, buf);
|
|
|
|
err = hash_jam (formal_hash, sb_terminate (&f->name), f);
|
|
if (err != NULL)
|
|
return err;
|
|
|
|
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
|
|
{
|
|
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);
|
|
sb_kill (&loclist->name);
|
|
sb_kill (&loclist->def);
|
|
sb_kill (&loclist->actual);
|
|
free (loclist);
|
|
loclist = f;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Assign values to the formal parameters of a macro, and expand the
|
|
body. */
|
|
|
|
static const char *
|
|
macro_expand (int 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;
|
|
|
|
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;
|
|
|
|
n = (formal_entry *) xmalloc (sizeof (formal_entry));
|
|
sb_new (&n->name);
|
|
sb_new (&n->def);
|
|
sb_new (&n->actual);
|
|
n->index = QUAL_INDEX;
|
|
|
|
n->next = m->formals;
|
|
m->formals = n;
|
|
|
|
idx = get_any_string (idx, in, &n->actual, 1, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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] != '=')
|
|
return _("confusion in formal parameters");
|
|
|
|
/* Lookup the formal in the macro's list. */
|
|
ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t));
|
|
if (!ptr)
|
|
return _("macro formal argument does not exist");
|
|
else
|
|
{
|
|
/* Insert this value into the right place. */
|
|
sb_reset (&ptr->actual);
|
|
idx = get_any_string (idx + 1, in, &ptr->actual, 0, 0);
|
|
if (ptr->actual.len > 0)
|
|
++narg;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* This is a positional arg. */
|
|
is_positional = 1;
|
|
if (is_keyword)
|
|
return _("can't mix positional and keyword arguments");
|
|
|
|
if (!f)
|
|
{
|
|
formal_entry **pf;
|
|
int c;
|
|
|
|
if (!macro_mri)
|
|
return _("too many positional arguments");
|
|
|
|
f = (formal_entry *) xmalloc (sizeof (formal_entry));
|
|
sb_new (&f->name);
|
|
sb_new (&f->def);
|
|
sb_new (&f->actual);
|
|
f->next = NULL;
|
|
|
|
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;
|
|
}
|
|
|
|
sb_reset (&f->actual);
|
|
idx = get_any_string (idx, in, &f->actual, 1, 0);
|
|
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 (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));
|
|
sb_reset (&ptr->actual);
|
|
sprintf (buffer, "%d", narg);
|
|
sb_add_string (&ptr->actual, buffer);
|
|
}
|
|
|
|
err = macro_expand_body (&m->sub, out, m->formals, m->formal_hash, 1);
|
|
if (err != NULL)
|
|
return err;
|
|
|
|
/* 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
|
|
{
|
|
sb_kill (&(*pf)->name);
|
|
sb_kill (&(*pf)->def);
|
|
sb_kill (&(*pf)->actual);
|
|
f = (*pf)->next;
|
|
free (*pf);
|
|
*pf = f;
|
|
}
|
|
}
|
|
}
|
|
|
|
sb_kill (&t);
|
|
macro_number++;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Check for a macro. If one is found, put the expansion into
|
|
*EXPAND. Return 1 if a macro is found, 0 otherwise. */
|
|
|
|
int
|
|
check_macro (const char *line, sb *expand,
|
|
const char **error, macro_entry **info)
|
|
{
|
|
const char *s;
|
|
char *copy, *cs;
|
|
macro_entry *macro;
|
|
sb line_sb;
|
|
|
|
if (! ISALPHA (*line)
|
|
&& *line != '_'
|
|
&& *line != '$'
|
|
&& (! macro_mri || *line != '.'))
|
|
return 0;
|
|
|
|
s = line + 1;
|
|
while (ISALNUM (*s)
|
|
|| *s == '_'
|
|
|| *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);
|
|
|
|
macro = (macro_entry *) hash_find (macro_hash, copy);
|
|
|
|
if (macro == NULL)
|
|
return 0;
|
|
|
|
/* Wrap the line up in an sb. */
|
|
sb_new (&line_sb);
|
|
while (*s != '\0' && *s != '\n' && *s != '\r')
|
|
sb_add_char (&line_sb, *s++);
|
|
|
|
sb_new (expand);
|
|
*error = macro_expand (0, &line_sb, macro, expand);
|
|
|
|
sb_kill (&line_sb);
|
|
|
|
/* Export the macro information if requested. */
|
|
if (info)
|
|
*info = macro;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* Delete a macro. */
|
|
|
|
void
|
|
delete_macro (const char *name)
|
|
{
|
|
hash_delete (macro_hash, name);
|
|
}
|
|
|
|
/* Handle the MRI IRP and IRPC pseudo-ops. These are handled as a
|
|
combined macro definition and execution. This returns NULL on
|
|
success, or an error message otherwise. */
|
|
|
|
const char *
|
|
expand_irp (int irpc, int idx, sb *in, sb *out, int (*get_line) (sb *))
|
|
{
|
|
const char *mn;
|
|
sb sub;
|
|
formal_entry f;
|
|
struct hash_control *h;
|
|
const char *err;
|
|
|
|
if (irpc)
|
|
mn = "IRPC";
|
|
else
|
|
mn = "IRP";
|
|
|
|
idx = sb_skip_white (idx, in);
|
|
|
|
sb_new (&sub);
|
|
if (! buffer_and_nest (mn, "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;
|
|
|
|
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);
|
|
if (err != NULL)
|
|
return err;
|
|
}
|
|
else
|
|
{
|
|
if (irpc && in->ptr[idx] == '"')
|
|
++idx;
|
|
while (idx < in->len)
|
|
{
|
|
if (!irpc)
|
|
idx = get_any_string (idx, in, &f.actual, 1, 0);
|
|
else
|
|
{
|
|
if (in->ptr[idx] == '"')
|
|
{
|
|
int nxt;
|
|
|
|
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)
|
|
return err;
|
|
if (!irpc)
|
|
idx = sb_skip_comma (idx, in);
|
|
else
|
|
idx = sb_skip_white (idx, in);
|
|
}
|
|
}
|
|
|
|
hash_die (h);
|
|
sb_kill (&sub);
|
|
|
|
return NULL;
|
|
}
|