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