1 /* macro.c - macro support for gas
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005 Free Software Foundation, Inc.
5 Written by Steve and Judy Chamberlain of Cygnus Support,
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 2, or (at your option)
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
32 /* Indented so that pre-ansi C compilers will ignore it, rather than
33 choke on it. Some versions of AIX require this to be the first
37 # ifndef alloca /* predefined by HP cc +Olibcalls */
38 # if !defined (__STDC__) && !defined (__hpux)
39 extern char *alloca ();
41 extern void *alloca ();
42 # endif /* __STDC__, __hpux */
45 # endif /* HAVE_ALLOCA_H */
58 #include "libiberty.h"
59 #include "safe-ctype.h"
66 /* The routines in this file handle macro definition and expansion.
67 They are called by gas. */
69 /* Internal functions. */
71 static int get_token (int, sb
*, sb
*);
72 static int getstring (int, sb
*, sb
*);
73 static int get_any_string (int, sb
*, sb
*, int, int);
74 static formal_entry
*new_formal (void);
75 static void del_formal (formal_entry
*);
76 static int do_formals (macro_entry
*, int, sb
*);
77 static int get_apost_token (int, sb
*, sb
*, int);
78 static int sub_actual (int, sb
*, sb
*, struct hash_control
*, int, sb
*, int);
79 static const char *macro_expand_body
80 (sb
*, sb
*, formal_entry
*, struct hash_control
*, const macro_entry
*);
81 static const char *macro_expand (int, sb
*, macro_entry
*, sb
*);
82 static void free_macro(macro_entry
*);
84 #define ISWHITE(x) ((x) == ' ' || (x) == '\t')
87 ((x) == ' ' || (x) == '\t' || (x) == ',' || (x) == '"' || (x) == ';' \
88 || (x) == ')' || (x) == '(' \
89 || ((macro_alternate || macro_mri) && ((x) == '<' || (x) == '>')))
92 ((x) == 'b' || (x) == 'B' \
93 || (x) == 'q' || (x) == 'Q' \
94 || (x) == 'h' || (x) == 'H' \
95 || (x) == 'd' || (x) == 'D')
97 /* The macro hash table. */
99 struct hash_control
*macro_hash
;
101 /* Whether any macros have been defined. */
105 /* Whether we are in alternate syntax mode. */
107 static int macro_alternate
;
109 /* Whether we are in MRI mode. */
111 static int macro_mri
;
113 /* Whether we should strip '@' characters. */
115 static int macro_strip_at
;
117 /* Function to use to parse an expression. */
119 static int (*macro_expr
) (const char *, int, sb
*, int *);
121 /* Number of macro expansions that have been done. */
123 static int macro_number
;
125 /* Initialize macro processing. */
128 macro_init (int alternate
, int mri
, int strip_at
,
129 int (*expr
) (const char *, int, sb
*, int *))
131 macro_hash
= hash_new ();
133 macro_alternate
= alternate
;
135 macro_strip_at
= strip_at
;
139 /* Switch in and out of alternate mode on the fly. */
142 macro_set_alternate (int alternate
)
144 macro_alternate
= alternate
;
147 /* Switch in and out of MRI mode on the fly. */
150 macro_mri_mode (int mri
)
155 /* Read input lines till we get to a TO string.
156 Increase nesting depth if we get a FROM string.
157 Put the results into sb at PTR.
158 FROM may be NULL (or will be ignored) if TO is "ENDR".
159 Add a new input line to an sb using GET_LINE.
160 Return 1 on success, 0 on unexpected EOF. */
163 buffer_and_nest (const char *from
, const char *to
, sb
*ptr
,
164 int (*get_line
) (sb
*))
167 int to_len
= strlen (to
);
169 int line_start
= ptr
->len
;
171 int more
= get_line (ptr
);
173 if (to_len
== 4 && strcasecmp(to
, "ENDR") == 0)
179 from_len
= strlen (from
);
183 /* Try and find the first pseudo op on the line. */
186 if (! NO_PSEUDO_DOT
&& ! flag_m68k_mri
)
188 /* With normal syntax we can suck what we want till we get
189 to the dot. With the alternate, labels have to start in
190 the first column, since we can't tell what's a label and
193 if (! LABELS_WITHOUT_COLONS
)
195 /* Skip leading whitespace. */
196 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
202 /* Skip over a label, if any. */
203 if (i
>= ptr
->len
|| ! is_name_beginner (ptr
->ptr
[i
]))
206 while (i
< ptr
->len
&& is_part_of_name (ptr
->ptr
[i
]))
208 if (i
< ptr
->len
&& is_name_ender (ptr
->ptr
[i
]))
210 if (LABELS_WITHOUT_COLONS
)
212 /* Skip whitespace. */
213 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
215 /* Check for the colon. */
216 if (i
>= ptr
->len
|| ptr
->ptr
[i
] != ':')
226 /* Skip trailing whitespace. */
227 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
230 if (i
< ptr
->len
&& (ptr
->ptr
[i
] == '.'
234 if (! flag_m68k_mri
&& ptr
->ptr
[i
] == '.')
237 && strncasecmp (ptr
->ptr
+ i
, "IRPC", from_len
= 4) != 0
238 && strncasecmp (ptr
->ptr
+ i
, "IRP", from_len
= 3) != 0
239 && strncasecmp (ptr
->ptr
+ i
, "IREPC", from_len
= 5) != 0
240 && strncasecmp (ptr
->ptr
+ i
, "IREP", from_len
= 4) != 0
241 && strncasecmp (ptr
->ptr
+ i
, "REPT", from_len
= 4) != 0
242 && strncasecmp (ptr
->ptr
+ i
, "REP", from_len
= 3) != 0)
245 ? strncasecmp (ptr
->ptr
+ i
, from
, from_len
) == 0
247 && (ptr
->len
== (i
+ from_len
)
248 || ! (is_part_of_name (ptr
->ptr
[i
+ from_len
])
249 || is_name_ender (ptr
->ptr
[i
+ from_len
]))))
251 if (strncasecmp (ptr
->ptr
+ i
, to
, to_len
) == 0
252 && (ptr
->len
== (i
+ to_len
)
253 || ! (is_part_of_name (ptr
->ptr
[i
+ to_len
])
254 || is_name_ender (ptr
->ptr
[i
+ to_len
]))))
259 /* Reset the string to not include the ending rune. */
260 ptr
->len
= line_start
;
266 /* Add the original end-of-line char to the end and keep running. */
267 sb_add_char (ptr
, more
);
268 line_start
= ptr
->len
;
269 more
= get_line (ptr
);
272 /* Return 1 on success, 0 on unexpected EOF. */
276 /* Pick up a token. */
279 get_token (int idx
, sb
*in
, sb
*name
)
282 && is_name_beginner (in
->ptr
[idx
]))
284 sb_add_char (name
, in
->ptr
[idx
++]);
286 && is_part_of_name (in
->ptr
[idx
]))
288 sb_add_char (name
, in
->ptr
[idx
++]);
291 && is_name_ender (in
->ptr
[idx
]))
293 sb_add_char (name
, in
->ptr
[idx
++]);
296 /* Ignore trailing &. */
297 if (macro_alternate
&& idx
< in
->len
&& in
->ptr
[idx
] == '&')
302 /* Pick up a string. */
305 getstring (int idx
, sb
*in
, sb
*acc
)
307 idx
= sb_skip_white (idx
, in
);
310 && (in
->ptr
[idx
] == '"'
311 || (in
->ptr
[idx
] == '<' && (macro_alternate
|| macro_mri
))
312 || (in
->ptr
[idx
] == '\'' && macro_alternate
)))
314 if (in
->ptr
[idx
] == '<')
318 while ((in
->ptr
[idx
] != '>' || nest
)
321 if (in
->ptr
[idx
] == '!')
324 sb_add_char (acc
, in
->ptr
[idx
++]);
328 if (in
->ptr
[idx
] == '>')
330 if (in
->ptr
[idx
] == '<')
332 sb_add_char (acc
, in
->ptr
[idx
++]);
337 else if (in
->ptr
[idx
] == '"' || in
->ptr
[idx
] == '\'')
339 char tchar
= in
->ptr
[idx
];
344 while (idx
< in
->len
)
346 if (in
->ptr
[idx
- 1] == '\\')
351 if (macro_alternate
&& in
->ptr
[idx
] == '!')
355 sb_add_char (acc
, in
->ptr
[idx
]);
359 else if (escaped
&& in
->ptr
[idx
] == tchar
)
361 sb_add_char (acc
, tchar
);
366 if (in
->ptr
[idx
] == tchar
)
370 if (idx
>= in
->len
|| in
->ptr
[idx
] != tchar
)
374 sb_add_char (acc
, in
->ptr
[idx
]);
384 /* Fetch string from the input stream,
386 'Bxyx<whitespace> -> return 'Bxyza
387 %<char> -> return string of decimal value of x
388 "<string>" -> return string
389 xyx<whitespace> -> return xyz
393 get_any_string (int idx
, sb
*in
, sb
*out
, int expand
, int pretend_quoted
)
396 idx
= sb_skip_white (idx
, in
);
400 if (in
->len
> idx
+ 2 && in
->ptr
[idx
+ 1] == '\'' && ISBASE (in
->ptr
[idx
]))
402 while (!ISSEP (in
->ptr
[idx
]))
403 sb_add_char (out
, in
->ptr
[idx
++]);
405 else if (in
->ptr
[idx
] == '%'
411 /* Turns the next expression into a string. */
412 /* xgettext: no-c-format */
413 idx
= (*macro_expr
) (_("% operator needs absolute expression"),
417 sprintf (buf
, "%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
] == '\''))
428 /* Keep the quotes. */
429 sb_add_char (out
, '\"');
431 idx
= getstring (idx
, in
, out
);
432 sb_add_char (out
, '\"');
436 idx
= getstring (idx
, in
, out
);
442 && (in
->ptr
[idx
] == '"'
443 || in
->ptr
[idx
] == '\''
445 || (in
->ptr
[idx
] != ' '
446 && in
->ptr
[idx
] != '\t'
447 && in
->ptr
[idx
] != ','
448 && (in
->ptr
[idx
] != '<'
449 || (! macro_alternate
&& ! macro_mri
)))))
451 if (in
->ptr
[idx
] == '"'
452 || in
->ptr
[idx
] == '\'')
454 char tchar
= in
->ptr
[idx
];
455 sb_add_char (out
, in
->ptr
[idx
++]);
457 && in
->ptr
[idx
] != tchar
)
458 sb_add_char (out
, in
->ptr
[idx
++]);
462 sb_add_char (out
, in
->ptr
[idx
++]);
470 /* Allocate a new formal. */
472 static formal_entry
*
475 formal_entry
*formal
;
477 formal
= xmalloc (sizeof (formal_entry
));
479 sb_new (&formal
->name
);
480 sb_new (&formal
->def
);
481 sb_new (&formal
->actual
);
483 formal
->type
= FORMAL_OPTIONAL
;
490 del_formal (formal_entry
*formal
)
492 sb_kill (&formal
->actual
);
493 sb_kill (&formal
->def
);
494 sb_kill (&formal
->name
);
498 /* Pick up the formal parameters of a macro definition. */
501 do_formals (macro_entry
*macro
, int idx
, sb
*in
)
503 formal_entry
**p
= ¯o
->formals
;
506 idx
= sb_skip_white (idx
, in
);
507 while (idx
< in
->len
)
509 formal_entry
*formal
= new_formal ();
512 idx
= get_token (idx
, in
, &formal
->name
);
513 if (formal
->name
.len
== 0)
515 if (macro
->formal_count
)
519 idx
= sb_skip_white (idx
, in
);
520 /* This is a formal. */
521 name
= sb_terminate (&formal
->name
);
524 && in
->ptr
[idx
] == ':'
525 && (! is_name_beginner (':')
526 || idx
+ 1 >= in
->len
527 || ! is_part_of_name (in
->ptr
[idx
+ 1])))
529 /* Got a qualifier. */
533 idx
= get_token (sb_skip_white (idx
+ 1, in
), in
, &qual
);
534 sb_terminate (&qual
);
536 as_bad_where (macro
->file
,
538 _("Missing parameter qualifier for `%s' in macro `%s'"),
541 else if (strcmp (qual
.ptr
, "req") == 0)
542 formal
->type
= FORMAL_REQUIRED
;
543 else if (strcmp (qual
.ptr
, "vararg") == 0)
544 formal
->type
= FORMAL_VARARG
;
546 as_bad_where (macro
->file
,
548 _("`%s' is not a valid parameter qualifier for `%s' in macro `%s'"),
553 idx
= sb_skip_white (idx
, in
);
555 if (idx
< in
->len
&& in
->ptr
[idx
] == '=')
558 idx
= get_any_string (idx
+ 1, in
, &formal
->def
, 1, 0);
559 idx
= sb_skip_white (idx
, in
);
560 if (formal
->type
== FORMAL_REQUIRED
)
562 sb_reset (&formal
->def
);
563 as_warn_where (macro
->file
,
565 _("Pointless default value for required parameter `%s' in macro `%s'"),
571 /* Add to macro's hash table. */
572 if (! hash_find (macro
->formal_hash
, name
))
573 hash_jam (macro
->formal_hash
, name
, formal
);
575 as_bad_where (macro
->file
,
577 _("A parameter named `%s' already exists for macro `%s'"),
581 formal
->index
= macro
->formal_count
++;
584 if (formal
->type
== FORMAL_VARARG
)
587 idx
= sb_skip_comma (idx
, in
);
588 if (idx
!= cidx
&& idx
>= in
->len
)
597 formal_entry
*formal
= new_formal ();
599 /* Add a special NARG formal, which macro_expand will set to the
600 number of arguments. */
601 /* The same MRI assemblers which treat '@' characters also use
602 the name $NARG. At least until we find an exception. */
608 sb_add_string (&formal
->name
, name
);
610 /* Add to macro's hash table. */
611 if (hash_find (macro
->formal_hash
, name
))
612 as_bad_where (macro
->file
,
614 _("Reserved word `%s' used as parameter in macro `%s'"),
617 hash_jam (macro
->formal_hash
, name
, formal
);
619 formal
->index
= NARG_INDEX
;
626 /* Define a new macro. Returns NULL on success, otherwise returns an
627 error message. If NAMEP is not NULL, *NAMEP is set to the name of
628 the macro which was defined. */
631 define_macro (int idx
, sb
*in
, sb
*label
,
632 int (*get_line
) (sb
*),
633 char *file
, unsigned int line
,
638 const char *error
= NULL
;
640 macro
= (macro_entry
*) xmalloc (sizeof (macro_entry
));
641 sb_new (¯o
->sub
);
646 macro
->formal_count
= 0;
648 macro
->formal_hash
= hash_new ();
650 idx
= sb_skip_white (idx
, in
);
651 if (! buffer_and_nest ("MACRO", "ENDM", ¯o
->sub
, get_line
))
652 error
= _("unexpected end of file in macro `%s' definition");
653 if (label
!= NULL
&& label
->len
!= 0)
655 sb_add_sb (&name
, label
);
656 macro
->name
= sb_terminate (&name
);
657 if (idx
< in
->len
&& in
->ptr
[idx
] == '(')
659 /* It's the label: MACRO (formals,...) sort */
660 idx
= do_formals (macro
, idx
+ 1, in
);
661 if (idx
< in
->len
&& in
->ptr
[idx
] == ')')
662 idx
= sb_skip_white (idx
+ 1, in
);
664 error
= _("missing `)' after formals in macro definition `%s'");
668 /* It's the label: MACRO formals,... sort */
669 idx
= do_formals (macro
, idx
, in
);
676 idx
= get_token (idx
, in
, &name
);
677 macro
->name
= sb_terminate (&name
);
679 error
= _("Missing macro name");
680 cidx
= sb_skip_white (idx
, in
);
681 idx
= sb_skip_comma (cidx
, in
);
682 if (idx
== cidx
|| idx
< in
->len
)
683 idx
= do_formals (macro
, idx
, in
);
687 if (!error
&& idx
< in
->len
)
688 error
= _("Bad parameter list for macro `%s'");
690 /* And stick it in the macro hash table. */
691 for (idx
= 0; idx
< name
.len
; idx
++)
692 name
.ptr
[idx
] = TOLOWER (name
.ptr
[idx
]);
693 if (hash_find (macro_hash
, macro
->name
))
694 error
= _("Macro `%s' was already defined");
696 error
= hash_jam (macro_hash
, macro
->name
, (PTR
) macro
);
699 *namep
= macro
->name
;
709 /* Scan a token, and then skip KIND. */
712 get_apost_token (int idx
, sb
*in
, sb
*name
, int kind
)
714 idx
= get_token (idx
, in
, name
);
716 && in
->ptr
[idx
] == kind
717 && (! macro_mri
|| macro_strip_at
)
718 && (! macro_strip_at
|| kind
== '@'))
723 /* Substitute the actual value for a formal parameter. */
726 sub_actual (int start
, sb
*in
, sb
*t
, struct hash_control
*formal_hash
,
727 int kind
, sb
*out
, int copyifnotthere
)
732 src
= get_apost_token (start
, in
, t
, kind
);
733 /* See if it's in the macro's hash table, unless this is
734 macro_strip_at and kind is '@' and the token did not end in '@'. */
737 && (src
== start
|| in
->ptr
[src
- 1] != '@'))
740 ptr
= (formal_entry
*) hash_find (formal_hash
, sb_terminate (t
));
745 sb_add_sb (out
, &ptr
->actual
);
749 sb_add_sb (out
, &ptr
->def
);
752 else if (kind
== '&')
754 /* Doing this permits people to use & in macro bodies. */
755 sb_add_char (out
, '&');
758 else if (copyifnotthere
)
764 sb_add_char (out
, '\\');
770 /* Expand the body of a macro. */
773 macro_expand_body (sb
*in
, sb
*out
, formal_entry
*formals
,
774 struct hash_control
*formal_hash
, const macro_entry
*macro
)
777 int src
= 0, inquote
= 0, macro_line
= 0;
778 formal_entry
*loclist
= NULL
;
779 const char *err
= NULL
;
783 while (src
< in
->len
&& !err
)
785 if (in
->ptr
[src
] == '&')
790 if (src
+ 1 < in
->len
&& in
->ptr
[src
+ 1] == '&')
791 src
= sub_actual (src
+ 2, in
, &t
, formal_hash
, '\'', out
, 1);
793 sb_add_char (out
, in
->ptr
[src
++]);
797 /* FIXME: Why do we do this? */
798 /* At least in alternate mode this seems correct; without this
799 one can't append a literal to a parameter. */
800 src
= sub_actual (src
+ 1, in
, &t
, formal_hash
, '&', out
, 0);
803 else if (in
->ptr
[src
] == '\\')
806 if (src
< in
->len
&& in
->ptr
[src
] == '(')
808 /* Sub in till the next ')' literally. */
810 while (src
< in
->len
&& in
->ptr
[src
] != ')')
812 sb_add_char (out
, in
->ptr
[src
++]);
817 err
= _("missing `)'");
819 as_bad_where (macro
->file
, macro
->line
+ macro_line
, _("missing `)'"));
821 else if (src
< in
->len
&& in
->ptr
[src
] == '@')
823 /* Sub in the macro invocation number. */
827 sprintf (buffer
, "%d", macro_number
);
828 sb_add_string (out
, buffer
);
830 else if (src
< in
->len
&& in
->ptr
[src
] == '&')
832 /* This is a preprocessor variable name, we don't do them
834 sb_add_char (out
, '\\');
835 sb_add_char (out
, '&');
838 else if (macro_mri
&& src
< in
->len
&& ISALNUM (in
->ptr
[src
]))
843 if (ISDIGIT (in
->ptr
[src
]))
844 ind
= in
->ptr
[src
] - '0';
845 else if (ISUPPER (in
->ptr
[src
]))
846 ind
= in
->ptr
[src
] - 'A' + 10;
848 ind
= in
->ptr
[src
] - 'a' + 10;
850 for (f
= formals
; f
!= NULL
; f
= f
->next
)
852 if (f
->index
== ind
- 1)
854 if (f
->actual
.len
!= 0)
855 sb_add_sb (out
, &f
->actual
);
857 sb_add_sb (out
, &f
->def
);
865 src
= sub_actual (src
, in
, &t
, formal_hash
, '\'', out
, 0);
868 else if ((macro_alternate
|| macro_mri
)
869 && is_name_beginner (in
->ptr
[src
])
872 || (src
> 0 && in
->ptr
[src
- 1] == '@')))
875 || src
+ 5 >= in
->len
876 || strncasecmp (in
->ptr
+ src
, "LOCAL", 5) != 0
877 || ! ISWHITE (in
->ptr
[src
+ 5]))
880 src
= sub_actual (src
, in
, &t
, formal_hash
,
881 (macro_strip_at
&& inquote
) ? '@' : '\'',
886 src
= sb_skip_white (src
+ 5, in
);
887 while (in
->ptr
[src
] != '\n')
890 formal_entry
*f
= new_formal ();
892 src
= get_token (src
, in
, &f
->name
);
893 name
= sb_terminate (&f
->name
);
894 if (! hash_find (formal_hash
, name
))
899 f
->index
= LOCAL_INDEX
;
903 sprintf (buf
, IS_ELF
? ".LL%04x" : "LL%04x", ++loccnt
);
904 sb_add_string (&f
->actual
, buf
);
906 err
= hash_jam (formal_hash
, name
, f
);
912 as_bad_where (macro
->file
,
913 macro
->line
+ macro_line
,
914 _("`%s' was already used as parameter (or another local) name"),
919 src
= sb_skip_comma (src
, in
);
923 else if (in
->ptr
[src
] == '"'
924 || (macro_mri
&& in
->ptr
[src
] == '\''))
927 sb_add_char (out
, in
->ptr
[src
++]);
929 else if (in
->ptr
[src
] == '@' && macro_strip_at
)
933 && in
->ptr
[src
] == '@')
935 sb_add_char (out
, '@');
940 && in
->ptr
[src
] == '='
942 && in
->ptr
[src
+ 1] == '=')
947 src
= get_token (src
+ 2, in
, &t
);
948 ptr
= (formal_entry
*) hash_find (formal_hash
, sb_terminate (&t
));
951 /* FIXME: We should really return a warning string here,
952 but we can't, because the == might be in the MRI
953 comment field, and, since the nature of the MRI
954 comment field depends upon the exact instruction
955 being used, we don't have enough information here to
956 figure out whether it is or not. Instead, we leave
957 the == in place, which should cause a syntax error if
958 it is not in a comment. */
959 sb_add_char (out
, '=');
960 sb_add_char (out
, '=');
967 sb_add_string (out
, "-1");
971 sb_add_char (out
, '0');
977 if (in
->ptr
[src
] == '\n')
979 sb_add_char (out
, in
->ptr
[src
++]);
985 while (loclist
!= NULL
)
990 /* Setting the value to NULL effectively deletes the entry. We
991 avoid calling hash_delete because it doesn't reclaim memory. */
992 hash_jam (formal_hash
, sb_terminate (&loclist
->name
), NULL
);
993 del_formal (loclist
);
1000 /* Assign values to the formal parameters of a macro, and expand the
1004 macro_expand (int idx
, sb
*in
, macro_entry
*m
, sb
*out
)
1009 int is_positional
= 0;
1012 const char *err
= NULL
;
1016 /* Reset any old value the actuals may have. */
1017 for (f
= m
->formals
; f
; f
= f
->next
)
1018 sb_reset (&f
->actual
);
1020 while (f
!= NULL
&& f
->index
< 0)
1025 /* The macro may be called with an optional qualifier, which may
1026 be referred to in the macro body as \0. */
1027 if (idx
< in
->len
&& in
->ptr
[idx
] == '.')
1029 /* The Microtec assembler ignores this if followed by a white space.
1030 (Macro invocation with empty extension) */
1033 && in
->ptr
[idx
] != ' '
1034 && in
->ptr
[idx
] != '\t')
1036 formal_entry
*n
= new_formal ();
1038 n
->index
= QUAL_INDEX
;
1040 n
->next
= m
->formals
;
1043 idx
= get_any_string (idx
, in
, &n
->actual
, 1, 0);
1048 /* Peel off the actuals and store them away in the hash tables' actuals. */
1049 idx
= sb_skip_white (idx
, in
);
1050 while (idx
< in
->len
)
1054 /* Look and see if it's a positional or keyword arg. */
1056 while (scan
< in
->len
1057 && !ISSEP (in
->ptr
[scan
])
1058 && !(macro_mri
&& in
->ptr
[scan
] == '\'')
1059 && (!macro_alternate
&& in
->ptr
[scan
] != '='))
1061 if (scan
< in
->len
&& !macro_alternate
&& in
->ptr
[scan
] == '=')
1065 /* It's OK to go from positional to keyword. */
1067 /* This is a keyword arg, fetch the formal name and
1068 then the actual stuff. */
1070 idx
= get_token (idx
, in
, &t
);
1071 if (in
->ptr
[idx
] != '=')
1073 err
= _("confusion in formal parameters");
1077 /* Lookup the formal in the macro's list. */
1078 ptr
= (formal_entry
*) hash_find (m
->formal_hash
, sb_terminate (&t
));
1080 as_bad (_("Parameter named `%s' does not exist for macro `%s'"),
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"),
1091 sb_reset (&ptr
->actual
);
1093 idx
= get_any_string (idx
+ 1, in
, &ptr
->actual
, 0, 0);
1094 if (ptr
->actual
.len
> 0)
1100 /* This is a positional arg. */
1104 err
= _("can't mix positional and keyword arguments");
1115 err
= _("too many positional arguments");
1122 for (pf
= &m
->formals
; *pf
!= NULL
; pf
= &(*pf
)->next
)
1123 if ((*pf
)->index
>= c
)
1124 c
= (*pf
)->index
+ 1;
1131 if (f
->type
!= FORMAL_VARARG
)
1132 idx
= get_any_string (idx
, in
, &f
->actual
, 1, 0);
1135 sb_add_buffer (&f
->actual
, in
->ptr
+ idx
, in
->len
- idx
);
1138 if (f
->actual
.len
> 0)
1144 while (f
!= NULL
&& f
->index
< 0);
1148 idx
= sb_skip_comma (idx
, in
);
1151 if (in
->ptr
[idx
] == ',')
1153 if (ISWHITE (in
->ptr
[idx
]))
1160 for (ptr
= m
->formals
; ptr
; ptr
= ptr
->next
)
1162 if (ptr
->type
== FORMAL_REQUIRED
&& ptr
->actual
.len
== 0)
1163 as_bad (_("Missing value for required parameter `%s' of macro `%s'"),
1173 sb_add_string (&t
, macro_strip_at
? "$NARG" : "NARG");
1174 ptr
= (formal_entry
*) hash_find (m
->formal_hash
, sb_terminate (&t
));
1175 sprintf (buffer
, "%d", narg
);
1176 sb_add_string (&ptr
->actual
, buffer
);
1179 err
= macro_expand_body (&m
->sub
, out
, m
->formals
, m
->formal_hash
, m
);
1182 /* Discard any unnamed formal arguments. */
1190 if ((*pf
)->name
.len
!= 0)
1208 /* Check for a macro. If one is found, put the expansion into
1209 *EXPAND. Return 1 if a macro is found, 0 otherwise. */
1212 check_macro (const char *line
, sb
*expand
,
1213 const char **error
, macro_entry
**info
)
1220 if (! is_name_beginner (*line
)
1221 && (! macro_mri
|| *line
!= '.'))
1225 while (is_part_of_name (*s
))
1227 if (is_name_ender (*s
))
1230 copy
= (char *) alloca (s
- line
+ 1);
1231 memcpy (copy
, line
, s
- line
);
1232 copy
[s
- line
] = '\0';
1233 for (cs
= copy
; *cs
!= '\0'; cs
++)
1234 *cs
= TOLOWER (*cs
);
1236 macro
= (macro_entry
*) hash_find (macro_hash
, copy
);
1241 /* Wrap the line up in an sb. */
1243 while (*s
!= '\0' && *s
!= '\n' && *s
!= '\r')
1244 sb_add_char (&line_sb
, *s
++);
1247 *error
= macro_expand (0, &line_sb
, macro
, expand
);
1251 /* Export the macro information if requested. */
1258 /* Free the memory allocated to a macro. */
1261 free_macro(macro_entry
*macro
)
1263 formal_entry
*formal
;
1265 for (formal
= macro
->formals
; formal
; )
1270 formal
= formal
->next
;
1273 hash_die (macro
->formal_hash
);
1274 sb_kill (¯o
->sub
);
1278 /* Delete a macro. */
1281 delete_macro (const char *name
)
1287 len
= strlen (name
);
1288 copy
= (char *) alloca (len
+ 1);
1289 for (i
= 0; i
< len
; ++i
)
1290 copy
[i
] = TOLOWER (name
[i
]);
1293 /* Since hash_delete doesn't free memory, just clear out the entry. */
1294 if ((macro
= hash_find (macro_hash
, copy
)) != NULL
)
1296 hash_jam (macro_hash
, copy
, NULL
);
1300 as_warn (_("Attempt to purge non-existant macro `%s'"), copy
);
1303 /* Handle the MRI IRP and IRPC pseudo-ops. These are handled as a
1304 combined macro definition and execution. This returns NULL on
1305 success, or an error message otherwise. */
1308 expand_irp (int irpc
, int idx
, sb
*in
, sb
*out
, int (*get_line
) (sb
*))
1312 struct hash_control
*h
;
1315 idx
= sb_skip_white (idx
, in
);
1318 if (! buffer_and_nest (NULL
, "ENDR", &sub
, get_line
))
1319 return _("unexpected end of file in irp or irpc");
1325 idx
= get_token (idx
, in
, &f
.name
);
1326 if (f
.name
.len
== 0)
1327 return _("missing model parameter");
1330 err
= hash_jam (h
, sb_terminate (&f
.name
), &f
);
1336 f
.type
= FORMAL_OPTIONAL
;
1340 idx
= sb_skip_comma (idx
, in
);
1343 /* Expand once with a null string. */
1344 err
= macro_expand_body (&sub
, out
, &f
, h
, 0);
1348 if (irpc
&& in
->ptr
[idx
] == '"')
1350 while (idx
< in
->len
)
1353 idx
= get_any_string (idx
, in
, &f
.actual
, 1, 0);
1356 if (in
->ptr
[idx
] == '"')
1360 nxt
= sb_skip_white (idx
+ 1, in
);
1367 sb_reset (&f
.actual
);
1368 sb_add_char (&f
.actual
, in
->ptr
[idx
]);
1371 err
= macro_expand_body (&sub
, out
, &f
, h
, 0);
1375 idx
= sb_skip_comma (idx
, in
);
1377 idx
= sb_skip_white (idx
, in
);
1382 sb_kill (&f
.actual
);