gas/macro.c

   1 /* macro.c - macro support for gas
   2    Copyright (C) 1994-2014 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_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
 250 static size_t
 251 get_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
 276 static size_t
 277 getstring (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
 362 static size_t
 363 get_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 = (char *) xmalloc (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 = (char *) xmalloc (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
 469 static formal_entry *
 470 new_formal (void)
 471 {
 472   formal_entry *formal;
 473
 474   formal = (formal_entry *) xmalloc (sizeof (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
 486 static void
 487 del_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
 497 static size_t
 498 do_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
 626 static void
 627 free_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
 648 const char *
 649 define_macro (size_t idx, sb *in, sb *label,
 650               size_t (*get_line) (sb *),
 651               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 = (macro_entry *) xmalloc (sizeof (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
 729 static size_t
 730 get_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
 743 static size_t
 744 sub_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
 792 static const char *
 793 macro_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[10];
 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
1025 static const char *
1026 macro_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
1234 int
1235 check_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 = (char *) alloca (s - line + 1);
1254   memcpy (copy, line, s - line);
1255   copy[s - line] = '\0';
1256   for (cls = copy; *cls != '\0'; cls ++)
1257     *cls = TOLOWER (*cls);
1258
1259   macro = (macro_entry *) hash_find (macro_hash, copy);
1260
1261   if (macro == NULL)
1262     return 0;
1263
1264   /* Wrap the line up in an sb.  */
1265   sb_new (&line_sb);
1266   while (*s != '\0' && *s != '\n' && *s != '\r')
1267     sb_add_char (&line_sb, *s++);
1268
1269   sb_new (expand);
1270   *error = macro_expand (0, &line_sb, macro, expand);
1271
1272   sb_kill (&line_sb);
1273
1274   /* Export the macro information if requested.  */
1275   if (info)
1276     *info = macro;
1277
1278   return 1;
1279 }
1280
1281 /* Delete a macro.  */
1282
1283 void
1284 delete_macro (const char *name)
1285 {
1286   char *copy;
1287   size_t i, len;
1288   macro_entry *macro;
1289
1290   len = strlen (name);
1291   copy = (char *) alloca (len + 1);
1292   for (i = 0; i < len; ++i)
1293     copy[i] = TOLOWER (name[i]);
1294   copy[i] = '\0';
1295
1296   /* We can only ask hash_delete to free memory if we are deleting
1297      macros in reverse order to their definition.
1298      So just clear out the entry.  */
1299   if ((macro = (macro_entry *) hash_find (macro_hash, copy)) != NULL)
1300     {
1301       hash_jam (macro_hash, copy, NULL);
1302       free_macro (macro);
1303     }
1304   else
1305     as_warn (_("Attempt to purge non-existant macro `%s'"), 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
1312 const char *
1313 expand_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 }