daily update
[binutils.git] / gas / macro.c
blobe39288355cbb7fbb63997262fad81264feb060be
1 /* macro.c - macro support for gas
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5 Written by Steve and Judy Chamberlain of Cygnus Support,
6 sac@cygnus.com
8 This file is part of GAS, the GNU Assembler.
10 GAS is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
13 any later version.
15 GAS is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GAS; see the file COPYING. If not, write to the Free
22 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 02110-1301, USA. */
25 #include "as.h"
26 #include "safe-ctype.h"
27 #include "sb.h"
28 #include "macro.h"
30 /* The routines in this file handle macro definition and expansion.
31 They are called by gas. */
33 #define ISWHITE(x) ((x) == ' ' || (x) == '\t')
35 #define ISSEP(x) \
36 ((x) == ' ' || (x) == '\t' || (x) == ',' || (x) == '"' || (x) == ';' \
37 || (x) == ')' || (x) == '(' \
38 || ((macro_alternate || macro_mri) && ((x) == '<' || (x) == '>')))
40 #define ISBASE(x) \
41 ((x) == 'b' || (x) == 'B' \
42 || (x) == 'q' || (x) == 'Q' \
43 || (x) == 'h' || (x) == 'H' \
44 || (x) == 'd' || (x) == 'D')
46 /* The macro hash table. */
48 struct hash_control *macro_hash;
50 /* Whether any macros have been defined. */
52 int macro_defined;
54 /* Whether we are in alternate syntax mode. */
56 static int macro_alternate;
58 /* Whether we are in MRI mode. */
60 static int macro_mri;
62 /* Whether we should strip '@' characters. */
64 static int macro_strip_at;
66 /* Function to use to parse an expression. */
68 static int (*macro_expr) (const char *, int, sb *, int *);
70 /* Number of macro expansions that have been done. */
72 static int macro_number;
74 /* Initialize macro processing. */
76 void
77 macro_init (int alternate, int mri, int strip_at,
78 int (*exp) (const char *, int, sb *, int *))
80 macro_hash = hash_new ();
81 macro_defined = 0;
82 macro_alternate = alternate;
83 macro_mri = mri;
84 macro_strip_at = strip_at;
85 macro_expr = exp;
88 /* Switch in and out of alternate mode on the fly. */
90 void
91 macro_set_alternate (int alternate)
93 macro_alternate = alternate;
96 /* Switch in and out of MRI mode on the fly. */
98 void
99 macro_mri_mode (int mri)
101 macro_mri = mri;
104 /* Read input lines till we get to a TO string.
105 Increase nesting depth if we get a FROM string.
106 Put the results into sb at PTR.
107 FROM may be NULL (or will be ignored) if TO is "ENDR".
108 Add a new input line to an sb using GET_LINE.
109 Return 1 on success, 0 on unexpected EOF. */
112 buffer_and_nest (const char *from, const char *to, sb *ptr,
113 int (*get_line) (sb *))
115 int from_len;
116 int to_len = strlen (to);
117 int depth = 1;
118 int line_start = ptr->len;
120 int more = get_line (ptr);
122 if (to_len == 4 && strcasecmp(to, "ENDR") == 0)
124 from = NULL;
125 from_len = 0;
127 else
128 from_len = strlen (from);
130 while (more)
132 /* Try to find the first pseudo op on the line. */
133 int i = line_start;
134 bfd_boolean had_colon = FALSE;
136 /* With normal syntax we can suck what we want till we get
137 to the dot. With the alternate, labels have to start in
138 the first column, since we can't tell what's a label and
139 what's a pseudoop. */
141 if (! LABELS_WITHOUT_COLONS)
143 /* Skip leading whitespace. */
144 while (i < ptr->len && ISWHITE (ptr->ptr[i]))
145 i++;
148 for (;;)
150 /* Skip over a label, if any. */
151 if (i >= ptr->len || ! is_name_beginner (ptr->ptr[i]))
152 break;
153 i++;
154 while (i < ptr->len && is_part_of_name (ptr->ptr[i]))
155 i++;
156 if (i < ptr->len && is_name_ender (ptr->ptr[i]))
157 i++;
158 /* Skip whitespace. */
159 while (i < ptr->len && ISWHITE (ptr->ptr[i]))
160 i++;
161 /* Check for the colon. */
162 if (i >= ptr->len || ptr->ptr[i] != ':')
164 /* LABELS_WITHOUT_COLONS doesn't mean we cannot have a
165 colon after a label. If we do have a colon on the
166 first label then handle more than one label on the
167 line, assuming that each label has a colon. */
168 if (LABELS_WITHOUT_COLONS && !had_colon)
169 break;
170 i = line_start;
171 break;
173 i++;
174 line_start = i;
175 had_colon = TRUE;
178 /* Skip trailing whitespace. */
179 while (i < ptr->len && ISWHITE (ptr->ptr[i]))
180 i++;
182 if (i < ptr->len && (ptr->ptr[i] == '.'
183 || NO_PSEUDO_DOT
184 || macro_mri))
186 if (! flag_m68k_mri && ptr->ptr[i] == '.')
187 i++;
188 if (from == NULL
189 && strncasecmp (ptr->ptr + i, "IRPC", from_len = 4) != 0
190 && strncasecmp (ptr->ptr + i, "IRP", from_len = 3) != 0
191 && strncasecmp (ptr->ptr + i, "IREPC", from_len = 5) != 0
192 && strncasecmp (ptr->ptr + i, "IREP", from_len = 4) != 0
193 && strncasecmp (ptr->ptr + i, "REPT", from_len = 4) != 0
194 && strncasecmp (ptr->ptr + i, "REP", from_len = 3) != 0)
195 from_len = 0;
196 if ((from != NULL
197 ? strncasecmp (ptr->ptr + i, from, from_len) == 0
198 : from_len > 0)
199 && (ptr->len == (i + from_len)
200 || ! (is_part_of_name (ptr->ptr[i + from_len])
201 || is_name_ender (ptr->ptr[i + from_len]))))
202 depth++;
203 if (strncasecmp (ptr->ptr + i, to, to_len) == 0
204 && (ptr->len == (i + to_len)
205 || ! (is_part_of_name (ptr->ptr[i + to_len])
206 || is_name_ender (ptr->ptr[i + to_len]))))
208 depth--;
209 if (depth == 0)
211 /* Reset the string to not include the ending rune. */
212 ptr->len = line_start;
213 break;
218 /* Add the original end-of-line char to the end and keep running. */
219 sb_add_char (ptr, more);
220 line_start = ptr->len;
221 more = get_line (ptr);
224 /* Return 1 on success, 0 on unexpected EOF. */
225 return depth == 0;
228 /* Pick up a token. */
230 static int
231 get_token (int idx, sb *in, sb *name)
233 if (idx < in->len
234 && is_name_beginner (in->ptr[idx]))
236 sb_add_char (name, in->ptr[idx++]);
237 while (idx < in->len
238 && is_part_of_name (in->ptr[idx]))
240 sb_add_char (name, in->ptr[idx++]);
242 if (idx < in->len
243 && is_name_ender (in->ptr[idx]))
245 sb_add_char (name, in->ptr[idx++]);
248 /* Ignore trailing &. */
249 if (macro_alternate && idx < in->len && in->ptr[idx] == '&')
250 idx++;
251 return idx;
254 /* Pick up a string. */
256 static int
257 getstring (int idx, sb *in, sb *acc)
259 while (idx < in->len
260 && (in->ptr[idx] == '"'
261 || (in->ptr[idx] == '<' && (macro_alternate || macro_mri))
262 || (in->ptr[idx] == '\'' && macro_alternate)))
264 if (in->ptr[idx] == '<')
266 int nest = 0;
267 idx++;
268 while ((in->ptr[idx] != '>' || nest)
269 && idx < in->len)
271 if (in->ptr[idx] == '!')
273 idx++;
274 sb_add_char (acc, in->ptr[idx++]);
276 else
278 if (in->ptr[idx] == '>')
279 nest--;
280 if (in->ptr[idx] == '<')
281 nest++;
282 sb_add_char (acc, in->ptr[idx++]);
285 idx++;
287 else if (in->ptr[idx] == '"' || in->ptr[idx] == '\'')
289 char tchar = in->ptr[idx];
290 int escaped = 0;
292 idx++;
294 while (idx < in->len)
296 if (in->ptr[idx - 1] == '\\')
297 escaped ^= 1;
298 else
299 escaped = 0;
301 if (macro_alternate && in->ptr[idx] == '!')
303 idx ++;
305 sb_add_char (acc, in->ptr[idx]);
307 idx ++;
309 else if (escaped && in->ptr[idx] == tchar)
311 sb_add_char (acc, tchar);
312 idx ++;
314 else
316 if (in->ptr[idx] == tchar)
318 idx ++;
320 if (idx >= in->len || in->ptr[idx] != tchar)
321 break;
324 sb_add_char (acc, in->ptr[idx]);
325 idx ++;
331 return idx;
334 /* Fetch string from the input stream,
335 rules:
336 'Bxyx<whitespace> -> return 'Bxyza
337 %<expr> -> return string of decimal value of <expr>
338 "string" -> return string
339 (string) -> return (string-including-whitespaces)
340 xyx<whitespace> -> return xyz. */
342 static int
343 get_any_string (int idx, sb *in, sb *out)
345 sb_reset (out);
346 idx = sb_skip_white (idx, in);
348 if (idx < in->len)
350 if (in->len > idx + 2 && in->ptr[idx + 1] == '\'' && ISBASE (in->ptr[idx]))
352 while (!ISSEP (in->ptr[idx]))
353 sb_add_char (out, in->ptr[idx++]);
355 else if (in->ptr[idx] == '%' && macro_alternate)
357 int val;
358 char buf[20];
360 /* Turns the next expression into a string. */
361 /* xgettext: no-c-format */
362 idx = (*macro_expr) (_("% operator needs absolute expression"),
363 idx + 1,
365 &val);
366 sprintf (buf, "%d", val);
367 sb_add_string (out, buf);
369 else if (in->ptr[idx] == '"'
370 || (in->ptr[idx] == '<' && (macro_alternate || macro_mri))
371 || (macro_alternate && in->ptr[idx] == '\''))
373 if (macro_alternate && ! macro_strip_at && in->ptr[idx] != '<')
375 /* Keep the quotes. */
376 sb_add_char (out, '"');
377 idx = getstring (idx, in, out);
378 sb_add_char (out, '"');
380 else
382 idx = getstring (idx, in, out);
385 else
387 char *br_buf = (char *) xmalloc(1);
388 char *in_br = br_buf;
390 *in_br = '\0';
391 while (idx < in->len
392 && (*in_br
393 || (in->ptr[idx] != ' '
394 && in->ptr[idx] != '\t'))
395 && in->ptr[idx] != ','
396 && (in->ptr[idx] != '<'
397 || (! macro_alternate && ! macro_mri)))
399 char tchar = in->ptr[idx];
401 switch (tchar)
403 case '"':
404 case '\'':
405 sb_add_char (out, in->ptr[idx++]);
406 while (idx < in->len
407 && in->ptr[idx] != tchar)
408 sb_add_char (out, in->ptr[idx++]);
409 if (idx == in->len)
410 return idx;
411 break;
412 case '(':
413 case '[':
414 if (in_br > br_buf)
415 --in_br;
416 else
418 br_buf = (char *) xmalloc(strlen(in_br) + 2);
419 strcpy(br_buf + 1, in_br);
420 free(in_br);
421 in_br = br_buf;
423 *in_br = tchar;
424 break;
425 case ')':
426 if (*in_br == '(')
427 ++in_br;
428 break;
429 case ']':
430 if (*in_br == '[')
431 ++in_br;
432 break;
434 sb_add_char (out, tchar);
435 ++idx;
437 free(br_buf);
441 return idx;
444 /* Allocate a new formal. */
446 static formal_entry *
447 new_formal (void)
449 formal_entry *formal;
451 formal = (formal_entry *) xmalloc (sizeof (formal_entry));
453 sb_new (&formal->name);
454 sb_new (&formal->def);
455 sb_new (&formal->actual);
456 formal->next = NULL;
457 formal->type = FORMAL_OPTIONAL;
458 return formal;
461 /* Free a formal. */
463 static void
464 del_formal (formal_entry *formal)
466 sb_kill (&formal->actual);
467 sb_kill (&formal->def);
468 sb_kill (&formal->name);
469 free (formal);
472 /* Pick up the formal parameters of a macro definition. */
474 static int
475 do_formals (macro_entry *macro, int idx, sb *in)
477 formal_entry **p = &macro->formals;
478 const char *name;
480 idx = sb_skip_white (idx, in);
481 while (idx < in->len)
483 formal_entry *formal = new_formal ();
484 int cidx;
486 idx = get_token (idx, in, &formal->name);
487 if (formal->name.len == 0)
489 if (macro->formal_count)
490 --idx;
491 break;
493 idx = sb_skip_white (idx, in);
494 /* This is a formal. */
495 name = sb_terminate (&formal->name);
496 if (! macro_mri
497 && idx < in->len
498 && in->ptr[idx] == ':'
499 && (! is_name_beginner (':')
500 || idx + 1 >= in->len
501 || ! is_part_of_name (in->ptr[idx + 1])))
503 /* Got a qualifier. */
504 sb qual;
506 sb_new (&qual);
507 idx = get_token (sb_skip_white (idx + 1, in), in, &qual);
508 sb_terminate (&qual);
509 if (qual.len == 0)
510 as_bad_where (macro->file,
511 macro->line,
512 _("Missing parameter qualifier for `%s' in macro `%s'"),
513 name,
514 macro->name);
515 else if (strcmp (qual.ptr, "req") == 0)
516 formal->type = FORMAL_REQUIRED;
517 else if (strcmp (qual.ptr, "vararg") == 0)
518 formal->type = FORMAL_VARARG;
519 else
520 as_bad_where (macro->file,
521 macro->line,
522 _("`%s' is not a valid parameter qualifier for `%s' in macro `%s'"),
523 qual.ptr,
524 name,
525 macro->name);
526 sb_kill (&qual);
527 idx = sb_skip_white (idx, in);
529 if (idx < in->len && in->ptr[idx] == '=')
531 /* Got a default. */
532 idx = get_any_string (idx + 1, in, &formal->def);
533 idx = sb_skip_white (idx, in);
534 if (formal->type == FORMAL_REQUIRED)
536 sb_reset (&formal->def);
537 as_warn_where (macro->file,
538 macro->line,
539 _("Pointless default value for required parameter `%s' in macro `%s'"),
540 name,
541 macro->name);
545 /* Add to macro's hash table. */
546 if (! hash_find (macro->formal_hash, name))
547 hash_jam (macro->formal_hash, name, formal);
548 else
549 as_bad_where (macro->file,
550 macro->line,
551 _("A parameter named `%s' already exists for macro `%s'"),
552 name,
553 macro->name);
555 formal->index = macro->formal_count++;
556 *p = formal;
557 p = &formal->next;
558 if (formal->type == FORMAL_VARARG)
559 break;
560 cidx = idx;
561 idx = sb_skip_comma (idx, in);
562 if (idx != cidx && idx >= in->len)
564 idx = cidx;
565 break;
569 if (macro_mri)
571 formal_entry *formal = new_formal ();
573 /* Add a special NARG formal, which macro_expand will set to the
574 number of arguments. */
575 /* The same MRI assemblers which treat '@' characters also use
576 the name $NARG. At least until we find an exception. */
577 if (macro_strip_at)
578 name = "$NARG";
579 else
580 name = "NARG";
582 sb_add_string (&formal->name, name);
584 /* Add to macro's hash table. */
585 if (hash_find (macro->formal_hash, name))
586 as_bad_where (macro->file,
587 macro->line,
588 _("Reserved word `%s' used as parameter in macro `%s'"),
589 name,
590 macro->name);
591 hash_jam (macro->formal_hash, name, formal);
593 formal->index = NARG_INDEX;
594 *p = formal;
597 return idx;
600 /* Free the memory allocated to a macro. */
602 static void
603 free_macro (macro_entry *macro)
605 formal_entry *formal;
607 for (formal = macro->formals; formal; )
609 formal_entry *f;
611 f = formal;
612 formal = formal->next;
613 del_formal (f);
615 hash_die (macro->formal_hash);
616 sb_kill (&macro->sub);
617 free (macro);
620 /* Define a new macro. Returns NULL on success, otherwise returns an
621 error message. If NAMEP is not NULL, *NAMEP is set to the name of
622 the macro which was defined. */
624 const char *
625 define_macro (int idx, sb *in, sb *label,
626 int (*get_line) (sb *),
627 char *file, unsigned int line,
628 const char **namep)
630 macro_entry *macro;
631 sb name;
632 const char *error = NULL;
634 macro = (macro_entry *) xmalloc (sizeof (macro_entry));
635 sb_new (&macro->sub);
636 sb_new (&name);
637 macro->file = file;
638 macro->line = line;
640 macro->formal_count = 0;
641 macro->formals = 0;
642 macro->formal_hash = hash_new ();
644 idx = sb_skip_white (idx, in);
645 if (! buffer_and_nest ("MACRO", "ENDM", &macro->sub, get_line))
646 error = _("unexpected end of file in macro `%s' definition");
647 if (label != NULL && label->len != 0)
649 sb_add_sb (&name, label);
650 macro->name = sb_terminate (&name);
651 if (idx < in->len && in->ptr[idx] == '(')
653 /* It's the label: MACRO (formals,...) sort */
654 idx = do_formals (macro, idx + 1, in);
655 if (idx < in->len && in->ptr[idx] == ')')
656 idx = sb_skip_white (idx + 1, in);
657 else if (!error)
658 error = _("missing `)' after formals in macro definition `%s'");
660 else
662 /* It's the label: MACRO formals,... sort */
663 idx = do_formals (macro, idx, in);
666 else
668 int cidx;
670 idx = get_token (idx, in, &name);
671 macro->name = sb_terminate (&name);
672 if (name.len == 0)
673 error = _("Missing macro name");
674 cidx = sb_skip_white (idx, in);
675 idx = sb_skip_comma (cidx, in);
676 if (idx == cidx || idx < in->len)
677 idx = do_formals (macro, idx, in);
678 else
679 idx = cidx;
681 if (!error && idx < in->len)
682 error = _("Bad parameter list for macro `%s'");
684 /* And stick it in the macro hash table. */
685 for (idx = 0; idx < name.len; idx++)
686 name.ptr[idx] = TOLOWER (name.ptr[idx]);
687 if (hash_find (macro_hash, macro->name))
688 error = _("Macro `%s' was already defined");
689 if (!error)
690 error = hash_jam (macro_hash, macro->name, (void *) macro);
692 if (namep != NULL)
693 *namep = macro->name;
695 if (!error)
696 macro_defined = 1;
697 else
698 free_macro (macro);
700 return error;
703 /* Scan a token, and then skip KIND. */
705 static int
706 get_apost_token (int idx, sb *in, sb *name, int kind)
708 idx = get_token (idx, in, name);
709 if (idx < in->len
710 && in->ptr[idx] == kind
711 && (! macro_mri || macro_strip_at)
712 && (! macro_strip_at || kind == '@'))
713 idx++;
714 return idx;
717 /* Substitute the actual value for a formal parameter. */
719 static int
720 sub_actual (int start, sb *in, sb *t, struct hash_control *formal_hash,
721 int kind, sb *out, int copyifnotthere)
723 int src;
724 formal_entry *ptr;
726 src = get_apost_token (start, in, t, kind);
727 /* See if it's in the macro's hash table, unless this is
728 macro_strip_at and kind is '@' and the token did not end in '@'. */
729 if (macro_strip_at
730 && kind == '@'
731 && (src == start || in->ptr[src - 1] != '@'))
732 ptr = NULL;
733 else
734 ptr = (formal_entry *) hash_find (formal_hash, sb_terminate (t));
735 if (ptr)
737 if (ptr->actual.len)
739 sb_add_sb (out, &ptr->actual);
741 else
743 sb_add_sb (out, &ptr->def);
746 else if (kind == '&')
748 /* Doing this permits people to use & in macro bodies. */
749 sb_add_char (out, '&');
750 sb_add_sb (out, t);
751 if (src != start && in->ptr[src - 1] == '&')
752 sb_add_char (out, '&');
754 else if (copyifnotthere)
756 sb_add_sb (out, t);
758 else
760 sb_add_char (out, '\\');
761 sb_add_sb (out, t);
763 return src;
766 /* Expand the body of a macro. */
768 static const char *
769 macro_expand_body (sb *in, sb *out, formal_entry *formals,
770 struct hash_control *formal_hash, const macro_entry *macro)
772 sb t;
773 int src = 0, inquote = 0, macro_line = 0;
774 formal_entry *loclist = NULL;
775 const char *err = NULL;
777 sb_new (&t);
779 while (src < in->len && !err)
781 if (in->ptr[src] == '&')
783 sb_reset (&t);
784 if (macro_mri)
786 if (src + 1 < in->len && in->ptr[src + 1] == '&')
787 src = sub_actual (src + 2, in, &t, formal_hash, '\'', out, 1);
788 else
789 sb_add_char (out, in->ptr[src++]);
791 else
793 /* Permit macro parameter substition delineated with
794 an '&' prefix and optional '&' suffix. */
795 src = sub_actual (src + 1, in, &t, formal_hash, '&', out, 0);
798 else if (in->ptr[src] == '\\')
800 src++;
801 if (src < in->len && in->ptr[src] == '(')
803 /* Sub in till the next ')' literally. */
804 src++;
805 while (src < in->len && in->ptr[src] != ')')
807 sb_add_char (out, in->ptr[src++]);
809 if (src < in->len)
810 src++;
811 else if (!macro)
812 err = _("missing `)'");
813 else
814 as_bad_where (macro->file, macro->line + macro_line, _("missing `)'"));
816 else if (src < in->len && in->ptr[src] == '@')
818 /* Sub in the macro invocation number. */
820 char buffer[10];
821 src++;
822 sprintf (buffer, "%d", macro_number);
823 sb_add_string (out, buffer);
825 else if (src < in->len && in->ptr[src] == '&')
827 /* This is a preprocessor variable name, we don't do them
828 here. */
829 sb_add_char (out, '\\');
830 sb_add_char (out, '&');
831 src++;
833 else if (macro_mri && src < in->len && ISALNUM (in->ptr[src]))
835 int ind;
836 formal_entry *f;
838 if (ISDIGIT (in->ptr[src]))
839 ind = in->ptr[src] - '0';
840 else if (ISUPPER (in->ptr[src]))
841 ind = in->ptr[src] - 'A' + 10;
842 else
843 ind = in->ptr[src] - 'a' + 10;
844 ++src;
845 for (f = formals; f != NULL; f = f->next)
847 if (f->index == ind - 1)
849 if (f->actual.len != 0)
850 sb_add_sb (out, &f->actual);
851 else
852 sb_add_sb (out, &f->def);
853 break;
857 else
859 sb_reset (&t);
860 src = sub_actual (src, in, &t, formal_hash, '\'', out, 0);
863 else if ((macro_alternate || macro_mri)
864 && is_name_beginner (in->ptr[src])
865 && (! inquote
866 || ! macro_strip_at
867 || (src > 0 && in->ptr[src - 1] == '@')))
869 if (! macro
870 || src + 5 >= in->len
871 || strncasecmp (in->ptr + src, "LOCAL", 5) != 0
872 || ! ISWHITE (in->ptr[src + 5])
873 /* PR 11507: Skip keyword LOCAL if it is found inside a quoted string. */
874 || inquote)
876 sb_reset (&t);
877 src = sub_actual (src, in, &t, formal_hash,
878 (macro_strip_at && inquote) ? '@' : '\'',
879 out, 1);
881 else
883 src = sb_skip_white (src + 5, in);
884 while (in->ptr[src] != '\n')
886 const char *name;
887 formal_entry *f = new_formal ();
889 src = get_token (src, in, &f->name);
890 name = sb_terminate (&f->name);
891 if (! hash_find (formal_hash, name))
893 static int loccnt;
894 char buf[20];
896 f->index = LOCAL_INDEX;
897 f->next = loclist;
898 loclist = f;
900 sprintf (buf, IS_ELF ? ".LL%04x" : "LL%04x", ++loccnt);
901 sb_add_string (&f->actual, buf);
903 err = hash_jam (formal_hash, name, f);
904 if (err != NULL)
905 break;
907 else
909 as_bad_where (macro->file,
910 macro->line + macro_line,
911 _("`%s' was already used as parameter (or another local) name"),
912 name);
913 del_formal (f);
916 src = sb_skip_comma (src, in);
920 else if (in->ptr[src] == '"'
921 || (macro_mri && in->ptr[src] == '\''))
923 inquote = !inquote;
924 sb_add_char (out, in->ptr[src++]);
926 else if (in->ptr[src] == '@' && macro_strip_at)
928 ++src;
929 if (src < in->len
930 && in->ptr[src] == '@')
932 sb_add_char (out, '@');
933 ++src;
936 else if (macro_mri
937 && in->ptr[src] == '='
938 && src + 1 < in->len
939 && in->ptr[src + 1] == '=')
941 formal_entry *ptr;
943 sb_reset (&t);
944 src = get_token (src + 2, in, &t);
945 ptr = (formal_entry *) hash_find (formal_hash, sb_terminate (&t));
946 if (ptr == NULL)
948 /* FIXME: We should really return a warning string here,
949 but we can't, because the == might be in the MRI
950 comment field, and, since the nature of the MRI
951 comment field depends upon the exact instruction
952 being used, we don't have enough information here to
953 figure out whether it is or not. Instead, we leave
954 the == in place, which should cause a syntax error if
955 it is not in a comment. */
956 sb_add_char (out, '=');
957 sb_add_char (out, '=');
958 sb_add_sb (out, &t);
960 else
962 if (ptr->actual.len)
964 sb_add_string (out, "-1");
966 else
968 sb_add_char (out, '0');
972 else
974 if (in->ptr[src] == '\n')
975 ++macro_line;
976 sb_add_char (out, in->ptr[src++]);
980 sb_kill (&t);
982 while (loclist != NULL)
984 formal_entry *f;
985 const char *name;
987 f = loclist->next;
988 name = sb_terminate (&loclist->name);
989 hash_delete (formal_hash, name, f == NULL);
990 del_formal (loclist);
991 loclist = f;
994 return err;
997 /* Assign values to the formal parameters of a macro, and expand the
998 body. */
1000 static const char *
1001 macro_expand (int idx, sb *in, macro_entry *m, sb *out)
1003 sb t;
1004 formal_entry *ptr;
1005 formal_entry *f;
1006 int is_keyword = 0;
1007 int narg = 0;
1008 const char *err = NULL;
1010 sb_new (&t);
1012 /* Reset any old value the actuals may have. */
1013 for (f = m->formals; f; f = f->next)
1014 sb_reset (&f->actual);
1015 f = m->formals;
1016 while (f != NULL && f->index < 0)
1017 f = f->next;
1019 if (macro_mri)
1021 /* The macro may be called with an optional qualifier, which may
1022 be referred to in the macro body as \0. */
1023 if (idx < in->len && in->ptr[idx] == '.')
1025 /* The Microtec assembler ignores this if followed by a white space.
1026 (Macro invocation with empty extension) */
1027 idx++;
1028 if ( idx < in->len
1029 && in->ptr[idx] != ' '
1030 && in->ptr[idx] != '\t')
1032 formal_entry *n = new_formal ();
1034 n->index = QUAL_INDEX;
1036 n->next = m->formals;
1037 m->formals = n;
1039 idx = get_any_string (idx, in, &n->actual);
1044 /* Peel off the actuals and store them away in the hash tables' actuals. */
1045 idx = sb_skip_white (idx, in);
1046 while (idx < in->len)
1048 int scan;
1050 /* Look and see if it's a positional or keyword arg. */
1051 scan = idx;
1052 while (scan < in->len
1053 && !ISSEP (in->ptr[scan])
1054 && !(macro_mri && in->ptr[scan] == '\'')
1055 && (!macro_alternate && in->ptr[scan] != '='))
1056 scan++;
1057 if (scan < in->len && !macro_alternate && in->ptr[scan] == '=')
1059 is_keyword = 1;
1061 /* It's OK to go from positional to keyword. */
1063 /* This is a keyword arg, fetch the formal name and
1064 then the actual stuff. */
1065 sb_reset (&t);
1066 idx = get_token (idx, in, &t);
1067 if (in->ptr[idx] != '=')
1069 err = _("confusion in formal parameters");
1070 break;
1073 /* Lookup the formal in the macro's list. */
1074 ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t));
1075 if (!ptr)
1077 as_bad (_("Parameter named `%s' does not exist for macro `%s'"),
1078 t.ptr,
1079 m->name);
1080 sb_reset (&t);
1081 idx = get_any_string (idx + 1, in, &t);
1083 else
1085 /* Insert this value into the right place. */
1086 if (ptr->actual.len)
1088 as_warn (_("Value for parameter `%s' of macro `%s' was already specified"),
1089 ptr->name.ptr,
1090 m->name);
1091 sb_reset (&ptr->actual);
1093 idx = get_any_string (idx + 1, in, &ptr->actual);
1094 if (ptr->actual.len > 0)
1095 ++narg;
1098 else
1100 if (is_keyword)
1102 err = _("can't mix positional and keyword arguments");
1103 break;
1106 if (!f)
1108 formal_entry **pf;
1109 int c;
1111 if (!macro_mri)
1113 err = _("too many positional arguments");
1114 break;
1117 f = new_formal ();
1119 c = -1;
1120 for (pf = &m->formals; *pf != NULL; pf = &(*pf)->next)
1121 if ((*pf)->index >= c)
1122 c = (*pf)->index + 1;
1123 if (c == -1)
1124 c = 0;
1125 *pf = f;
1126 f->index = c;
1129 if (f->type != FORMAL_VARARG)
1130 idx = get_any_string (idx, in, &f->actual);
1131 else
1133 sb_add_buffer (&f->actual, in->ptr + idx, in->len - idx);
1134 idx = in->len;
1136 if (f->actual.len > 0)
1137 ++narg;
1140 f = f->next;
1142 while (f != NULL && f->index < 0);
1145 if (! macro_mri)
1146 idx = sb_skip_comma (idx, in);
1147 else
1149 if (in->ptr[idx] == ',')
1150 ++idx;
1151 if (ISWHITE (in->ptr[idx]))
1152 break;
1156 if (! err)
1158 for (ptr = m->formals; ptr; ptr = ptr->next)
1160 if (ptr->type == FORMAL_REQUIRED && ptr->actual.len == 0)
1161 as_bad (_("Missing value for required parameter `%s' of macro `%s'"),
1162 ptr->name.ptr,
1163 m->name);
1166 if (macro_mri)
1168 char buffer[20];
1170 sb_reset (&t);
1171 sb_add_string (&t, macro_strip_at ? "$NARG" : "NARG");
1172 ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t));
1173 sprintf (buffer, "%d", narg);
1174 sb_add_string (&ptr->actual, buffer);
1177 err = macro_expand_body (&m->sub, out, m->formals, m->formal_hash, m);
1180 /* Discard any unnamed formal arguments. */
1181 if (macro_mri)
1183 formal_entry **pf;
1185 pf = &m->formals;
1186 while (*pf != NULL)
1188 if ((*pf)->name.len != 0)
1189 pf = &(*pf)->next;
1190 else
1192 f = (*pf)->next;
1193 del_formal (*pf);
1194 *pf = f;
1199 sb_kill (&t);
1200 if (!err)
1201 macro_number++;
1203 return err;
1206 /* Check for a macro. If one is found, put the expansion into
1207 *EXPAND. Return 1 if a macro is found, 0 otherwise. */
1210 check_macro (const char *line, sb *expand,
1211 const char **error, macro_entry **info)
1213 const char *s;
1214 char *copy, *cls;
1215 macro_entry *macro;
1216 sb line_sb;
1218 if (! is_name_beginner (*line)
1219 && (! macro_mri || *line != '.'))
1220 return 0;
1222 s = line + 1;
1223 while (is_part_of_name (*s))
1224 ++s;
1225 if (is_name_ender (*s))
1226 ++s;
1228 copy = (char *) alloca (s - line + 1);
1229 memcpy (copy, line, s - line);
1230 copy[s - line] = '\0';
1231 for (cls = copy; *cls != '\0'; cls ++)
1232 *cls = TOLOWER (*cls);
1234 macro = (macro_entry *) hash_find (macro_hash, copy);
1236 if (macro == NULL)
1237 return 0;
1239 /* Wrap the line up in an sb. */
1240 sb_new (&line_sb);
1241 while (*s != '\0' && *s != '\n' && *s != '\r')
1242 sb_add_char (&line_sb, *s++);
1244 sb_new (expand);
1245 *error = macro_expand (0, &line_sb, macro, expand);
1247 sb_kill (&line_sb);
1249 /* Export the macro information if requested. */
1250 if (info)
1251 *info = macro;
1253 return 1;
1256 /* Delete a macro. */
1258 void
1259 delete_macro (const char *name)
1261 char *copy;
1262 size_t i, len;
1263 macro_entry *macro;
1265 len = strlen (name);
1266 copy = (char *) alloca (len + 1);
1267 for (i = 0; i < len; ++i)
1268 copy[i] = TOLOWER (name[i]);
1269 copy[i] = '\0';
1271 /* We can only ask hash_delete to free memory if we are deleting
1272 macros in reverse order to their definition.
1273 So just clear out the entry. */
1274 if ((macro = (macro_entry *) hash_find (macro_hash, copy)) != NULL)
1276 hash_jam (macro_hash, copy, NULL);
1277 free_macro (macro);
1279 else
1280 as_warn (_("Attempt to purge non-existant macro `%s'"), copy);
1283 /* Handle the MRI IRP and IRPC pseudo-ops. These are handled as a
1284 combined macro definition and execution. This returns NULL on
1285 success, or an error message otherwise. */
1287 const char *
1288 expand_irp (int irpc, int idx, sb *in, sb *out, int (*get_line) (sb *))
1290 sb sub;
1291 formal_entry f;
1292 struct hash_control *h;
1293 const char *err;
1295 idx = sb_skip_white (idx, in);
1297 sb_new (&sub);
1298 if (! buffer_and_nest (NULL, "ENDR", &sub, get_line))
1299 return _("unexpected end of file in irp or irpc");
1301 sb_new (&f.name);
1302 sb_new (&f.def);
1303 sb_new (&f.actual);
1305 idx = get_token (idx, in, &f.name);
1306 if (f.name.len == 0)
1307 return _("missing model parameter");
1309 h = hash_new ();
1310 err = hash_jam (h, sb_terminate (&f.name), &f);
1311 if (err != NULL)
1312 return err;
1314 f.index = 1;
1315 f.next = NULL;
1316 f.type = FORMAL_OPTIONAL;
1318 sb_reset (out);
1320 idx = sb_skip_comma (idx, in);
1321 if (idx >= in->len)
1323 /* Expand once with a null string. */
1324 err = macro_expand_body (&sub, out, &f, h, 0);
1326 else
1328 bfd_boolean in_quotes = FALSE;
1330 if (irpc && in->ptr[idx] == '"')
1332 in_quotes = TRUE;
1333 ++idx;
1336 while (idx < in->len)
1338 if (!irpc)
1339 idx = get_any_string (idx, in, &f.actual);
1340 else
1342 if (in->ptr[idx] == '"')
1344 int nxt;
1346 if (irpc)
1347 in_quotes = ! in_quotes;
1349 nxt = sb_skip_white (idx + 1, in);
1350 if (nxt >= in->len)
1352 idx = nxt;
1353 break;
1356 sb_reset (&f.actual);
1357 sb_add_char (&f.actual, in->ptr[idx]);
1358 ++idx;
1361 err = macro_expand_body (&sub, out, &f, h, 0);
1362 if (err != NULL)
1363 break;
1364 if (!irpc)
1365 idx = sb_skip_comma (idx, in);
1366 else if (! in_quotes)
1367 idx = sb_skip_white (idx, in);
1371 hash_die (h);
1372 sb_kill (&f.actual);
1373 sb_kill (&f.def);
1374 sb_kill (&f.name);
1375 sb_kill (&sub);
1377 return err;