1/* macro.c - macro support for gas
2   Copyright (C) 1994-2017 Free Software Foundation, Inc.
3
4   Written by Steve and Judy Chamberlain of Cygnus Support,
5      sac@cygnus.com
6
7   This file is part of GAS, the GNU Assembler.
8
9   GAS is free software; you can redistribute it and/or modify
10   it under the terms of the GNU General Public License as published by
11   the Free Software Foundation; either version 3, or (at your option)
12   any later version.
13
14   GAS is distributed in the hope that it will be useful,
15   but WITHOUT ANY WARRANTY; without even the implied warranty of
16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17   GNU General Public License for more details.
18
19   You should have received a copy of the GNU General Public License
20   along with GAS; see the file COPYING.  If not, write to the Free
21   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22   02110-1301, USA.  */
23
24#include "as.h"
25#include "safe-ctype.h"
26#include "sb.h"
27#include "macro.h"
28
29/* The routines in this file handle macro definition and expansion.
30   They are called by gas.  */
31
32#define ISWHITE(x) ((x) == ' ' || (x) == '\t')
33
34#define ISSEP(x) \
35 ((x) == ' ' || (x) == '\t' || (x) == ',' || (x) == '"' || (x) == ';' \
36  || (x) == ')' || (x) == '(' \
37  || ((macro_alternate || macro_mri) && ((x) == '<' || (x) == '>')))
38
39#define ISBASE(x) \
40  ((x) == 'b' || (x) == 'B' \
41   || (x) == 'q' || (x) == 'Q' \
42   || (x) == 'h' || (x) == 'H' \
43   || (x) == 'd' || (x) == 'D')
44
45/* The macro hash table.  */
46
47struct hash_control *macro_hash;
48
49/* Whether any macros have been defined.  */
50
51int macro_defined;
52
53/* Whether we are in alternate syntax mode.  */
54
55static int macro_alternate;
56
57/* Whether we are in MRI mode.  */
58
59static int macro_mri;
60
61/* Whether we should strip '@' characters.  */
62
63static int macro_strip_at;
64
65/* Function to use to parse an expression.  */
66
67static size_t (*macro_expr) (const char *, size_t, sb *, offsetT *);
68
69/* Number of macro expansions that have been done.  */
70
71static int macro_number;
72
73/* Initialize macro processing.  */
74
75void
76macro_init (int alternate, int mri, int strip_at,
77	    size_t (*exp) (const char *, size_t, sb *, offsetT *))
78{
79  macro_hash = hash_new ();
80  macro_defined = 0;
81  macro_alternate = alternate;
82  macro_mri = mri;
83  macro_strip_at = strip_at;
84  macro_expr = exp;
85}
86
87/* Switch in and out of alternate mode on the fly.  */
88
89void
90macro_set_alternate (int alternate)
91{
92  macro_alternate = alternate;
93}
94
95/* Switch in and out of MRI mode on the fly.  */
96
97void
98macro_mri_mode (int mri)
99{
100  macro_mri = mri;
101}
102
103/* Read input lines till we get to a TO string.
104   Increase nesting depth if we get a FROM string.
105   Put the results into sb at PTR.
106   FROM may be NULL (or will be ignored) if TO is "ENDR".
107   Add a new input line to an sb using GET_LINE.
108   Return 1 on success, 0 on unexpected EOF.  */
109
110int
111buffer_and_nest (const char *from, const char *to, sb *ptr,
112		 size_t (*get_line) (sb *))
113{
114  size_t from_len;
115  size_t to_len = strlen (to);
116  int depth = 1;
117  size_t line_start = ptr->len;
118  size_t more = get_line (ptr);
119
120  if (to_len == 4 && strcasecmp (to, "ENDR") == 0)
121    {
122      from = NULL;
123      from_len = 0;
124    }
125  else
126    from_len = strlen (from);
127
128  while (more)
129    {
130      /* Try to find the first pseudo op on the line.  */
131      size_t i = line_start;
132      bfd_boolean had_colon = FALSE;
133
134      /* With normal syntax we can suck what we want till we get
135	 to the dot.  With the alternate, labels have to start in
136	 the first column, since we can't tell what's a label and
137	 what's a pseudoop.  */
138
139      if (! LABELS_WITHOUT_COLONS)
140	{
141	  /* Skip leading whitespace.  */
142	  while (i < ptr->len && ISWHITE (ptr->ptr[i]))
143	    i++;
144	}
145
146      for (;;)
147	{
148	  /* Skip over a label, if any.  */
149	  if (i >= ptr->len || ! is_name_beginner (ptr->ptr[i]))
150	    break;
151	  i++;
152	  while (i < ptr->len && is_part_of_name (ptr->ptr[i]))
153	    i++;
154	  if (i < ptr->len && is_name_ender (ptr->ptr[i]))
155	    i++;
156	  /* Skip whitespace.  */
157	  while (i < ptr->len && ISWHITE (ptr->ptr[i]))
158	    i++;
159	  /* Check for the colon.  */
160	  if (i >= ptr->len || ptr->ptr[i] != ':')
161	    {
162	      /* LABELS_WITHOUT_COLONS doesn't mean we cannot have a
163		 colon after a label.  If we do have a colon on the
164		 first label then handle more than one label on the
165		 line, assuming that each label has a colon.  */
166	      if (LABELS_WITHOUT_COLONS && !had_colon)
167		break;
168	      i = line_start;
169	      break;
170	    }
171	  i++;
172	  line_start = i;
173	  had_colon = TRUE;
174	}
175
176      /* Skip trailing whitespace.  */
177      while (i < ptr->len && ISWHITE (ptr->ptr[i]))
178	i++;
179
180      if (i < ptr->len && (ptr->ptr[i] == '.'
181			   || NO_PSEUDO_DOT
182			   || macro_mri))
183	{
184	  if (! flag_m68k_mri && ptr->ptr[i] == '.')
185	    i++;
186	  if (from == NULL
187	     && strncasecmp (ptr->ptr + i, "IRPC", from_len = 4) != 0
188	     && strncasecmp (ptr->ptr + i, "IRP", from_len = 3) != 0
189	     && strncasecmp (ptr->ptr + i, "IREPC", from_len = 5) != 0
190	     && strncasecmp (ptr->ptr + i, "IREP", from_len = 4) != 0
191	     && strncasecmp (ptr->ptr + i, "REPT", from_len = 4) != 0
192	     && strncasecmp (ptr->ptr + i, "REP", from_len = 3) != 0)
193	    from_len = 0;
194	  if ((from != NULL
195	       ? strncasecmp (ptr->ptr + i, from, from_len) == 0
196	       : from_len > 0)
197	      && (ptr->len == (i + from_len)
198		  || ! (is_part_of_name (ptr->ptr[i + from_len])
199			|| is_name_ender (ptr->ptr[i + from_len]))))
200	    depth++;
201	  if (strncasecmp (ptr->ptr + i, to, to_len) == 0
202	      && (ptr->len == (i + to_len)
203		  || ! (is_part_of_name (ptr->ptr[i + to_len])
204			|| is_name_ender (ptr->ptr[i + to_len]))))
205	    {
206	      depth--;
207	      if (depth == 0)
208		{
209		  /* Reset the string to not include the ending rune.  */
210		  ptr->len = line_start;
211		  break;
212		}
213	    }
214
215	  /* PR gas/16908
216	     Apply and discard .linefile directives that appear within
217	     the macro.  For long macros, one might want to report the
218	     line number information associated with the lines within
219	     the macro definition, but we would need more infrastructure
220	     to make that happen correctly (e.g. resetting the line
221	     number when expanding the macro), and since for short
222	     macros we clearly prefer reporting the point of expansion
223	     anyway, there's not an obviously better fix here.  */
224	  if (strncasecmp (ptr->ptr + i, "linefile", 8) == 0)
225	    {
226	      char *saved_input_line_pointer = input_line_pointer;
227	      char saved_eol_char = ptr->ptr[ptr->len];
228
229	      ptr->ptr[ptr->len] = '\0';
230	      input_line_pointer = ptr->ptr + i + 8;
231	      s_app_line (0);
232	      ptr->ptr[ptr->len] = saved_eol_char;
233	      input_line_pointer = saved_input_line_pointer;
234	      ptr->len = line_start;
235	    }
236	}
237
238      /* Add the original end-of-line char to the end and keep running.  */
239      sb_add_char (ptr, more);
240      line_start = ptr->len;
241      more = get_line (ptr);
242    }
243
244  /* Return 1 on success, 0 on unexpected EOF.  */
245  return depth == 0;
246}
247
248/* Pick up a token.  */
249
250static size_t
251get_token (size_t idx, sb *in, sb *name)
252{
253  if (idx < in->len
254      && is_name_beginner (in->ptr[idx]))
255    {
256      sb_add_char (name, in->ptr[idx++]);
257      while (idx < in->len
258	     && is_part_of_name (in->ptr[idx]))
259	{
260	  sb_add_char (name, in->ptr[idx++]);
261	}
262      if (idx < in->len
263	     && is_name_ender (in->ptr[idx]))
264	{
265	  sb_add_char (name, in->ptr[idx++]);
266	}
267    }
268  /* Ignore trailing &.  */
269  if (macro_alternate && idx < in->len && in->ptr[idx] == '&')
270    idx++;
271  return idx;
272}
273
274/* Pick up a string.  */
275
276static size_t
277getstring (size_t idx, sb *in, sb *acc)
278{
279  while (idx < in->len
280	 && (in->ptr[idx] == '"'
281	     || (in->ptr[idx] == '<' && (macro_alternate || macro_mri))
282	     || (in->ptr[idx] == '\'' && macro_alternate)))
283    {
284      if (in->ptr[idx] == '<')
285	{
286	  int nest = 0;
287	  idx++;
288	  while ((in->ptr[idx] != '>' || nest)
289		 && idx < in->len)
290	    {
291	      if (in->ptr[idx] == '!')
292		{
293		  idx++;
294		  sb_add_char (acc, in->ptr[idx++]);
295		}
296	      else
297		{
298		  if (in->ptr[idx] == '>')
299		    nest--;
300		  if (in->ptr[idx] == '<')
301		    nest++;
302		  sb_add_char (acc, in->ptr[idx++]);
303		}
304	    }
305	  idx++;
306	}
307      else if (in->ptr[idx] == '"' || in->ptr[idx] == '\'')
308	{
309	  char tchar = in->ptr[idx];
310	  int escaped = 0;
311
312	  idx++;
313
314	  while (idx < in->len)
315	    {
316	      if (in->ptr[idx - 1] == '\\')
317		escaped ^= 1;
318	      else
319		escaped = 0;
320
321	      if (macro_alternate && in->ptr[idx] == '!')
322		{
323		  idx ++;
324
325		  sb_add_char (acc, in->ptr[idx]);
326
327		  idx ++;
328		}
329	      else if (escaped && in->ptr[idx] == tchar)
330		{
331		  sb_add_char (acc, tchar);
332		  idx ++;
333		}
334	      else
335		{
336		  if (in->ptr[idx] == tchar)
337		    {
338		      idx ++;
339
340		      if (idx >= in->len || in->ptr[idx] != tchar)
341			break;
342		    }
343
344		  sb_add_char (acc, in->ptr[idx]);
345		  idx ++;
346		}
347	    }
348	}
349    }
350
351  return idx;
352}
353
354/* Fetch string from the input stream,
355   rules:
356    'Bxyx<whitespace>  	-> return 'Bxyza
357    %<expr>		-> return string of decimal value of <expr>
358    "string"		-> return string
359    (string)		-> return (string-including-whitespaces)
360    xyx<whitespace>     -> return xyz.  */
361
362static size_t
363get_any_string (size_t idx, sb *in, sb *out)
364{
365  sb_reset (out);
366  idx = sb_skip_white (idx, in);
367
368  if (idx < in->len)
369    {
370      if (in->len > idx + 2 && in->ptr[idx + 1] == '\'' && ISBASE (in->ptr[idx]))
371	{
372	  while (!ISSEP (in->ptr[idx]))
373	    sb_add_char (out, in->ptr[idx++]);
374	}
375      else if (in->ptr[idx] == '%' && macro_alternate)
376	{
377	  offsetT val;
378	  char buf[20];
379
380	  /* Turns the next expression into a string.  */
381	  /* xgettext: no-c-format */
382	  idx = (*macro_expr) (_("% operator needs absolute expression"),
383			       idx + 1,
384			       in,
385			       &val);
386	  sprintf (buf, "%" BFD_VMA_FMT "d", val);
387	  sb_add_string (out, buf);
388	}
389      else if (in->ptr[idx] == '"'
390	       || (in->ptr[idx] == '<' && (macro_alternate || macro_mri))
391	       || (macro_alternate && in->ptr[idx] == '\''))
392	{
393	  if (macro_alternate && ! macro_strip_at && in->ptr[idx] != '<')
394	    {
395	      /* Keep the quotes.  */
396	      sb_add_char (out, '"');
397	      idx = getstring (idx, in, out);
398	      sb_add_char (out, '"');
399	    }
400	  else
401	    {
402	      idx = getstring (idx, in, out);
403	    }
404	}
405      else
406	{
407	  char *br_buf = XNEWVEC (char, 1);
408	  char *in_br = br_buf;
409
410	  *in_br = '\0';
411	  while (idx < in->len
412		 && (*in_br
413		     || (in->ptr[idx] != ' '
414			 && in->ptr[idx] != '\t'))
415		 && in->ptr[idx] != ','
416		 && (in->ptr[idx] != '<'
417		     || (! macro_alternate && ! macro_mri)))
418	    {
419	      char tchar = in->ptr[idx];
420
421	      switch (tchar)
422		{
423		case '"':
424		case '\'':
425		  sb_add_char (out, in->ptr[idx++]);
426		  while (idx < in->len
427			 && in->ptr[idx] != tchar)
428		    sb_add_char (out, in->ptr[idx++]);
429		  if (idx == in->len)
430		    {
431		      free (br_buf);
432		      return idx;
433		    }
434		  break;
435		case '(':
436		case '[':
437		  if (in_br > br_buf)
438		    --in_br;
439		  else
440		    {
441		      br_buf = XNEWVEC (char, strlen (in_br) + 2);
442		      strcpy (br_buf + 1, in_br);
443		      free (in_br);
444		      in_br = br_buf;
445		    }
446		  *in_br = tchar;
447		  break;
448		case ')':
449		  if (*in_br == '(')
450		    ++in_br;
451		  break;
452		case ']':
453		  if (*in_br == '[')
454		    ++in_br;
455		  break;
456		}
457	      sb_add_char (out, tchar);
458	      ++idx;
459	    }
460	  free (br_buf);
461	}
462    }
463
464  return idx;
465}
466
467/* Allocate a new formal.  */
468
469static formal_entry *
470new_formal (void)
471{
472  formal_entry *formal;
473
474  formal = XNEW (formal_entry);
475
476  sb_new (&formal->name);
477  sb_new (&formal->def);
478  sb_new (&formal->actual);
479  formal->next = NULL;
480  formal->type = FORMAL_OPTIONAL;
481  return formal;
482}
483
484/* Free a formal.  */
485
486static void
487del_formal (formal_entry *formal)
488{
489  sb_kill (&formal->actual);
490  sb_kill (&formal->def);
491  sb_kill (&formal->name);
492  free (formal);
493}
494
495/* Pick up the formal parameters of a macro definition.  */
496
497static size_t
498do_formals (macro_entry *macro, size_t idx, sb *in)
499{
500  formal_entry **p = &macro->formals;
501  const char *name;
502
503  idx = sb_skip_white (idx, in);
504  while (idx < in->len)
505    {
506      formal_entry *formal = new_formal ();
507      size_t cidx;
508
509      idx = get_token (idx, in, &formal->name);
510      if (formal->name.len == 0)
511	{
512	  if (macro->formal_count)
513	    --idx;
514	  del_formal (formal);	/* 'formal' goes out of scope.  */
515	  break;
516	}
517      idx = sb_skip_white (idx, in);
518      /* This is a formal.  */
519      name = sb_terminate (&formal->name);
520      if (! macro_mri
521	  && idx < in->len
522	  && in->ptr[idx] == ':'
523	  && (! is_name_beginner (':')
524	      || idx + 1 >= in->len
525	      || ! is_part_of_name (in->ptr[idx + 1])))
526	{
527	  /* Got a qualifier.  */
528	  sb qual;
529
530	  sb_new (&qual);
531	  idx = get_token (sb_skip_white (idx + 1, in), in, &qual);
532	  sb_terminate (&qual);
533	  if (qual.len == 0)
534	    as_bad_where (macro->file,
535			  macro->line,
536			  _("Missing parameter qualifier for `%s' in macro `%s'"),
537			  name,
538			  macro->name);
539	  else if (strcmp (qual.ptr, "req") == 0)
540	    formal->type = FORMAL_REQUIRED;
541	  else if (strcmp (qual.ptr, "vararg") == 0)
542	    formal->type = FORMAL_VARARG;
543	  else
544	    as_bad_where (macro->file,
545			  macro->line,
546			  _("`%s' is not a valid parameter qualifier for `%s' in macro `%s'"),
547			  qual.ptr,
548			  name,
549			  macro->name);
550	  sb_kill (&qual);
551	  idx = sb_skip_white (idx, in);
552	}
553      if (idx < in->len && in->ptr[idx] == '=')
554	{
555	  /* Got a default.  */
556	  idx = get_any_string (idx + 1, in, &formal->def);
557	  idx = sb_skip_white (idx, in);
558	  if (formal->type == FORMAL_REQUIRED)
559	    {
560	      sb_reset (&formal->def);
561	      as_warn_where (macro->file,
562			    macro->line,
563			    _("Pointless default value for required parameter `%s' in macro `%s'"),
564			    name,
565			    macro->name);
566	    }
567	}
568
569      /* Add to macro's hash table.  */
570      if (! hash_find (macro->formal_hash, name))
571	hash_jam (macro->formal_hash, name, formal);
572      else
573	as_bad_where (macro->file,
574		      macro->line,
575		      _("A parameter named `%s' already exists for macro `%s'"),
576		      name,
577		      macro->name);
578
579      formal->index = macro->formal_count++;
580      *p = formal;
581      p = &formal->next;
582      if (formal->type == FORMAL_VARARG)
583	break;
584      cidx = idx;
585      idx = sb_skip_comma (idx, in);
586      if (idx != cidx && idx >= in->len)
587	{
588	  idx = cidx;
589	  break;
590	}
591    }
592
593  if (macro_mri)
594    {
595      formal_entry *formal = new_formal ();
596
597      /* Add a special NARG formal, which macro_expand will set to the
598	 number of arguments.  */
599      /* The same MRI assemblers which treat '@' characters also use
600	 the name $NARG.  At least until we find an exception.  */
601      if (macro_strip_at)
602	name = "$NARG";
603      else
604	name = "NARG";
605
606      sb_add_string (&formal->name, name);
607
608      /* Add to macro's hash table.  */
609      if (hash_find (macro->formal_hash, name))
610	as_bad_where (macro->file,
611		      macro->line,
612		      _("Reserved word `%s' used as parameter in macro `%s'"),
613		      name,
614		      macro->name);
615      hash_jam (macro->formal_hash, name, formal);
616
617      formal->index = NARG_INDEX;
618      *p = formal;
619    }
620
621  return idx;
622}
623
624/* Free the memory allocated to a macro.  */
625
626static void
627free_macro (macro_entry *macro)
628{
629  formal_entry *formal;
630
631  for (formal = macro->formals; formal; )
632    {
633      formal_entry *f;
634
635      f = formal;
636      formal = formal->next;
637      del_formal (f);
638    }
639  hash_die (macro->formal_hash);
640  sb_kill (&macro->sub);
641  free (macro);
642}
643
644/* Define a new macro.  Returns NULL on success, otherwise returns an
645   error message.  If NAMEP is not NULL, *NAMEP is set to the name of
646   the macro which was defined.  */
647
648const char *
649define_macro (size_t idx, sb *in, sb *label,
650	      size_t (*get_line) (sb *),
651	      const char *file, unsigned int line,
652	      const char **namep)
653{
654  macro_entry *macro;
655  sb name;
656  const char *error = NULL;
657
658  macro = XNEW (macro_entry);
659  sb_new (&macro->sub);
660  sb_new (&name);
661  macro->file = file;
662  macro->line = line;
663
664  macro->formal_count = 0;
665  macro->formals = 0;
666  macro->formal_hash = hash_new_sized (7);
667
668  idx = sb_skip_white (idx, in);
669  if (! buffer_and_nest ("MACRO", "ENDM", &macro->sub, get_line))
670    error = _("unexpected end of file in macro `%s' definition");
671  if (label != NULL && label->len != 0)
672    {
673      sb_add_sb (&name, label);
674      macro->name = sb_terminate (&name);
675      if (idx < in->len && in->ptr[idx] == '(')
676	{
677	  /* It's the label: MACRO (formals,...)  sort  */
678	  idx = do_formals (macro, idx + 1, in);
679	  if (idx < in->len && in->ptr[idx] == ')')
680	    idx = sb_skip_white (idx + 1, in);
681	  else if (!error)
682	    error = _("missing `)' after formals in macro definition `%s'");
683	}
684      else
685	{
686	  /* It's the label: MACRO formals,...  sort  */
687	  idx = do_formals (macro, idx, in);
688	}
689    }
690  else
691    {
692      size_t cidx;
693
694      idx = get_token (idx, in, &name);
695      macro->name = sb_terminate (&name);
696      if (name.len == 0)
697	error = _("Missing macro name");
698      cidx = sb_skip_white (idx, in);
699      idx = sb_skip_comma (cidx, in);
700      if (idx == cidx || idx < in->len)
701	idx = do_formals (macro, idx, in);
702      else
703	idx = cidx;
704    }
705  if (!error && idx < in->len)
706    error = _("Bad parameter list for macro `%s'");
707
708  /* And stick it in the macro hash table.  */
709  for (idx = 0; idx < name.len; idx++)
710    name.ptr[idx] = TOLOWER (name.ptr[idx]);
711  if (hash_find (macro_hash, macro->name))
712    error = _("Macro `%s' was already defined");
713  if (!error)
714    error = hash_jam (macro_hash, macro->name, (void *) macro);
715
716  if (namep != NULL)
717    *namep = macro->name;
718
719  if (!error)
720    macro_defined = 1;
721  else
722    free_macro (macro);
723
724  return error;
725}
726
727/* Scan a token, and then skip KIND.  */
728
729static size_t
730get_apost_token (size_t idx, sb *in, sb *name, int kind)
731{
732  idx = get_token (idx, in, name);
733  if (idx < in->len
734      && in->ptr[idx] == kind
735      && (! macro_mri || macro_strip_at)
736      && (! macro_strip_at || kind == '@'))
737    idx++;
738  return idx;
739}
740
741/* Substitute the actual value for a formal parameter.  */
742
743static size_t
744sub_actual (size_t start, sb *in, sb *t, struct hash_control *formal_hash,
745	    int kind, sb *out, int copyifnotthere)
746{
747  size_t src;
748  formal_entry *ptr;
749
750  src = get_apost_token (start, in, t, kind);
751  /* See if it's in the macro's hash table, unless this is
752     macro_strip_at and kind is '@' and the token did not end in '@'.  */
753  if (macro_strip_at
754      && kind == '@'
755      && (src == start || in->ptr[src - 1] != '@'))
756    ptr = NULL;
757  else
758    ptr = (formal_entry *) hash_find (formal_hash, sb_terminate (t));
759  if (ptr)
760    {
761      if (ptr->actual.len)
762	{
763	  sb_add_sb (out, &ptr->actual);
764	}
765      else
766	{
767	  sb_add_sb (out, &ptr->def);
768	}
769    }
770  else if (kind == '&')
771    {
772      /* Doing this permits people to use & in macro bodies.  */
773      sb_add_char (out, '&');
774      sb_add_sb (out, t);
775      if (src != start && in->ptr[src - 1] == '&')
776	sb_add_char (out, '&');
777    }
778  else if (copyifnotthere)
779    {
780      sb_add_sb (out, t);
781    }
782  else
783    {
784      sb_add_char (out, '\\');
785      sb_add_sb (out, t);
786    }
787  return src;
788}
789
790/* Expand the body of a macro.  */
791
792static const char *
793macro_expand_body (sb *in, sb *out, formal_entry *formals,
794		   struct hash_control *formal_hash, const macro_entry *macro)
795{
796  sb t;
797  size_t src = 0;
798  int inquote = 0, macro_line = 0;
799  formal_entry *loclist = NULL;
800  const char *err = NULL;
801
802  sb_new (&t);
803
804  while (src < in->len && !err)
805    {
806      if (in->ptr[src] == '&')
807	{
808	  sb_reset (&t);
809	  if (macro_mri)
810	    {
811	      if (src + 1 < in->len && in->ptr[src + 1] == '&')
812		src = sub_actual (src + 2, in, &t, formal_hash, '\'', out, 1);
813	      else
814		sb_add_char (out, in->ptr[src++]);
815	    }
816	  else
817	    {
818	      /* Permit macro parameter substition delineated with
819		 an '&' prefix and optional '&' suffix.  */
820	      src = sub_actual (src + 1, in, &t, formal_hash, '&', out, 0);
821	    }
822	}
823      else if (in->ptr[src] == '\\')
824	{
825	  src++;
826	  if (src < in->len && in->ptr[src] == '(')
827	    {
828	      /* Sub in till the next ')' literally.  */
829	      src++;
830	      while (src < in->len && in->ptr[src] != ')')
831		{
832		  sb_add_char (out, in->ptr[src++]);
833		}
834	      if (src < in->len)
835		src++;
836	      else if (!macro)
837		err = _("missing `)'");
838	      else
839		as_bad_where (macro->file, macro->line + macro_line, _("missing `)'"));
840	    }
841	  else if (src < in->len && in->ptr[src] == '@')
842	    {
843	      /* Sub in the macro invocation number.  */
844
845	      char buffer[12];
846	      src++;
847	      sprintf (buffer, "%d", macro_number);
848	      sb_add_string (out, buffer);
849	    }
850	  else if (src < in->len && in->ptr[src] == '&')
851	    {
852	      /* This is a preprocessor variable name, we don't do them
853		 here.  */
854	      sb_add_char (out, '\\');
855	      sb_add_char (out, '&');
856	      src++;
857	    }
858	  else if (macro_mri && src < in->len && ISALNUM (in->ptr[src]))
859	    {
860	      int ind;
861	      formal_entry *f;
862
863	      if (ISDIGIT (in->ptr[src]))
864		ind = in->ptr[src] - '0';
865	      else if (ISUPPER (in->ptr[src]))
866		ind = in->ptr[src] - 'A' + 10;
867	      else
868		ind = in->ptr[src] - 'a' + 10;
869	      ++src;
870	      for (f = formals; f != NULL; f = f->next)
871		{
872		  if (f->index == ind - 1)
873		    {
874		      if (f->actual.len != 0)
875			sb_add_sb (out, &f->actual);
876		      else
877			sb_add_sb (out, &f->def);
878		      break;
879		    }
880		}
881	    }
882	  else
883	    {
884	      sb_reset (&t);
885	      src = sub_actual (src, in, &t, formal_hash, '\'', out, 0);
886	    }
887	}
888      else if ((macro_alternate || macro_mri)
889	       && is_name_beginner (in->ptr[src])
890	       && (! inquote
891		   || ! macro_strip_at
892		   || (src > 0 && in->ptr[src - 1] == '@')))
893	{
894	  if (! macro
895	      || src + 5 >= in->len
896	      || strncasecmp (in->ptr + src, "LOCAL", 5) != 0
897	      || ! ISWHITE (in->ptr[src + 5])
898	      /* PR 11507: Skip keyword LOCAL if it is found inside a quoted string.  */
899	      || inquote)
900	    {
901	      sb_reset (&t);
902	      src = sub_actual (src, in, &t, formal_hash,
903				(macro_strip_at && inquote) ? '@' : '\'',
904				out, 1);
905	    }
906	  else
907	    {
908	      src = sb_skip_white (src + 5, in);
909	      while (in->ptr[src] != '\n')
910		{
911		  const char *name;
912		  formal_entry *f = new_formal ();
913
914		  src = get_token (src, in, &f->name);
915		  name = sb_terminate (&f->name);
916		  if (! hash_find (formal_hash, name))
917		    {
918		      static int loccnt;
919		      char buf[20];
920
921		      f->index = LOCAL_INDEX;
922		      f->next = loclist;
923		      loclist = f;
924
925		      sprintf (buf, IS_ELF ? ".LL%04x" : "LL%04x", ++loccnt);
926		      sb_add_string (&f->actual, buf);
927
928		      err = hash_jam (formal_hash, name, f);
929		      if (err != NULL)
930			break;
931		    }
932		  else
933		    {
934		      as_bad_where (macro->file,
935				    macro->line + macro_line,
936				    _("`%s' was already used as parameter (or another local) name"),
937				    name);
938		      del_formal (f);
939		    }
940
941		  src = sb_skip_comma (src, in);
942		}
943	    }
944	}
945      else if (in->ptr[src] == '"'
946	       || (macro_mri && in->ptr[src] == '\''))
947	{
948	  inquote = !inquote;
949	  sb_add_char (out, in->ptr[src++]);
950	}
951      else if (in->ptr[src] == '@' && macro_strip_at)
952	{
953	  ++src;
954	  if (src < in->len
955	      && in->ptr[src] == '@')
956	    {
957	      sb_add_char (out, '@');
958	      ++src;
959	    }
960	}
961      else if (macro_mri
962	       && in->ptr[src] == '='
963	       && src + 1 < in->len
964	       && in->ptr[src + 1] == '=')
965	{
966	  formal_entry *ptr;
967
968	  sb_reset (&t);
969	  src = get_token (src + 2, in, &t);
970	  ptr = (formal_entry *) hash_find (formal_hash, sb_terminate (&t));
971	  if (ptr == NULL)
972	    {
973	      /* FIXME: We should really return a warning string here,
974		 but we can't, because the == might be in the MRI
975		 comment field, and, since the nature of the MRI
976		 comment field depends upon the exact instruction
977		 being used, we don't have enough information here to
978		 figure out whether it is or not.  Instead, we leave
979		 the == in place, which should cause a syntax error if
980		 it is not in a comment.  */
981	      sb_add_char (out, '=');
982	      sb_add_char (out, '=');
983	      sb_add_sb (out, &t);
984	    }
985	  else
986	    {
987	      if (ptr->actual.len)
988		{
989		  sb_add_string (out, "-1");
990		}
991	      else
992		{
993		  sb_add_char (out, '0');
994		}
995	    }
996	}
997      else
998	{
999	  if (in->ptr[src] == '\n')
1000	    ++macro_line;
1001	  sb_add_char (out, in->ptr[src++]);
1002	}
1003    }
1004
1005  sb_kill (&t);
1006
1007  while (loclist != NULL)
1008    {
1009      formal_entry *f;
1010      const char *name;
1011
1012      f = loclist->next;
1013      name = sb_terminate (&loclist->name);
1014      hash_delete (formal_hash, name, f == NULL);
1015      del_formal (loclist);
1016      loclist = f;
1017    }
1018
1019  return err;
1020}
1021
1022/* Assign values to the formal parameters of a macro, and expand the
1023   body.  */
1024
1025static const char *
1026macro_expand (size_t idx, sb *in, macro_entry *m, sb *out)
1027{
1028  sb t;
1029  formal_entry *ptr;
1030  formal_entry *f;
1031  int is_keyword = 0;
1032  int narg = 0;
1033  const char *err = NULL;
1034
1035  sb_new (&t);
1036
1037  /* Reset any old value the actuals may have.  */
1038  for (f = m->formals; f; f = f->next)
1039    sb_reset (&f->actual);
1040  f = m->formals;
1041  while (f != NULL && f->index < 0)
1042    f = f->next;
1043
1044  if (macro_mri)
1045    {
1046      /* The macro may be called with an optional qualifier, which may
1047	 be referred to in the macro body as \0.  */
1048      if (idx < in->len && in->ptr[idx] == '.')
1049	{
1050	  /* The Microtec assembler ignores this if followed by a white space.
1051	     (Macro invocation with empty extension) */
1052	  idx++;
1053	  if (    idx < in->len
1054		  && in->ptr[idx] != ' '
1055		  && in->ptr[idx] != '\t')
1056	    {
1057	      formal_entry *n = new_formal ();
1058
1059	      n->index = QUAL_INDEX;
1060
1061	      n->next = m->formals;
1062	      m->formals = n;
1063
1064	      idx = get_any_string (idx, in, &n->actual);
1065	    }
1066	}
1067    }
1068
1069  /* Peel off the actuals and store them away in the hash tables' actuals.  */
1070  idx = sb_skip_white (idx, in);
1071  while (idx < in->len)
1072    {
1073      size_t scan;
1074
1075      /* Look and see if it's a positional or keyword arg.  */
1076      scan = idx;
1077      while (scan < in->len
1078	     && !ISSEP (in->ptr[scan])
1079	     && !(macro_mri && in->ptr[scan] == '\'')
1080	     && (!macro_alternate && in->ptr[scan] != '='))
1081	scan++;
1082      if (scan < in->len && !macro_alternate && in->ptr[scan] == '=')
1083	{
1084	  is_keyword = 1;
1085
1086	  /* It's OK to go from positional to keyword.  */
1087
1088	  /* This is a keyword arg, fetch the formal name and
1089	     then the actual stuff.  */
1090	  sb_reset (&t);
1091	  idx = get_token (idx, in, &t);
1092	  if (in->ptr[idx] != '=')
1093	    {
1094	      err = _("confusion in formal parameters");
1095	      break;
1096	    }
1097
1098	  /* Lookup the formal in the macro's list.  */
1099	  ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t));
1100	  if (!ptr)
1101	    {
1102	      as_bad (_("Parameter named `%s' does not exist for macro `%s'"),
1103		      t.ptr,
1104		      m->name);
1105	      sb_reset (&t);
1106	      idx = get_any_string (idx + 1, in, &t);
1107	    }
1108	  else
1109	    {
1110	      /* Insert this value into the right place.  */
1111	      if (ptr->actual.len)
1112		{
1113		  as_warn (_("Value for parameter `%s' of macro `%s' was already specified"),
1114			   ptr->name.ptr,
1115			   m->name);
1116		  sb_reset (&ptr->actual);
1117		}
1118	      idx = get_any_string (idx + 1, in, &ptr->actual);
1119	      if (ptr->actual.len > 0)
1120		++narg;
1121	    }
1122	}
1123      else
1124	{
1125	  if (is_keyword)
1126	    {
1127	      err = _("can't mix positional and keyword arguments");
1128	      break;
1129	    }
1130
1131	  if (!f)
1132	    {
1133	      formal_entry **pf;
1134	      int c;
1135
1136	      if (!macro_mri)
1137		{
1138		  err = _("too many positional arguments");
1139		  break;
1140		}
1141
1142	      f = new_formal ();
1143
1144	      c = -1;
1145	      for (pf = &m->formals; *pf != NULL; pf = &(*pf)->next)
1146		if ((*pf)->index >= c)
1147		  c = (*pf)->index + 1;
1148	      if (c == -1)
1149		c = 0;
1150	      *pf = f;
1151	      f->index = c;
1152	    }
1153
1154	  if (f->type != FORMAL_VARARG)
1155	    idx = get_any_string (idx, in, &f->actual);
1156	  else
1157	    {
1158	      sb_add_buffer (&f->actual, in->ptr + idx, in->len - idx);
1159	      idx = in->len;
1160	    }
1161	  if (f->actual.len > 0)
1162	    ++narg;
1163	  do
1164	    {
1165	      f = f->next;
1166	    }
1167	  while (f != NULL && f->index < 0);
1168	}
1169
1170      if (! macro_mri)
1171	idx = sb_skip_comma (idx, in);
1172      else
1173	{
1174	  if (in->ptr[idx] == ',')
1175	    ++idx;
1176	  if (ISWHITE (in->ptr[idx]))
1177	    break;
1178	}
1179    }
1180
1181  if (! err)
1182    {
1183      for (ptr = m->formals; ptr; ptr = ptr->next)
1184	{
1185	  if (ptr->type == FORMAL_REQUIRED && ptr->actual.len == 0)
1186	    as_bad (_("Missing value for required parameter `%s' of macro `%s'"),
1187		    ptr->name.ptr,
1188		    m->name);
1189	}
1190
1191      if (macro_mri)
1192	{
1193	  char buffer[20];
1194
1195	  sb_reset (&t);
1196	  sb_add_string (&t, macro_strip_at ? "$NARG" : "NARG");
1197	  ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t));
1198	  sprintf (buffer, "%d", narg);
1199	  sb_add_string (&ptr->actual, buffer);
1200	}
1201
1202      err = macro_expand_body (&m->sub, out, m->formals, m->formal_hash, m);
1203    }
1204
1205  /* Discard any unnamed formal arguments.  */
1206  if (macro_mri)
1207    {
1208      formal_entry **pf;
1209
1210      pf = &m->formals;
1211      while (*pf != NULL)
1212	{
1213	  if ((*pf)->name.len != 0)
1214	    pf = &(*pf)->next;
1215	  else
1216	    {
1217	      f = (*pf)->next;
1218	      del_formal (*pf);
1219	      *pf = f;
1220	    }
1221	}
1222    }
1223
1224  sb_kill (&t);
1225  if (!err)
1226    macro_number++;
1227
1228  return err;
1229}
1230
1231/* Check for a macro.  If one is found, put the expansion into
1232   *EXPAND.  Return 1 if a macro is found, 0 otherwise.  */
1233
1234int
1235check_macro (const char *line, sb *expand,
1236	     const char **error, macro_entry **info)
1237{
1238  const char *s;
1239  char *copy, *cls;
1240  macro_entry *macro;
1241  sb line_sb;
1242
1243  if (! is_name_beginner (*line)
1244      && (! macro_mri || *line != '.'))
1245    return 0;
1246
1247  s = line + 1;
1248  while (is_part_of_name (*s))
1249    ++s;
1250  if (is_name_ender (*s))
1251    ++s;
1252
1253  copy = xmemdup0 (line, s - line);
1254  for (cls = copy; *cls != '\0'; cls ++)
1255    *cls = TOLOWER (*cls);
1256
1257  macro = (macro_entry *) hash_find (macro_hash, copy);
1258  free (copy);
1259
1260  if (macro == NULL)
1261    return 0;
1262
1263  /* Wrap the line up in an sb.  */
1264  sb_new (&line_sb);
1265  while (*s != '\0' && *s != '\n' && *s != '\r')
1266    sb_add_char (&line_sb, *s++);
1267
1268  sb_new (expand);
1269  *error = macro_expand (0, &line_sb, macro, expand);
1270
1271  sb_kill (&line_sb);
1272
1273  /* Export the macro information if requested.  */
1274  if (info)
1275    *info = macro;
1276
1277  return 1;
1278}
1279
1280/* Delete a macro.  */
1281
1282void
1283delete_macro (const char *name)
1284{
1285  char *copy;
1286  size_t i, len;
1287  macro_entry *macro;
1288
1289  len = strlen (name);
1290  copy = XNEWVEC (char, len + 1);
1291  for (i = 0; i < len; ++i)
1292    copy[i] = TOLOWER (name[i]);
1293  copy[i] = '\0';
1294
1295  /* We can only ask hash_delete to free memory if we are deleting
1296     macros in reverse order to their definition.
1297     So just clear out the entry.  */
1298  if ((macro = (macro_entry *) hash_find (macro_hash, copy)) != NULL)
1299    {
1300      hash_jam (macro_hash, copy, NULL);
1301      free_macro (macro);
1302    }
1303  else
1304    as_warn (_("Attempt to purge non-existant macro `%s'"), copy);
1305  free (copy);
1306}
1307
1308/* Handle the MRI IRP and IRPC pseudo-ops.  These are handled as a
1309   combined macro definition and execution.  This returns NULL on
1310   success, or an error message otherwise.  */
1311
1312const char *
1313expand_irp (int irpc, size_t idx, sb *in, sb *out, size_t (*get_line) (sb *))
1314{
1315  sb sub;
1316  formal_entry f;
1317  struct hash_control *h;
1318  const char *err;
1319
1320  idx = sb_skip_white (idx, in);
1321
1322  sb_new (&sub);
1323  if (! buffer_and_nest (NULL, "ENDR", &sub, get_line))
1324    return _("unexpected end of file in irp or irpc");
1325
1326  sb_new (&f.name);
1327  sb_new (&f.def);
1328  sb_new (&f.actual);
1329
1330  idx = get_token (idx, in, &f.name);
1331  if (f.name.len == 0)
1332    return _("missing model parameter");
1333
1334  h = hash_new ();
1335  err = hash_jam (h, sb_terminate (&f.name), &f);
1336  if (err != NULL)
1337    return err;
1338
1339  f.index = 1;
1340  f.next = NULL;
1341  f.type = FORMAL_OPTIONAL;
1342
1343  sb_reset (out);
1344
1345  idx = sb_skip_comma (idx, in);
1346  if (idx >= in->len)
1347    {
1348      /* Expand once with a null string.  */
1349      err = macro_expand_body (&sub, out, &f, h, 0);
1350    }
1351  else
1352    {
1353      bfd_boolean in_quotes = FALSE;
1354
1355      if (irpc && in->ptr[idx] == '"')
1356	{
1357	  in_quotes = TRUE;
1358	  ++idx;
1359	}
1360
1361      while (idx < in->len)
1362	{
1363	  if (!irpc)
1364	    idx = get_any_string (idx, in, &f.actual);
1365	  else
1366	    {
1367	      if (in->ptr[idx] == '"')
1368		{
1369		  size_t nxt;
1370
1371		  if (irpc)
1372		    in_quotes = ! in_quotes;
1373
1374		  nxt = sb_skip_white (idx + 1, in);
1375		  if (nxt >= in->len)
1376		    {
1377		      idx = nxt;
1378		      break;
1379		    }
1380		}
1381	      sb_reset (&f.actual);
1382	      sb_add_char (&f.actual, in->ptr[idx]);
1383	      ++idx;
1384	    }
1385
1386	  err = macro_expand_body (&sub, out, &f, h, 0);
1387	  if (err != NULL)
1388	    break;
1389	  if (!irpc)
1390	    idx = sb_skip_comma (idx, in);
1391	  else if (! in_quotes)
1392	    idx = sb_skip_white (idx, in);
1393	}
1394    }
1395
1396  hash_die (h);
1397  sb_kill (&f.actual);
1398  sb_kill (&f.def);
1399  sb_kill (&f.name);
1400  sb_kill (&sub);
1401
1402  return err;
1403}
1404