1 /* macro.c - macro support for gas
2 Copyright (C) 1994-2020 Free Software Foundation, Inc.
4 Written by Steve and Judy Chamberlain of Cygnus Support,
7 This file is part of GAS, the GNU Assembler.
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)
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.
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
25 #include "safe-ctype.h"
29 /* The routines in this file handle macro definition and expansion.
30 They are called by gas. */
32 #define ISWHITE(x) ((x) == ' ' || (x) == '\t')
35 ((x) == ' ' || (x) == '\t' || (x) == ',' || (x) == '"' || (x) == ';' \
36 || (x) == ')' || (x) == '(' \
37 || ((macro_alternate || macro_mri) && ((x) == '<' || (x) == '>')))
40 ((x) == 'b' || (x) == 'B' \
41 || (x) == 'q' || (x) == 'Q' \
42 || (x) == 'h' || (x) == 'H' \
43 || (x) == 'd' || (x) == 'D')
45 /* The macro hash table. */
47 struct htab
*macro_hash
;
49 /* Whether any macros have been defined. */
53 /* Whether we are in alternate syntax mode. */
55 static int macro_alternate
;
57 /* Whether we are in MRI mode. */
61 /* Whether we should strip '@' characters. */
63 static int macro_strip_at
;
65 /* Function to use to parse an expression. */
67 static size_t (*macro_expr
) (const char *, size_t, sb
*, offsetT
*);
69 /* Number of macro expansions that have been done. */
71 static int macro_number
;
73 /* Initialize macro processing. */
76 macro_init (int alternate
, int mri
, int strip_at
,
77 size_t (*exp
) (const char *, size_t, sb
*, offsetT
*))
79 macro_hash
= htab_create_alloc (16, hash_macro_entry
, eq_macro_entry
,
82 macro_alternate
= alternate
;
84 macro_strip_at
= strip_at
;
88 /* Switch in and out of alternate mode on the fly. */
91 macro_set_alternate (int alternate
)
93 macro_alternate
= alternate
;
96 /* Switch in and out of MRI mode on the fly. */
99 macro_mri_mode (int 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 size_t (*get_line
) (sb
*))
116 size_t to_len
= strlen (to
);
118 size_t line_start
= ptr
->len
;
119 size_t more
= get_line (ptr
);
121 if (to_len
== 4 && strcasecmp (to
, "ENDR") == 0)
127 from_len
= strlen (from
);
131 /* Try to find the first pseudo op on the line. */
132 size_t i
= line_start
;
133 bfd_boolean had_colon
= FALSE
;
135 /* With normal syntax we can suck what we want till we get
136 to the dot. With the alternate, labels have to start in
137 the first column, since we can't tell what's a label and
138 what's a pseudoop. */
140 if (! LABELS_WITHOUT_COLONS
)
142 /* Skip leading whitespace. */
143 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
149 /* Skip over a label, if any. */
150 if (i
>= ptr
->len
|| ! is_name_beginner (ptr
->ptr
[i
]))
153 while (i
< ptr
->len
&& is_part_of_name (ptr
->ptr
[i
]))
155 if (i
< ptr
->len
&& is_name_ender (ptr
->ptr
[i
]))
157 /* Skip whitespace. */
158 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
160 /* Check for the colon. */
161 if (i
>= ptr
->len
|| ptr
->ptr
[i
] != ':')
163 /* LABELS_WITHOUT_COLONS doesn't mean we cannot have a
164 colon after a label. If we do have a colon on the
165 first label then handle more than one label on the
166 line, assuming that each label has a colon. */
167 if (LABELS_WITHOUT_COLONS
&& !had_colon
)
177 /* Skip trailing whitespace. */
178 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
181 if (i
< ptr
->len
&& (ptr
->ptr
[i
] == '.'
185 if (! flag_m68k_mri
&& ptr
->ptr
[i
] == '.')
188 && strncasecmp (ptr
->ptr
+ i
, "IRPC", from_len
= 4) != 0
189 && strncasecmp (ptr
->ptr
+ i
, "IRP", from_len
= 3) != 0
190 && strncasecmp (ptr
->ptr
+ i
, "IREPC", from_len
= 5) != 0
191 && strncasecmp (ptr
->ptr
+ i
, "IREP", from_len
= 4) != 0
192 && strncasecmp (ptr
->ptr
+ i
, "REPT", from_len
= 4) != 0
193 && strncasecmp (ptr
->ptr
+ i
, "REP", from_len
= 3) != 0)
196 ? strncasecmp (ptr
->ptr
+ i
, from
, from_len
) == 0
198 && (ptr
->len
== (i
+ from_len
)
199 || ! (is_part_of_name (ptr
->ptr
[i
+ from_len
])
200 || is_name_ender (ptr
->ptr
[i
+ from_len
]))))
202 if (strncasecmp (ptr
->ptr
+ i
, to
, to_len
) == 0
203 && (ptr
->len
== (i
+ to_len
)
204 || ! (is_part_of_name (ptr
->ptr
[i
+ to_len
])
205 || is_name_ender (ptr
->ptr
[i
+ to_len
]))))
210 /* Reset the string to not include the ending rune. */
211 ptr
->len
= line_start
;
217 Apply and discard .linefile directives that appear within
218 the macro. For long macros, one might want to report the
219 line number information associated with the lines within
220 the macro definition, but we would need more infrastructure
221 to make that happen correctly (e.g. resetting the line
222 number when expanding the macro), and since for short
223 macros we clearly prefer reporting the point of expansion
224 anyway, there's not an obviously better fix here. */
225 if (strncasecmp (ptr
->ptr
+ i
, "linefile", 8) == 0)
227 char saved_eol_char
= ptr
->ptr
[ptr
->len
];
229 ptr
->ptr
[ptr
->len
] = '\0';
230 temp_ilp (ptr
->ptr
+ i
+ 8);
233 ptr
->ptr
[ptr
->len
] = saved_eol_char
;
234 ptr
->len
= line_start
;
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
);
244 /* Return 1 on success, 0 on unexpected EOF. */
248 /* Pick up a token. */
251 get_token (size_t idx
, sb
*in
, sb
*name
)
254 && is_name_beginner (in
->ptr
[idx
]))
256 sb_add_char (name
, in
->ptr
[idx
++]);
258 && is_part_of_name (in
->ptr
[idx
]))
260 sb_add_char (name
, in
->ptr
[idx
++]);
263 && is_name_ender (in
->ptr
[idx
]))
265 sb_add_char (name
, in
->ptr
[idx
++]);
268 /* Ignore trailing &. */
269 if (macro_alternate
&& idx
< in
->len
&& in
->ptr
[idx
] == '&')
274 /* Pick up a string. */
277 getstring (size_t idx
, sb
*in
, sb
*acc
)
280 && (in
->ptr
[idx
] == '"'
281 || (in
->ptr
[idx
] == '<' && (macro_alternate
|| macro_mri
))
282 || (in
->ptr
[idx
] == '\'' && macro_alternate
)))
284 if (in
->ptr
[idx
] == '<')
289 && (in
->ptr
[idx
] != '>' || nest
))
291 if (in
->ptr
[idx
] == '!')
294 sb_add_char (acc
, in
->ptr
[idx
++]);
298 if (in
->ptr
[idx
] == '>')
300 if (in
->ptr
[idx
] == '<')
302 sb_add_char (acc
, in
->ptr
[idx
++]);
307 else if (in
->ptr
[idx
] == '"' || in
->ptr
[idx
] == '\'')
309 char tchar
= in
->ptr
[idx
];
314 while (idx
< in
->len
)
316 if (in
->ptr
[idx
- 1] == '\\')
321 if (macro_alternate
&& in
->ptr
[idx
] == '!')
325 sb_add_char (acc
, in
->ptr
[idx
]);
329 else if (escaped
&& in
->ptr
[idx
] == tchar
)
331 sb_add_char (acc
, tchar
);
336 if (in
->ptr
[idx
] == tchar
)
340 if (idx
>= in
->len
|| in
->ptr
[idx
] != tchar
)
344 sb_add_char (acc
, in
->ptr
[idx
]);
354 /* Fetch string from the input stream,
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. */
363 get_any_string (size_t idx
, sb
*in
, sb
*out
)
366 idx
= sb_skip_white (idx
, in
);
370 if (in
->len
> idx
+ 2 && in
->ptr
[idx
+ 1] == '\'' && ISBASE (in
->ptr
[idx
]))
372 while (idx
< in
->len
&& !ISSEP (in
->ptr
[idx
]))
373 sb_add_char (out
, in
->ptr
[idx
++]);
375 else if (in
->ptr
[idx
] == '%' && macro_alternate
)
380 /* Turns the next expression into a string. */
381 /* xgettext: no-c-format */
382 idx
= (*macro_expr
) (_("% operator needs absolute expression"),
386 sprintf (buf
, "%" BFD_VMA_FMT
"d", val
);
387 sb_add_string (out
, buf
);
389 else if (in
->ptr
[idx
] == '"'
390 || (in
->ptr
[idx
] == '<' && (macro_alternate
|| macro_mri
))
391 || (macro_alternate
&& in
->ptr
[idx
] == '\''))
393 if (macro_alternate
&& ! macro_strip_at
&& in
->ptr
[idx
] != '<')
395 /* Keep the quotes. */
396 sb_add_char (out
, '"');
397 idx
= getstring (idx
, in
, out
);
398 sb_add_char (out
, '"');
402 idx
= getstring (idx
, in
, out
);
407 char *br_buf
= XNEWVEC (char, 1);
408 char *in_br
= br_buf
;
413 || (in
->ptr
[idx
] != ' '
414 && in
->ptr
[idx
] != '\t'))
415 && in
->ptr
[idx
] != ','
416 && (in
->ptr
[idx
] != '<'
417 || (! macro_alternate
&& ! macro_mri
)))
419 char tchar
= in
->ptr
[idx
];
425 sb_add_char (out
, in
->ptr
[idx
++]);
427 && in
->ptr
[idx
] != tchar
)
428 sb_add_char (out
, in
->ptr
[idx
++]);
441 br_buf
= XNEWVEC (char, strlen (in_br
) + 2);
442 strcpy (br_buf
+ 1, in_br
);
457 sb_add_char (out
, tchar
);
467 /* Allocate a new formal. */
469 static formal_entry
*
472 formal_entry
*formal
;
474 formal
= XNEW (formal_entry
);
476 sb_new (&formal
->name
);
477 sb_new (&formal
->def
);
478 sb_new (&formal
->actual
);
480 formal
->type
= FORMAL_OPTIONAL
;
487 del_formal (formal_entry
*formal
)
489 sb_kill (&formal
->actual
);
490 sb_kill (&formal
->def
);
491 sb_kill (&formal
->name
);
495 /* Pick up the formal parameters of a macro definition. */
498 do_formals (macro_entry
*macro
, size_t idx
, sb
*in
)
500 formal_entry
**p
= ¯o
->formals
;
503 idx
= sb_skip_white (idx
, in
);
504 while (idx
< in
->len
)
506 formal_entry
*formal
= new_formal ();
509 idx
= get_token (idx
, in
, &formal
->name
);
510 if (formal
->name
.len
== 0)
512 if (macro
->formal_count
)
514 del_formal (formal
); /* 'formal' goes out of scope. */
517 idx
= sb_skip_white (idx
, in
);
518 /* This is a formal. */
519 name
= sb_terminate (&formal
->name
);
522 && in
->ptr
[idx
] == ':'
523 && (! is_name_beginner (':')
524 || idx
+ 1 >= in
->len
525 || ! is_part_of_name (in
->ptr
[idx
+ 1])))
527 /* Got a qualifier. */
531 idx
= get_token (sb_skip_white (idx
+ 1, in
), in
, &qual
);
532 sb_terminate (&qual
);
534 as_bad_where (macro
->file
,
536 _("Missing parameter qualifier for `%s' in macro `%s'"),
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
;
544 as_bad_where (macro
->file
,
546 _("`%s' is not a valid parameter qualifier for `%s' in macro `%s'"),
551 idx
= sb_skip_white (idx
, in
);
553 if (idx
< in
->len
&& in
->ptr
[idx
] == '=')
556 idx
= get_any_string (idx
+ 1, in
, &formal
->def
);
557 idx
= sb_skip_white (idx
, in
);
558 if (formal
->type
== FORMAL_REQUIRED
)
560 sb_reset (&formal
->def
);
561 as_warn_where (macro
->file
,
563 _("Pointless default value for required parameter `%s' in macro `%s'"),
569 /* Add to macro's hash table. */
570 if (formal_entry_find (macro
->formal_hash
, name
) == NULL
)
571 htab_insert (macro
->formal_hash
, formal_entry_alloc (name
, formal
));
573 as_bad_where (macro
->file
,
575 _("A parameter named `%s' already exists for macro `%s'"),
579 formal
->index
= macro
->formal_count
++;
582 if (formal
->type
== FORMAL_VARARG
)
585 idx
= sb_skip_comma (idx
, in
);
586 if (idx
!= cidx
&& idx
>= in
->len
)
595 formal_entry
*formal
= new_formal ();
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. */
606 sb_add_string (&formal
->name
, name
);
608 /* Add to macro's hash table. */
609 if (formal_entry_find (macro
->formal_hash
, name
))
610 as_bad_where (macro
->file
,
612 _("Reserved word `%s' used as parameter in macro `%s'"),
615 htab_insert (macro
->formal_hash
, formal_entry_alloc (name
, formal
));
617 formal
->index
= NARG_INDEX
;
624 /* Free the memory allocated to a macro. */
627 free_macro (macro_entry
*macro
)
629 formal_entry
*formal
;
631 for (formal
= macro
->formals
; formal
; )
636 formal
= formal
->next
;
639 htab_delete (macro
->formal_hash
);
640 sb_kill (¯o
->sub
);
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. */
649 define_macro (size_t idx
, sb
*in
, sb
*label
,
650 size_t (*get_line
) (sb
*),
651 const char *file
, unsigned int line
,
656 const char *error
= NULL
;
658 macro
= XNEW (macro_entry
);
659 sb_new (¯o
->sub
);
664 macro
->formal_count
= 0;
666 macro
->formal_hash
= htab_create_alloc (7, hash_formal_entry
, eq_formal_entry
,
667 NULL
, xcalloc
, free
);
669 idx
= sb_skip_white (idx
, in
);
670 if (! buffer_and_nest ("MACRO", "ENDM", ¯o
->sub
, get_line
))
671 error
= _("unexpected end of file in macro `%s' definition");
672 if (label
!= NULL
&& label
->len
!= 0)
674 sb_add_sb (&name
, label
);
675 macro
->name
= sb_terminate (&name
);
676 if (idx
< in
->len
&& in
->ptr
[idx
] == '(')
678 /* It's the label: MACRO (formals,...) sort */
679 idx
= do_formals (macro
, idx
+ 1, in
);
680 if (idx
< in
->len
&& in
->ptr
[idx
] == ')')
681 idx
= sb_skip_white (idx
+ 1, in
);
683 error
= _("missing `)' after formals in macro definition `%s'");
687 /* It's the label: MACRO formals,... sort */
688 idx
= do_formals (macro
, idx
, in
);
695 idx
= get_token (idx
, in
, &name
);
696 macro
->name
= sb_terminate (&name
);
698 error
= _("Missing macro name");
699 cidx
= sb_skip_white (idx
, in
);
700 idx
= sb_skip_comma (cidx
, in
);
701 if (idx
== cidx
|| idx
< in
->len
)
702 idx
= do_formals (macro
, idx
, in
);
706 if (!error
&& idx
< in
->len
)
707 error
= _("Bad parameter list for macro `%s'");
709 /* And stick it in the macro hash table. */
710 for (idx
= 0; idx
< name
.len
; idx
++)
711 name
.ptr
[idx
] = TOLOWER (name
.ptr
[idx
]);
712 if (macro_entry_find (macro_hash
, macro
->name
))
713 error
= _("Macro `%s' was already defined");
715 htab_insert (macro_hash
, macro_entry_alloc (macro
->name
, macro
));
718 *namep
= macro
->name
;
728 /* Scan a token, and then skip KIND. */
731 get_apost_token (size_t idx
, sb
*in
, sb
*name
, int kind
)
733 idx
= get_token (idx
, in
, name
);
735 && in
->ptr
[idx
] == kind
736 && (! macro_mri
|| macro_strip_at
)
737 && (! macro_strip_at
|| kind
== '@'))
742 /* Substitute the actual value for a formal parameter. */
745 sub_actual (size_t start
, sb
*in
, sb
*t
, struct htab
*formal_hash
,
746 int kind
, sb
*out
, int copyifnotthere
)
751 src
= get_apost_token (start
, in
, t
, kind
);
752 /* See if it's in the macro's hash table, unless this is
753 macro_strip_at and kind is '@' and the token did not end in '@'. */
756 && (src
== start
|| in
->ptr
[src
- 1] != '@'))
759 ptr
= formal_entry_find (formal_hash
, sb_terminate (t
));
764 sb_add_sb (out
, &ptr
->actual
);
768 sb_add_sb (out
, &ptr
->def
);
771 else if (kind
== '&')
773 /* Doing this permits people to use & in macro bodies. */
774 sb_add_char (out
, '&');
776 if (src
!= start
&& in
->ptr
[src
- 1] == '&')
777 sb_add_char (out
, '&');
779 else if (copyifnotthere
)
785 sb_add_char (out
, '\\');
791 /* Expand the body of a macro. */
794 macro_expand_body (sb
*in
, sb
*out
, formal_entry
*formals
,
795 struct htab
*formal_hash
, const macro_entry
*macro
)
799 int inquote
= 0, macro_line
= 0;
800 formal_entry
*loclist
= NULL
;
801 const char *err
= NULL
;
805 while (src
< in
->len
&& !err
)
807 if (in
->ptr
[src
] == '&')
812 if (src
+ 1 < in
->len
&& in
->ptr
[src
+ 1] == '&')
813 src
= sub_actual (src
+ 2, in
, &t
, formal_hash
, '\'', out
, 1);
815 sb_add_char (out
, in
->ptr
[src
++]);
819 /* Permit macro parameter substitution delineated with
820 an '&' prefix and optional '&' suffix. */
821 src
= sub_actual (src
+ 1, in
, &t
, formal_hash
, '&', out
, 0);
824 else if (in
->ptr
[src
] == '\\')
827 if (src
< in
->len
&& in
->ptr
[src
] == '(')
829 /* Sub in till the next ')' literally. */
831 while (src
< in
->len
&& in
->ptr
[src
] != ')')
833 sb_add_char (out
, in
->ptr
[src
++]);
838 err
= _("missing `)'");
840 as_bad_where (macro
->file
, macro
->line
+ macro_line
, _("missing `)'"));
842 else if (src
< in
->len
&& in
->ptr
[src
] == '@')
844 /* Sub in the macro invocation number. */
848 sprintf (buffer
, "%d", macro_number
);
849 sb_add_string (out
, buffer
);
851 else if (src
< in
->len
&& in
->ptr
[src
] == '&')
853 /* This is a preprocessor variable name, we don't do them
855 sb_add_char (out
, '\\');
856 sb_add_char (out
, '&');
859 else if (macro_mri
&& src
< in
->len
&& ISALNUM (in
->ptr
[src
]))
864 if (ISDIGIT (in
->ptr
[src
]))
865 ind
= in
->ptr
[src
] - '0';
866 else if (ISUPPER (in
->ptr
[src
]))
867 ind
= in
->ptr
[src
] - 'A' + 10;
869 ind
= in
->ptr
[src
] - 'a' + 10;
871 for (f
= formals
; f
!= NULL
; f
= f
->next
)
873 if (f
->index
== ind
- 1)
875 if (f
->actual
.len
!= 0)
876 sb_add_sb (out
, &f
->actual
);
878 sb_add_sb (out
, &f
->def
);
886 src
= sub_actual (src
, in
, &t
, formal_hash
, '\'', out
, 0);
889 else if ((macro_alternate
|| macro_mri
)
890 && is_name_beginner (in
->ptr
[src
])
893 || (src
> 0 && in
->ptr
[src
- 1] == '@')))
896 || src
+ 5 >= in
->len
897 || strncasecmp (in
->ptr
+ src
, "LOCAL", 5) != 0
898 || ! ISWHITE (in
->ptr
[src
+ 5])
899 /* PR 11507: Skip keyword LOCAL if it is found inside a quoted string. */
903 src
= sub_actual (src
, in
, &t
, formal_hash
,
904 (macro_strip_at
&& inquote
) ? '@' : '\'',
909 src
= sb_skip_white (src
+ 5, in
);
910 while (in
->ptr
[src
] != '\n')
913 formal_entry
*f
= new_formal ();
915 src
= get_token (src
, in
, &f
->name
);
916 name
= sb_terminate (&f
->name
);
917 if (formal_entry_find (formal_hash
, name
) == NULL
)
922 f
->index
= LOCAL_INDEX
;
926 sprintf (buf
, IS_ELF
? ".LL%04x" : "LL%04x", ++loccnt
);
927 sb_add_string (&f
->actual
, buf
);
929 htab_insert (formal_hash
, formal_entry_alloc (name
, f
));
933 as_bad_where (macro
->file
,
934 macro
->line
+ macro_line
,
935 _("`%s' was already used as parameter (or another local) name"),
940 src
= sb_skip_comma (src
, in
);
944 else if (in
->ptr
[src
] == '"'
945 || (macro_mri
&& in
->ptr
[src
] == '\''))
948 sb_add_char (out
, in
->ptr
[src
++]);
950 else if (in
->ptr
[src
] == '@' && macro_strip_at
)
954 && in
->ptr
[src
] == '@')
956 sb_add_char (out
, '@');
961 && in
->ptr
[src
] == '='
963 && in
->ptr
[src
+ 1] == '=')
968 src
= get_token (src
+ 2, in
, &t
);
969 ptr
= formal_entry_find (formal_hash
, sb_terminate (&t
));
972 /* FIXME: We should really return a warning string here,
973 but we can't, because the == might be in the MRI
974 comment field, and, since the nature of the MRI
975 comment field depends upon the exact instruction
976 being used, we don't have enough information here to
977 figure out whether it is or not. Instead, we leave
978 the == in place, which should cause a syntax error if
979 it is not in a comment. */
980 sb_add_char (out
, '=');
981 sb_add_char (out
, '=');
988 sb_add_string (out
, "-1");
992 sb_add_char (out
, '0');
998 if (in
->ptr
[src
] == '\n')
1000 sb_add_char (out
, in
->ptr
[src
++]);
1006 while (loclist
!= NULL
)
1012 name
= sb_terminate (&loclist
->name
);
1013 formal_hash_entry_t needle
= { name
, NULL
};
1014 htab_remove_elt (formal_hash
, &needle
);
1015 del_formal (loclist
);
1022 /* Assign values to the formal parameters of a macro, and expand the
1026 macro_expand (size_t idx
, sb
*in
, macro_entry
*m
, sb
*out
)
1033 const char *err
= NULL
;
1037 /* Reset any old value the actuals may have. */
1038 for (f
= m
->formals
; f
; f
= f
->next
)
1039 sb_reset (&f
->actual
);
1041 while (f
!= NULL
&& f
->index
< 0)
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
] == '.')
1050 /* The Microtec assembler ignores this if followed by a white space.
1051 (Macro invocation with empty extension) */
1054 && in
->ptr
[idx
] != ' '
1055 && in
->ptr
[idx
] != '\t')
1057 formal_entry
*n
= new_formal ();
1059 n
->index
= QUAL_INDEX
;
1061 n
->next
= m
->formals
;
1064 idx
= get_any_string (idx
, in
, &n
->actual
);
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
)
1075 /* Look and see if it's a positional or keyword arg. */
1077 while (scan
< in
->len
1078 && !ISSEP (in
->ptr
[scan
])
1079 && !(macro_mri
&& in
->ptr
[scan
] == '\'')
1080 && (!macro_alternate
&& in
->ptr
[scan
] != '='))
1082 if (scan
< in
->len
&& !macro_alternate
&& in
->ptr
[scan
] == '=')
1086 /* It's OK to go from positional to keyword. */
1088 /* This is a keyword arg, fetch the formal name and
1089 then the actual stuff. */
1091 idx
= get_token (idx
, in
, &t
);
1092 if (in
->ptr
[idx
] != '=')
1094 err
= _("confusion in formal parameters");
1098 /* Lookup the formal in the macro's list. */
1099 ptr
= formal_entry_find (m
->formal_hash
, sb_terminate (&t
));
1102 as_bad (_("Parameter named `%s' does not exist for macro `%s'"),
1106 idx
= get_any_string (idx
+ 1, in
, &t
);
1110 /* Insert this value into the right place. */
1111 if (ptr
->actual
.len
)
1113 as_warn (_("Value for parameter `%s' of macro `%s' was already specified"),
1116 sb_reset (&ptr
->actual
);
1118 idx
= get_any_string (idx
+ 1, in
, &ptr
->actual
);
1119 if (ptr
->actual
.len
> 0)
1127 err
= _("can't mix positional and keyword arguments");
1138 err
= _("too many positional arguments");
1145 for (pf
= &m
->formals
; *pf
!= NULL
; pf
= &(*pf
)->next
)
1146 if ((*pf
)->index
>= c
)
1147 c
= (*pf
)->index
+ 1;
1154 if (f
->type
!= FORMAL_VARARG
)
1155 idx
= get_any_string (idx
, in
, &f
->actual
);
1158 sb_add_buffer (&f
->actual
, in
->ptr
+ idx
, in
->len
- idx
);
1161 if (f
->actual
.len
> 0)
1167 while (f
!= NULL
&& f
->index
< 0);
1171 idx
= sb_skip_comma (idx
, in
);
1174 if (in
->ptr
[idx
] == ',')
1176 if (ISWHITE (in
->ptr
[idx
]))
1183 for (ptr
= m
->formals
; ptr
; ptr
= ptr
->next
)
1185 if (ptr
->type
== FORMAL_REQUIRED
&& ptr
->actual
.len
== 0)
1186 as_bad (_("Missing value for required parameter `%s' of macro `%s'"),
1196 sb_add_string (&t
, macro_strip_at
? "$NARG" : "NARG");
1197 ptr
= formal_entry_find (m
->formal_hash
, sb_terminate (&t
));
1198 sprintf (buffer
, "%d", narg
);
1199 sb_add_string (&ptr
->actual
, buffer
);
1202 err
= macro_expand_body (&m
->sub
, out
, m
->formals
, m
->formal_hash
, m
);
1205 /* Discard any unnamed formal arguments. */
1213 if ((*pf
)->name
.len
!= 0)
1231 /* Check for a macro. If one is found, put the expansion into
1232 *EXPAND. Return 1 if a macro is found, 0 otherwise. */
1235 check_macro (const char *line
, sb
*expand
,
1236 const char **error
, macro_entry
**info
)
1243 if (! is_name_beginner (*line
)
1244 && (! macro_mri
|| *line
!= '.'))
1248 while (is_part_of_name (*s
))
1250 if (is_name_ender (*s
))
1253 copy
= xmemdup0 (line
, s
- line
);
1254 for (cls
= copy
; *cls
!= '\0'; cls
++)
1255 *cls
= TOLOWER (*cls
);
1257 macro
= macro_entry_find (macro_hash
, copy
);
1263 /* Wrap the line up in an sb. */
1265 while (*s
!= '\0' && *s
!= '\n' && *s
!= '\r')
1266 sb_add_char (&line_sb
, *s
++);
1269 *error
= macro_expand (0, &line_sb
, macro
, expand
);
1273 /* Export the macro information if requested. */
1280 /* Delete a macro. */
1283 delete_macro (const char *name
)
1289 len
= strlen (name
);
1290 copy
= XNEWVEC (char, len
+ 1);
1291 for (i
= 0; i
< len
; ++i
)
1292 copy
[i
] = TOLOWER (name
[i
]);
1295 /* We can only ask hash_delete to free memory if we are deleting
1296 macros in reverse order to their definition.
1297 So just clear out the entry. */
1298 macro
= macro_entry_find (macro_hash
, copy
);
1301 htab_insert (macro_hash
, macro_entry_alloc (copy
, NULL
));
1305 as_warn (_("Attempt to purge non-existing macro `%s'"), copy
);
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. */
1313 expand_irp (int irpc
, size_t idx
, sb
*in
, sb
*out
, size_t (*get_line
) (sb
*))
1318 const char *err
= NULL
;
1320 idx
= sb_skip_white (idx
, in
);
1323 if (! buffer_and_nest (NULL
, "ENDR", &sub
, get_line
))
1324 return _("unexpected end of file in irp or irpc");
1330 idx
= get_token (idx
, in
, &f
.name
);
1331 if (f
.name
.len
== 0)
1332 return _("missing model parameter");
1334 h
= htab_create_alloc (16, hash_formal_entry
, eq_formal_entry
,
1335 NULL
, xcalloc
, free
);
1337 htab_insert (h
, formal_entry_alloc (sb_terminate (&f
.name
), &f
));
1341 f
.type
= FORMAL_OPTIONAL
;
1345 idx
= sb_skip_comma (idx
, in
);
1348 /* Expand once with a null string. */
1349 err
= macro_expand_body (&sub
, out
, &f
, h
, 0);
1353 bfd_boolean in_quotes
= FALSE
;
1355 if (irpc
&& in
->ptr
[idx
] == '"')
1361 while (idx
< in
->len
)
1364 idx
= get_any_string (idx
, in
, &f
.actual
);
1367 if (in
->ptr
[idx
] == '"')
1372 in_quotes
= ! in_quotes
;
1374 nxt
= sb_skip_white (idx
+ 1, in
);
1381 sb_reset (&f
.actual
);
1382 sb_add_char (&f
.actual
, in
->ptr
[idx
]);
1386 err
= macro_expand_body (&sub
, out
, &f
, h
, 0);
1390 idx
= sb_skip_comma (idx
, in
);
1391 else if (! in_quotes
)
1392 idx
= sb_skip_white (idx
, in
);
1397 sb_kill (&f
.actual
);