1 /* macro.c - macro support for gas
2 Copyright (C) 1994-2022 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
);
129 /* Except for macros record the present source position, such that
130 diagnostics and debug info will be properly associated with the
131 respective original lines, rather than with the line of the ending
133 if (from
== NULL
|| strcasecmp (from
, "MACRO") != 0)
140 linefile
= xasprintf ("\t.linefile %u .\n", line
);
142 linefile
= xasprintf ("\tlinefile %u .\n", line
);
143 sb_add_buffer (ptr
, linefile
, strlen (linefile
));
149 /* Try to find the first pseudo op on the line. */
150 size_t i
= line_start
;
151 bool had_colon
= false;
153 /* With normal syntax we can suck what we want till we get
154 to the dot. With the alternate, labels have to start in
155 the first column, since we can't tell what's a label and
156 what's a pseudoop. */
158 if (! LABELS_WITHOUT_COLONS
)
160 /* Skip leading whitespace. */
161 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
167 /* Skip over a label, if any. */
168 if (i
>= ptr
->len
|| ! is_name_beginner (ptr
->ptr
[i
]))
171 while (i
< ptr
->len
&& is_part_of_name (ptr
->ptr
[i
]))
173 if (i
< ptr
->len
&& is_name_ender (ptr
->ptr
[i
]))
175 /* Skip whitespace. */
176 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
178 /* Check for the colon. */
179 if (i
>= ptr
->len
|| ptr
->ptr
[i
] != ':')
181 /* LABELS_WITHOUT_COLONS doesn't mean we cannot have a
182 colon after a label. If we do have a colon on the
183 first label then handle more than one label on the
184 line, assuming that each label has a colon. */
185 if (LABELS_WITHOUT_COLONS
&& !had_colon
)
195 /* Skip trailing whitespace. */
196 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
199 if (i
< ptr
->len
&& (ptr
->ptr
[i
] == '.'
203 if (! flag_m68k_mri
&& ptr
->ptr
[i
] == '.')
205 size_t len
= ptr
->len
- i
;
208 if (len
>= 5 && strncasecmp (ptr
->ptr
+ i
, "IREPC", 5) == 0)
210 else if (len
>= 4 && strncasecmp (ptr
->ptr
+ i
, "IREP", 4) == 0)
212 else if (len
>= 4 && strncasecmp (ptr
->ptr
+ i
, "IRPC", 4) == 0)
214 else if (len
>= 4 && strncasecmp (ptr
->ptr
+ i
, "REPT", 4) == 0)
216 else if (len
>= 3 && strncasecmp (ptr
->ptr
+ i
, "IRP", 3) == 0)
218 else if (len
>= 3 && strncasecmp (ptr
->ptr
+ i
, "REP", 3) == 0)
225 && strncasecmp (ptr
->ptr
+ i
, from
, from_len
) == 0)
228 || ! (is_part_of_name (ptr
->ptr
[i
+ from_len
])
229 || is_name_ender (ptr
->ptr
[i
+ from_len
]))))
232 && strncasecmp (ptr
->ptr
+ i
, to
, to_len
) == 0
234 || ! (is_part_of_name (ptr
->ptr
[i
+ to_len
])
235 || is_name_ender (ptr
->ptr
[i
+ to_len
]))))
240 /* Reset the string to not include the ending rune. */
241 ptr
->len
= line_start
;
247 Apply and discard .linefile directives that appear within
248 the macro. For long macros, one might want to report the
249 line number information associated with the lines within
250 the macro definition, but we would need more infrastructure
251 to make that happen correctly (e.g. resetting the line
252 number when expanding the macro), and since for short
253 macros we clearly prefer reporting the point of expansion
254 anyway, there's not an obviously better fix here. */
255 if (from
!= NULL
&& strcasecmp (from
, "MACRO") == 0
256 && len
>= 8 && strncasecmp (ptr
->ptr
+ i
, "linefile", 8) == 0)
258 char saved_eol_char
= ptr
->ptr
[ptr
->len
];
260 ptr
->ptr
[ptr
->len
] = '\0';
261 temp_ilp (ptr
->ptr
+ i
+ 8);
264 ptr
->ptr
[ptr
->len
] = saved_eol_char
;
265 ptr
->len
= line_start
;
269 /* Add the original end-of-line char to the end and keep running. */
270 sb_add_char (ptr
, more
);
271 line_start
= ptr
->len
;
272 more
= get_line (ptr
);
275 /* Return 1 on success, 0 on unexpected EOF. */
279 /* Pick up a token. */
282 get_token (size_t idx
, sb
*in
, sb
*name
)
285 && is_name_beginner (in
->ptr
[idx
]))
287 sb_add_char (name
, in
->ptr
[idx
++]);
289 && is_part_of_name (in
->ptr
[idx
]))
291 sb_add_char (name
, in
->ptr
[idx
++]);
294 && is_name_ender (in
->ptr
[idx
]))
296 sb_add_char (name
, in
->ptr
[idx
++]);
299 /* Ignore trailing &. */
300 if (macro_alternate
&& idx
< in
->len
&& in
->ptr
[idx
] == '&')
305 /* Pick up a string. */
308 getstring (size_t idx
, sb
*in
, sb
*acc
)
311 && (in
->ptr
[idx
] == '"'
312 || (in
->ptr
[idx
] == '<' && (macro_alternate
|| macro_mri
))
313 || (in
->ptr
[idx
] == '\'' && macro_alternate
)))
315 if (in
->ptr
[idx
] == '<')
320 && (in
->ptr
[idx
] != '>' || nest
))
322 if (in
->ptr
[idx
] == '!')
325 sb_add_char (acc
, in
->ptr
[idx
++]);
329 if (in
->ptr
[idx
] == '>')
331 if (in
->ptr
[idx
] == '<')
333 sb_add_char (acc
, in
->ptr
[idx
++]);
338 else if (in
->ptr
[idx
] == '"' || in
->ptr
[idx
] == '\'')
340 char tchar
= in
->ptr
[idx
];
345 while (idx
< in
->len
)
347 if (in
->ptr
[idx
- 1] == '\\')
352 if (macro_alternate
&& in
->ptr
[idx
] == '!')
356 sb_add_char (acc
, in
->ptr
[idx
]);
360 else if (escaped
&& in
->ptr
[idx
] == tchar
)
362 sb_add_char (acc
, tchar
);
367 if (in
->ptr
[idx
] == tchar
)
371 if (idx
>= in
->len
|| in
->ptr
[idx
] != tchar
)
375 sb_add_char (acc
, in
->ptr
[idx
]);
385 /* Fetch string from the input stream,
387 'Bxyx<whitespace> -> return 'Bxyza
388 %<expr> -> return string of decimal value of <expr>
389 "string" -> return string
390 (string) -> return (string-including-whitespaces)
391 xyx<whitespace> -> return xyz. */
394 get_any_string (size_t idx
, sb
*in
, sb
*out
)
397 idx
= sb_skip_white (idx
, in
);
401 if (in
->len
> idx
+ 2 && in
->ptr
[idx
+ 1] == '\'' && ISBASE (in
->ptr
[idx
]))
403 while (idx
< in
->len
&& !ISSEP (in
->ptr
[idx
]))
404 sb_add_char (out
, in
->ptr
[idx
++]);
406 else if (in
->ptr
[idx
] == '%' && macro_alternate
)
411 /* Turns the next expression into a string. */
412 /* xgettext: no-c-format */
413 idx
= (*macro_expr
) (_("% operator needs absolute expression"),
417 sprintf (buf
, "%" BFD_VMA_FMT
"d", val
);
418 sb_add_string (out
, buf
);
420 else if (in
->ptr
[idx
] == '"'
421 || (in
->ptr
[idx
] == '<' && (macro_alternate
|| macro_mri
))
422 || (macro_alternate
&& in
->ptr
[idx
] == '\''))
424 if (macro_alternate
&& ! macro_strip_at
&& in
->ptr
[idx
] != '<')
426 /* Keep the quotes. */
427 sb_add_char (out
, '"');
428 idx
= getstring (idx
, in
, out
);
429 sb_add_char (out
, '"');
433 idx
= getstring (idx
, in
, out
);
438 char *br_buf
= XNEWVEC (char, 1);
439 char *in_br
= br_buf
;
444 || (in
->ptr
[idx
] != ' '
445 && in
->ptr
[idx
] != '\t'))
446 && in
->ptr
[idx
] != ','
447 && (in
->ptr
[idx
] != '<'
448 || (! macro_alternate
&& ! macro_mri
)))
450 char tchar
= in
->ptr
[idx
];
456 sb_add_char (out
, in
->ptr
[idx
++]);
458 && in
->ptr
[idx
] != tchar
)
459 sb_add_char (out
, in
->ptr
[idx
++]);
472 br_buf
= XNEWVEC (char, strlen (in_br
) + 2);
473 strcpy (br_buf
+ 1, in_br
);
488 sb_add_char (out
, tchar
);
498 /* Allocate a new formal. */
500 static formal_entry
*
503 formal_entry
*formal
;
505 formal
= XNEW (formal_entry
);
507 sb_new (&formal
->name
);
508 sb_new (&formal
->def
);
509 sb_new (&formal
->actual
);
511 formal
->type
= FORMAL_OPTIONAL
;
518 del_formal (formal_entry
*formal
)
520 sb_kill (&formal
->actual
);
521 sb_kill (&formal
->def
);
522 sb_kill (&formal
->name
);
526 /* Pick up the formal parameters of a macro definition. */
529 do_formals (macro_entry
*macro
, size_t idx
, sb
*in
)
531 formal_entry
**p
= ¯o
->formals
;
534 idx
= sb_skip_white (idx
, in
);
535 while (idx
< in
->len
)
537 formal_entry
*formal
= new_formal ();
539 formal_hash_entry_t
*elt
;
541 idx
= get_token (idx
, in
, &formal
->name
);
542 if (formal
->name
.len
== 0)
544 if (macro
->formal_count
)
546 del_formal (formal
); /* 'formal' goes out of scope. */
549 idx
= sb_skip_white (idx
, in
);
550 /* This is a formal. */
551 name
= sb_terminate (&formal
->name
);
554 && in
->ptr
[idx
] == ':'
555 && (! is_name_beginner (':')
556 || idx
+ 1 >= in
->len
557 || ! is_part_of_name (in
->ptr
[idx
+ 1])))
559 /* Got a qualifier. */
563 idx
= get_token (sb_skip_white (idx
+ 1, in
), in
, &qual
);
564 sb_terminate (&qual
);
566 as_bad_where (macro
->file
,
568 _("Missing parameter qualifier for `%s' in macro `%s'"),
571 else if (strcmp (qual
.ptr
, "req") == 0)
572 formal
->type
= FORMAL_REQUIRED
;
573 else if (strcmp (qual
.ptr
, "vararg") == 0)
574 formal
->type
= FORMAL_VARARG
;
576 as_bad_where (macro
->file
,
578 _("`%s' is not a valid parameter qualifier for `%s' in macro `%s'"),
583 idx
= sb_skip_white (idx
, in
);
585 if (idx
< in
->len
&& in
->ptr
[idx
] == '=')
588 idx
= get_any_string (idx
+ 1, in
, &formal
->def
);
589 idx
= sb_skip_white (idx
, in
);
590 if (formal
->type
== FORMAL_REQUIRED
)
592 sb_reset (&formal
->def
);
593 as_warn_where (macro
->file
,
595 _("Pointless default value for required parameter `%s' in macro `%s'"),
601 /* Add to macro's hash table. */
602 elt
= formal_entry_alloc (name
, formal
);
603 if (htab_insert (macro
->formal_hash
, elt
, 0) != NULL
)
606 as_bad_where (macro
->file
, macro
->line
,
607 _("A parameter named `%s' "
608 "already exists for macro `%s'"),
612 formal
->index
= macro
->formal_count
++;
615 if (formal
->type
== FORMAL_VARARG
)
618 idx
= sb_skip_comma (idx
, in
);
619 if (idx
!= cidx
&& idx
>= in
->len
)
628 formal_entry
*formal
= new_formal ();
629 formal_hash_entry_t
*elt
;
631 /* Add a special NARG formal, which macro_expand will set to the
632 number of arguments. */
633 /* The same MRI assemblers which treat '@' characters also use
634 the name $NARG. At least until we find an exception. */
640 sb_add_string (&formal
->name
, name
);
642 /* Add to macro's hash table. */
643 elt
= formal_entry_alloc (name
, formal
);
644 if (htab_insert (macro
->formal_hash
, elt
, 0) != NULL
)
647 as_bad_where (macro
->file
, macro
->line
,
648 _("Reserved word `%s' used as parameter in macro `%s'"),
652 formal
->index
= NARG_INDEX
;
659 /* Free the memory allocated to a macro. */
662 free_macro (macro_entry
*macro
)
664 formal_entry
*formal
;
666 for (formal
= macro
->formals
; formal
; )
671 formal
= formal
->next
;
674 htab_delete (macro
->formal_hash
);
675 sb_kill (¯o
->sub
);
679 /* Define a new macro. Returns NULL on success, otherwise returns an
680 error message. If NAMEP is not NULL, *NAMEP is set to the name of
681 the macro which was defined. */
684 define_macro (size_t idx
, sb
*in
, sb
*label
,
685 size_t (*get_line
) (sb
*),
686 const char *file
, unsigned int line
,
691 const char *error
= NULL
;
693 macro
= XNEW (macro_entry
);
694 sb_new (¯o
->sub
);
699 macro
->formal_count
= 0;
701 macro
->formal_hash
= htab_create_alloc (7, hash_formal_entry
, eq_formal_entry
,
702 NULL
, xcalloc
, free
);
704 idx
= sb_skip_white (idx
, in
);
705 if (! buffer_and_nest ("MACRO", "ENDM", ¯o
->sub
, get_line
))
706 error
= _("unexpected end of file in macro `%s' definition");
707 if (label
!= NULL
&& label
->len
!= 0)
709 sb_add_sb (&name
, label
);
710 macro
->name
= sb_terminate (&name
);
711 if (idx
< in
->len
&& in
->ptr
[idx
] == '(')
713 /* It's the label: MACRO (formals,...) sort */
714 idx
= do_formals (macro
, idx
+ 1, in
);
715 if (idx
< in
->len
&& in
->ptr
[idx
] == ')')
716 idx
= sb_skip_white (idx
+ 1, in
);
718 error
= _("missing `)' after formals in macro definition `%s'");
722 /* It's the label: MACRO formals,... sort */
723 idx
= do_formals (macro
, idx
, in
);
730 idx
= get_token (idx
, in
, &name
);
731 macro
->name
= sb_terminate (&name
);
733 error
= _("Missing macro name");
734 cidx
= sb_skip_white (idx
, in
);
735 idx
= sb_skip_comma (cidx
, in
);
736 if (idx
== cidx
|| idx
< in
->len
)
737 idx
= do_formals (macro
, idx
, in
);
741 if (!error
&& idx
< in
->len
)
742 error
= _("Bad parameter list for macro `%s'");
744 /* And stick it in the macro hash table. */
745 for (idx
= 0; idx
< name
.len
; idx
++)
746 name
.ptr
[idx
] = TOLOWER (name
.ptr
[idx
]);
749 macro_hash_entry_t
*elt
= macro_entry_alloc (macro
->name
, macro
);
750 if (htab_insert (macro_hash
, elt
, 0) != NULL
)
753 error
= _("Macro `%s' was already defined");
758 *namep
= macro
->name
;
768 /* Scan a token, and then skip KIND. */
771 get_apost_token (size_t idx
, sb
*in
, sb
*name
, int kind
)
773 idx
= get_token (idx
, in
, name
);
775 && in
->ptr
[idx
] == kind
776 && (! macro_mri
|| macro_strip_at
)
777 && (! macro_strip_at
|| kind
== '@'))
782 /* Substitute the actual value for a formal parameter. */
785 sub_actual (size_t start
, sb
*in
, sb
*t
, struct htab
*formal_hash
,
786 int kind
, sb
*out
, int copyifnotthere
)
791 src
= get_apost_token (start
, in
, t
, kind
);
792 /* See if it's in the macro's hash table, unless this is
793 macro_strip_at and kind is '@' and the token did not end in '@'. */
796 && (src
== start
|| in
->ptr
[src
- 1] != '@'))
799 ptr
= formal_entry_find (formal_hash
, sb_terminate (t
));
804 sb_add_sb (out
, &ptr
->actual
);
808 sb_add_sb (out
, &ptr
->def
);
811 else if (kind
== '&')
813 /* Doing this permits people to use & in macro bodies. */
814 sb_add_char (out
, '&');
816 if (src
!= start
&& in
->ptr
[src
- 1] == '&')
817 sb_add_char (out
, '&');
819 else if (copyifnotthere
)
825 sb_add_char (out
, '\\');
831 /* Expand the body of a macro. */
834 macro_expand_body (sb
*in
, sb
*out
, formal_entry
*formals
,
835 struct htab
*formal_hash
, const macro_entry
*macro
)
839 int inquote
= 0, macro_line
= 0;
840 formal_entry
*loclist
= NULL
;
841 const char *err
= NULL
;
845 while (src
< in
->len
&& !err
)
847 if (in
->ptr
[src
] == '&')
852 if (src
+ 1 < in
->len
&& in
->ptr
[src
+ 1] == '&')
853 src
= sub_actual (src
+ 2, in
, &t
, formal_hash
, '\'', out
, 1);
855 sb_add_char (out
, in
->ptr
[src
++]);
859 /* Permit macro parameter substitution delineated with
860 an '&' prefix and optional '&' suffix. */
861 src
= sub_actual (src
+ 1, in
, &t
, formal_hash
, '&', out
, 0);
864 else if (in
->ptr
[src
] == '\\')
867 if (src
< in
->len
&& in
->ptr
[src
] == '(')
869 /* Sub in till the next ')' literally. */
871 while (src
< in
->len
&& in
->ptr
[src
] != ')')
873 sb_add_char (out
, in
->ptr
[src
++]);
878 err
= _("missing `)'");
880 as_bad_where (macro
->file
, macro
->line
+ macro_line
, _("missing `)'"));
882 else if (src
< in
->len
&& in
->ptr
[src
] == '@')
884 /* Sub in the macro invocation number. */
888 sprintf (buffer
, "%d", macro_number
);
889 sb_add_string (out
, buffer
);
891 else if (src
< in
->len
&& in
->ptr
[src
] == '&')
893 /* This is a preprocessor variable name, we don't do them
895 sb_add_char (out
, '\\');
896 sb_add_char (out
, '&');
899 else if (macro_mri
&& src
< in
->len
&& ISALNUM (in
->ptr
[src
]))
904 if (ISDIGIT (in
->ptr
[src
]))
905 ind
= in
->ptr
[src
] - '0';
906 else if (ISUPPER (in
->ptr
[src
]))
907 ind
= in
->ptr
[src
] - 'A' + 10;
909 ind
= in
->ptr
[src
] - 'a' + 10;
911 for (f
= formals
; f
!= NULL
; f
= f
->next
)
913 if (f
->index
== ind
- 1)
915 if (f
->actual
.len
!= 0)
916 sb_add_sb (out
, &f
->actual
);
918 sb_add_sb (out
, &f
->def
);
926 src
= sub_actual (src
, in
, &t
, formal_hash
, '\'', out
, 0);
929 else if ((macro_alternate
|| macro_mri
)
930 && is_name_beginner (in
->ptr
[src
])
933 || (src
> 0 && in
->ptr
[src
- 1] == '@')))
936 || src
+ 5 >= in
->len
937 || strncasecmp (in
->ptr
+ src
, "LOCAL", 5) != 0
938 || ! ISWHITE (in
->ptr
[src
+ 5])
939 /* PR 11507: Skip keyword LOCAL if it is found inside a quoted string. */
943 src
= sub_actual (src
, in
, &t
, formal_hash
,
944 (macro_strip_at
&& inquote
) ? '@' : '\'',
949 src
= sb_skip_white (src
+ 5, in
);
950 while (in
->ptr
[src
] != '\n')
953 formal_entry
*f
= new_formal ();
954 formal_hash_entry_t
*elt
;
956 src
= get_token (src
, in
, &f
->name
);
957 name
= sb_terminate (&f
->name
);
958 elt
= formal_entry_alloc (name
, f
);
959 if (htab_insert (formal_hash
, elt
, 0) != NULL
)
962 as_bad_where (macro
->file
, macro
->line
+ macro_line
,
963 _("`%s' was already used as parameter "
964 "(or another local) name"), name
);
972 f
->index
= LOCAL_INDEX
;
976 sprintf (buf
, IS_ELF
? ".LL%04x" : "LL%04x", ++loccnt
);
977 sb_add_string (&f
->actual
, buf
);
980 src
= sb_skip_comma (src
, in
);
984 else if (in
->ptr
[src
] == '"'
985 || (macro_mri
&& in
->ptr
[src
] == '\''))
988 sb_add_char (out
, in
->ptr
[src
++]);
990 else if (in
->ptr
[src
] == '@' && macro_strip_at
)
994 && in
->ptr
[src
] == '@')
996 sb_add_char (out
, '@');
1001 && in
->ptr
[src
] == '='
1002 && src
+ 1 < in
->len
1003 && in
->ptr
[src
+ 1] == '=')
1008 src
= get_token (src
+ 2, in
, &t
);
1009 ptr
= formal_entry_find (formal_hash
, sb_terminate (&t
));
1012 /* FIXME: We should really return a warning string here,
1013 but we can't, because the == might be in the MRI
1014 comment field, and, since the nature of the MRI
1015 comment field depends upon the exact instruction
1016 being used, we don't have enough information here to
1017 figure out whether it is or not. Instead, we leave
1018 the == in place, which should cause a syntax error if
1019 it is not in a comment. */
1020 sb_add_char (out
, '=');
1021 sb_add_char (out
, '=');
1022 sb_add_sb (out
, &t
);
1026 if (ptr
->actual
.len
)
1028 sb_add_string (out
, "-1");
1032 sb_add_char (out
, '0');
1038 if (in
->ptr
[src
] == '\n')
1040 sb_add_char (out
, in
->ptr
[src
++]);
1046 while (loclist
!= NULL
)
1052 name
= sb_terminate (&loclist
->name
);
1053 formal_hash_entry_t needle
= { name
, NULL
};
1054 htab_remove_elt (formal_hash
, &needle
);
1055 del_formal (loclist
);
1062 /* Assign values to the formal parameters of a macro, and expand the
1066 macro_expand (size_t idx
, sb
*in
, macro_entry
*m
, sb
*out
)
1073 const char *err
= NULL
;
1077 /* Reset any old value the actuals may have. */
1078 for (f
= m
->formals
; f
; f
= f
->next
)
1079 sb_reset (&f
->actual
);
1081 while (f
!= NULL
&& f
->index
< 0)
1086 /* The macro may be called with an optional qualifier, which may
1087 be referred to in the macro body as \0. */
1088 if (idx
< in
->len
&& in
->ptr
[idx
] == '.')
1090 /* The Microtec assembler ignores this if followed by a white space.
1091 (Macro invocation with empty extension) */
1094 && in
->ptr
[idx
] != ' '
1095 && in
->ptr
[idx
] != '\t')
1097 formal_entry
*n
= new_formal ();
1099 n
->index
= QUAL_INDEX
;
1101 n
->next
= m
->formals
;
1104 idx
= get_any_string (idx
, in
, &n
->actual
);
1109 /* Peel off the actuals and store them away in the hash tables' actuals. */
1110 idx
= sb_skip_white (idx
, in
);
1111 while (idx
< in
->len
)
1115 /* Look and see if it's a positional or keyword arg. */
1117 while (scan
< in
->len
1118 && !ISSEP (in
->ptr
[scan
])
1119 && !(macro_mri
&& in
->ptr
[scan
] == '\'')
1120 && (!macro_alternate
&& in
->ptr
[scan
] != '='))
1122 if (scan
< in
->len
&& !macro_alternate
&& in
->ptr
[scan
] == '=')
1126 /* It's OK to go from positional to keyword. */
1128 /* This is a keyword arg, fetch the formal name and
1129 then the actual stuff. */
1131 idx
= get_token (idx
, in
, &t
);
1132 if (in
->ptr
[idx
] != '=')
1134 err
= _("confusion in formal parameters");
1138 /* Lookup the formal in the macro's list. */
1139 ptr
= formal_entry_find (m
->formal_hash
, sb_terminate (&t
));
1142 as_bad (_("Parameter named `%s' does not exist for macro `%s'"),
1146 idx
= get_any_string (idx
+ 1, in
, &t
);
1150 /* Insert this value into the right place. */
1151 if (ptr
->actual
.len
)
1153 as_warn (_("Value for parameter `%s' of macro `%s' was already specified"),
1156 sb_reset (&ptr
->actual
);
1158 idx
= get_any_string (idx
+ 1, in
, &ptr
->actual
);
1159 if (ptr
->actual
.len
> 0)
1167 err
= _("can't mix positional and keyword arguments");
1178 err
= _("too many positional arguments");
1185 for (pf
= &m
->formals
; *pf
!= NULL
; pf
= &(*pf
)->next
)
1186 if ((*pf
)->index
>= c
)
1187 c
= (*pf
)->index
+ 1;
1194 if (f
->type
!= FORMAL_VARARG
)
1195 idx
= get_any_string (idx
, in
, &f
->actual
);
1198 sb_add_buffer (&f
->actual
, in
->ptr
+ idx
, in
->len
- idx
);
1201 if (f
->actual
.len
> 0)
1207 while (f
!= NULL
&& f
->index
< 0);
1211 idx
= sb_skip_comma (idx
, in
);
1214 if (in
->ptr
[idx
] == ',')
1216 if (ISWHITE (in
->ptr
[idx
]))
1223 for (ptr
= m
->formals
; ptr
; ptr
= ptr
->next
)
1225 if (ptr
->type
== FORMAL_REQUIRED
&& ptr
->actual
.len
== 0)
1226 as_bad (_("Missing value for required parameter `%s' of macro `%s'"),
1236 sb_add_string (&t
, macro_strip_at
? "$NARG" : "NARG");
1237 ptr
= formal_entry_find (m
->formal_hash
, sb_terminate (&t
));
1238 sprintf (buffer
, "%d", narg
);
1239 sb_add_string (&ptr
->actual
, buffer
);
1242 err
= macro_expand_body (&m
->sub
, out
, m
->formals
, m
->formal_hash
, m
);
1245 /* Discard any unnamed formal arguments. */
1253 if ((*pf
)->name
.len
!= 0)
1271 /* Check for a macro. If one is found, put the expansion into
1272 *EXPAND. Return 1 if a macro is found, 0 otherwise. */
1275 check_macro (const char *line
, sb
*expand
,
1276 const char **error
, macro_entry
**info
)
1283 if (! is_name_beginner (*line
)
1284 && (! macro_mri
|| *line
!= '.'))
1288 while (is_part_of_name (*s
))
1290 if (is_name_ender (*s
))
1293 copy
= xmemdup0 (line
, s
- line
);
1294 for (cls
= copy
; *cls
!= '\0'; cls
++)
1295 *cls
= TOLOWER (*cls
);
1297 macro
= macro_entry_find (macro_hash
, copy
);
1303 /* Wrap the line up in an sb. */
1305 while (*s
!= '\0' && *s
!= '\n' && *s
!= '\r')
1306 sb_add_char (&line_sb
, *s
++);
1309 *error
= macro_expand (0, &line_sb
, macro
, expand
);
1313 /* Export the macro information if requested. */
1320 /* Delete a macro. */
1323 delete_macro (const char *name
)
1328 macro_hash_entry_t needle
;
1330 len
= strlen (name
);
1331 copy
= XNEWVEC (char, len
+ 1);
1332 for (i
= 0; i
< len
; ++i
)
1333 copy
[i
] = TOLOWER (name
[i
]);
1337 needle
.macro
= NULL
;
1338 slot
= htab_find_slot (macro_hash
, &needle
, NO_INSERT
);
1341 free_macro (((macro_hash_entry_t
*) *slot
)->macro
);
1342 htab_clear_slot (macro_hash
, slot
);
1345 as_warn (_("Attempt to purge non-existing macro `%s'"), copy
);
1349 /* Handle the MRI IRP and IRPC pseudo-ops. These are handled as a
1350 combined macro definition and execution. This returns NULL on
1351 success, or an error message otherwise. */
1354 expand_irp (int irpc
, size_t idx
, sb
*in
, sb
*out
, size_t (*get_line
) (sb
*))
1359 const char *err
= NULL
;
1361 idx
= sb_skip_white (idx
, in
);
1364 if (! buffer_and_nest (NULL
, "ENDR", &sub
, get_line
))
1365 return _("unexpected end of file in irp or irpc");
1371 idx
= get_token (idx
, in
, &f
.name
);
1372 if (f
.name
.len
== 0)
1373 return _("missing model parameter");
1375 h
= htab_create_alloc (16, hash_formal_entry
, eq_formal_entry
,
1376 NULL
, xcalloc
, free
);
1378 htab_insert (h
, formal_entry_alloc (sb_terminate (&f
.name
), &f
), 0);
1382 f
.type
= FORMAL_OPTIONAL
;
1386 idx
= sb_skip_comma (idx
, in
);
1389 /* Expand once with a null string. */
1390 err
= macro_expand_body (&sub
, out
, &f
, h
, 0);
1394 bool in_quotes
= false;
1396 if (irpc
&& in
->ptr
[idx
] == '"')
1402 while (idx
< in
->len
)
1405 idx
= get_any_string (idx
, in
, &f
.actual
);
1408 if (in
->ptr
[idx
] == '"')
1413 in_quotes
= ! in_quotes
;
1415 nxt
= sb_skip_white (idx
+ 1, in
);
1422 sb_reset (&f
.actual
);
1423 sb_add_char (&f
.actual
, in
->ptr
[idx
]);
1427 err
= macro_expand_body (&sub
, out
, &f
, h
, 0);
1431 idx
= sb_skip_comma (idx
, in
);
1432 else if (! in_quotes
)
1433 idx
= sb_skip_white (idx
, in
);
1438 sb_kill (&f
.actual
);