gas/macro.c

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