1 /* macro.c - macro support for gas
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5 Written by Steve and Judy Chamberlain of Cygnus Support,
8 This file is part of GAS, the GNU Assembler.
10 GAS is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
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
26 #include "safe-ctype.h"
30 /* The routines in this file handle macro definition and expansion.
31 They are called by gas. */
33 #define ISWHITE(x) ((x) == ' ' || (x) == '\t')
36 ((x) == ' ' || (x) == '\t' || (x) == ',' || (x) == '"' || (x) == ';' \
37 || (x) == ')' || (x) == '(' \
38 || ((macro_alternate || macro_mri) && ((x) == '<' || (x) == '>')))
41 ((x) == 'b' || (x) == 'B' \
42 || (x) == 'q' || (x) == 'Q' \
43 || (x) == 'h' || (x) == 'H' \
44 || (x) == 'd' || (x) == 'D')
46 /* The macro hash table. */
48 struct hash_control
*macro_hash
;
50 /* Whether any macros have been defined. */
54 /* Whether we are in alternate syntax mode. */
56 static int macro_alternate
;
58 /* Whether we are in MRI mode. */
62 /* Whether we should strip '@' characters. */
64 static int macro_strip_at
;
66 /* Function to use to parse an expression. */
68 static int (*macro_expr
) (const char *, int, sb
*, int *);
70 /* Number of macro expansions that have been done. */
72 static int macro_number
;
74 /* Initialize macro processing. */
77 macro_init (int alternate
, int mri
, int strip_at
,
78 int (*exp
) (const char *, int, sb
*, int *))
80 macro_hash
= hash_new ();
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 int (*get_line
) (sb
*))
116 int to_len
= strlen (to
);
118 int line_start
= ptr
->len
;
120 int more
= get_line (ptr
);
122 if (to_len
== 4 && strcasecmp(to
, "ENDR") == 0)
128 from_len
= strlen (from
);
132 /* Try to find the first pseudo op on the line. */
134 bfd_boolean had_colon
= FALSE
;
136 /* With normal syntax we can suck what we want till we get
137 to the dot. With the alternate, labels have to start in
138 the first column, since we can't tell what's a label and
139 what's a pseudoop. */
141 if (! LABELS_WITHOUT_COLONS
)
143 /* Skip leading whitespace. */
144 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
150 /* Skip over a label, if any. */
151 if (i
>= ptr
->len
|| ! is_name_beginner (ptr
->ptr
[i
]))
154 while (i
< ptr
->len
&& is_part_of_name (ptr
->ptr
[i
]))
156 if (i
< ptr
->len
&& is_name_ender (ptr
->ptr
[i
]))
158 /* Skip whitespace. */
159 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
161 /* Check for the colon. */
162 if (i
>= ptr
->len
|| ptr
->ptr
[i
] != ':')
164 /* LABELS_WITHOUT_COLONS doesn't mean we cannot have a
165 colon after a label. If we do have a colon on the
166 first label then handle more than one label on the
167 line, assuming that each label has a colon. */
168 if (LABELS_WITHOUT_COLONS
&& !had_colon
)
178 /* Skip trailing whitespace. */
179 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
182 if (i
< ptr
->len
&& (ptr
->ptr
[i
] == '.'
186 if (! flag_m68k_mri
&& ptr
->ptr
[i
] == '.')
189 && strncasecmp (ptr
->ptr
+ i
, "IRPC", from_len
= 4) != 0
190 && strncasecmp (ptr
->ptr
+ i
, "IRP", from_len
= 3) != 0
191 && strncasecmp (ptr
->ptr
+ i
, "IREPC", from_len
= 5) != 0
192 && strncasecmp (ptr
->ptr
+ i
, "IREP", from_len
= 4) != 0
193 && strncasecmp (ptr
->ptr
+ i
, "REPT", from_len
= 4) != 0
194 && strncasecmp (ptr
->ptr
+ i
, "REP", from_len
= 3) != 0)
197 ? strncasecmp (ptr
->ptr
+ i
, from
, from_len
) == 0
199 && (ptr
->len
== (i
+ from_len
)
200 || ! (is_part_of_name (ptr
->ptr
[i
+ from_len
])
201 || is_name_ender (ptr
->ptr
[i
+ from_len
]))))
203 if (strncasecmp (ptr
->ptr
+ i
, to
, to_len
) == 0
204 && (ptr
->len
== (i
+ to_len
)
205 || ! (is_part_of_name (ptr
->ptr
[i
+ to_len
])
206 || is_name_ender (ptr
->ptr
[i
+ to_len
]))))
211 /* Reset the string to not include the ending rune. */
212 ptr
->len
= line_start
;
218 /* Add the original end-of-line char to the end and keep running. */
219 sb_add_char (ptr
, more
);
220 line_start
= ptr
->len
;
221 more
= get_line (ptr
);
224 /* Return 1 on success, 0 on unexpected EOF. */
228 /* Pick up a token. */
231 get_token (int idx
, sb
*in
, sb
*name
)
234 && is_name_beginner (in
->ptr
[idx
]))
236 sb_add_char (name
, in
->ptr
[idx
++]);
238 && is_part_of_name (in
->ptr
[idx
]))
240 sb_add_char (name
, in
->ptr
[idx
++]);
243 && is_name_ender (in
->ptr
[idx
]))
245 sb_add_char (name
, in
->ptr
[idx
++]);
248 /* Ignore trailing &. */
249 if (macro_alternate
&& idx
< in
->len
&& in
->ptr
[idx
] == '&')
254 /* Pick up a string. */
257 getstring (int idx
, sb
*in
, sb
*acc
)
260 && (in
->ptr
[idx
] == '"'
261 || (in
->ptr
[idx
] == '<' && (macro_alternate
|| macro_mri
))
262 || (in
->ptr
[idx
] == '\'' && macro_alternate
)))
264 if (in
->ptr
[idx
] == '<')
268 while ((in
->ptr
[idx
] != '>' || nest
)
271 if (in
->ptr
[idx
] == '!')
274 sb_add_char (acc
, in
->ptr
[idx
++]);
278 if (in
->ptr
[idx
] == '>')
280 if (in
->ptr
[idx
] == '<')
282 sb_add_char (acc
, in
->ptr
[idx
++]);
287 else if (in
->ptr
[idx
] == '"' || in
->ptr
[idx
] == '\'')
289 char tchar
= in
->ptr
[idx
];
294 while (idx
< in
->len
)
296 if (in
->ptr
[idx
- 1] == '\\')
301 if (macro_alternate
&& in
->ptr
[idx
] == '!')
305 sb_add_char (acc
, in
->ptr
[idx
]);
309 else if (escaped
&& in
->ptr
[idx
] == tchar
)
311 sb_add_char (acc
, tchar
);
316 if (in
->ptr
[idx
] == tchar
)
320 if (idx
>= in
->len
|| in
->ptr
[idx
] != tchar
)
324 sb_add_char (acc
, in
->ptr
[idx
]);
334 /* Fetch string from the input stream,
336 'Bxyx<whitespace> -> return 'Bxyza
337 %<expr> -> return string of decimal value of <expr>
338 "string" -> return string
339 (string) -> return (string-including-whitespaces)
340 xyx<whitespace> -> return xyz. */
343 get_any_string (int idx
, sb
*in
, sb
*out
)
346 idx
= sb_skip_white (idx
, in
);
350 if (in
->len
> idx
+ 2 && in
->ptr
[idx
+ 1] == '\'' && ISBASE (in
->ptr
[idx
]))
352 while (!ISSEP (in
->ptr
[idx
]))
353 sb_add_char (out
, in
->ptr
[idx
++]);
355 else if (in
->ptr
[idx
] == '%' && macro_alternate
)
360 /* Turns the next expression into a string. */
361 /* xgettext: no-c-format */
362 idx
= (*macro_expr
) (_("% operator needs absolute expression"),
366 sprintf (buf
, "%d", val
);
367 sb_add_string (out
, buf
);
369 else if (in
->ptr
[idx
] == '"'
370 || (in
->ptr
[idx
] == '<' && (macro_alternate
|| macro_mri
))
371 || (macro_alternate
&& in
->ptr
[idx
] == '\''))
373 if (macro_alternate
&& ! macro_strip_at
&& in
->ptr
[idx
] != '<')
375 /* Keep the quotes. */
376 sb_add_char (out
, '"');
377 idx
= getstring (idx
, in
, out
);
378 sb_add_char (out
, '"');
382 idx
= getstring (idx
, in
, out
);
387 char *br_buf
= (char *) xmalloc(1);
388 char *in_br
= br_buf
;
393 || (in
->ptr
[idx
] != ' '
394 && in
->ptr
[idx
] != '\t'))
395 && in
->ptr
[idx
] != ','
396 && (in
->ptr
[idx
] != '<'
397 || (! macro_alternate
&& ! macro_mri
)))
399 char tchar
= in
->ptr
[idx
];
405 sb_add_char (out
, in
->ptr
[idx
++]);
407 && in
->ptr
[idx
] != tchar
)
408 sb_add_char (out
, in
->ptr
[idx
++]);
418 br_buf
= (char *) xmalloc(strlen(in_br
) + 2);
419 strcpy(br_buf
+ 1, in_br
);
434 sb_add_char (out
, tchar
);
444 /* Allocate a new formal. */
446 static formal_entry
*
449 formal_entry
*formal
;
451 formal
= (formal_entry
*) xmalloc (sizeof (formal_entry
));
453 sb_new (&formal
->name
);
454 sb_new (&formal
->def
);
455 sb_new (&formal
->actual
);
457 formal
->type
= FORMAL_OPTIONAL
;
464 del_formal (formal_entry
*formal
)
466 sb_kill (&formal
->actual
);
467 sb_kill (&formal
->def
);
468 sb_kill (&formal
->name
);
472 /* Pick up the formal parameters of a macro definition. */
475 do_formals (macro_entry
*macro
, int idx
, sb
*in
)
477 formal_entry
**p
= ¯o
->formals
;
480 idx
= sb_skip_white (idx
, in
);
481 while (idx
< in
->len
)
483 formal_entry
*formal
= new_formal ();
486 idx
= get_token (idx
, in
, &formal
->name
);
487 if (formal
->name
.len
== 0)
489 if (macro
->formal_count
)
493 idx
= sb_skip_white (idx
, in
);
494 /* This is a formal. */
495 name
= sb_terminate (&formal
->name
);
498 && in
->ptr
[idx
] == ':'
499 && (! is_name_beginner (':')
500 || idx
+ 1 >= in
->len
501 || ! is_part_of_name (in
->ptr
[idx
+ 1])))
503 /* Got a qualifier. */
507 idx
= get_token (sb_skip_white (idx
+ 1, in
), in
, &qual
);
508 sb_terminate (&qual
);
510 as_bad_where (macro
->file
,
512 _("Missing parameter qualifier for `%s' in macro `%s'"),
515 else if (strcmp (qual
.ptr
, "req") == 0)
516 formal
->type
= FORMAL_REQUIRED
;
517 else if (strcmp (qual
.ptr
, "vararg") == 0)
518 formal
->type
= FORMAL_VARARG
;
520 as_bad_where (macro
->file
,
522 _("`%s' is not a valid parameter qualifier for `%s' in macro `%s'"),
527 idx
= sb_skip_white (idx
, in
);
529 if (idx
< in
->len
&& in
->ptr
[idx
] == '=')
532 idx
= get_any_string (idx
+ 1, in
, &formal
->def
);
533 idx
= sb_skip_white (idx
, in
);
534 if (formal
->type
== FORMAL_REQUIRED
)
536 sb_reset (&formal
->def
);
537 as_warn_where (macro
->file
,
539 _("Pointless default value for required parameter `%s' in macro `%s'"),
545 /* Add to macro's hash table. */
546 if (! hash_find (macro
->formal_hash
, name
))
547 hash_jam (macro
->formal_hash
, name
, formal
);
549 as_bad_where (macro
->file
,
551 _("A parameter named `%s' already exists for macro `%s'"),
555 formal
->index
= macro
->formal_count
++;
558 if (formal
->type
== FORMAL_VARARG
)
561 idx
= sb_skip_comma (idx
, in
);
562 if (idx
!= cidx
&& idx
>= in
->len
)
571 formal_entry
*formal
= new_formal ();
573 /* Add a special NARG formal, which macro_expand will set to the
574 number of arguments. */
575 /* The same MRI assemblers which treat '@' characters also use
576 the name $NARG. At least until we find an exception. */
582 sb_add_string (&formal
->name
, name
);
584 /* Add to macro's hash table. */
585 if (hash_find (macro
->formal_hash
, name
))
586 as_bad_where (macro
->file
,
588 _("Reserved word `%s' used as parameter in macro `%s'"),
591 hash_jam (macro
->formal_hash
, name
, formal
);
593 formal
->index
= NARG_INDEX
;
600 /* Free the memory allocated to a macro. */
603 free_macro (macro_entry
*macro
)
605 formal_entry
*formal
;
607 for (formal
= macro
->formals
; formal
; )
612 formal
= formal
->next
;
615 hash_die (macro
->formal_hash
);
616 sb_kill (¯o
->sub
);
620 /* Define a new macro. Returns NULL on success, otherwise returns an
621 error message. If NAMEP is not NULL, *NAMEP is set to the name of
622 the macro which was defined. */
625 define_macro (int idx
, sb
*in
, sb
*label
,
626 int (*get_line
) (sb
*),
627 char *file
, unsigned int line
,
632 const char *error
= NULL
;
634 macro
= (macro_entry
*) xmalloc (sizeof (macro_entry
));
635 sb_new (¯o
->sub
);
640 macro
->formal_count
= 0;
642 macro
->formal_hash
= hash_new ();
644 idx
= sb_skip_white (idx
, in
);
645 if (! buffer_and_nest ("MACRO", "ENDM", ¯o
->sub
, get_line
))
646 error
= _("unexpected end of file in macro `%s' definition");
647 if (label
!= NULL
&& label
->len
!= 0)
649 sb_add_sb (&name
, label
);
650 macro
->name
= sb_terminate (&name
);
651 if (idx
< in
->len
&& in
->ptr
[idx
] == '(')
653 /* It's the label: MACRO (formals,...) sort */
654 idx
= do_formals (macro
, idx
+ 1, in
);
655 if (idx
< in
->len
&& in
->ptr
[idx
] == ')')
656 idx
= sb_skip_white (idx
+ 1, in
);
658 error
= _("missing `)' after formals in macro definition `%s'");
662 /* It's the label: MACRO formals,... sort */
663 idx
= do_formals (macro
, idx
, in
);
670 idx
= get_token (idx
, in
, &name
);
671 macro
->name
= sb_terminate (&name
);
673 error
= _("Missing macro name");
674 cidx
= sb_skip_white (idx
, in
);
675 idx
= sb_skip_comma (cidx
, in
);
676 if (idx
== cidx
|| idx
< in
->len
)
677 idx
= do_formals (macro
, idx
, in
);
681 if (!error
&& idx
< in
->len
)
682 error
= _("Bad parameter list for macro `%s'");
684 /* And stick it in the macro hash table. */
685 for (idx
= 0; idx
< name
.len
; idx
++)
686 name
.ptr
[idx
] = TOLOWER (name
.ptr
[idx
]);
687 if (hash_find (macro_hash
, macro
->name
))
688 error
= _("Macro `%s' was already defined");
690 error
= hash_jam (macro_hash
, macro
->name
, (void *) macro
);
693 *namep
= macro
->name
;
703 /* Scan a token, and then skip KIND. */
706 get_apost_token (int idx
, sb
*in
, sb
*name
, int kind
)
708 idx
= get_token (idx
, in
, name
);
710 && in
->ptr
[idx
] == kind
711 && (! macro_mri
|| macro_strip_at
)
712 && (! macro_strip_at
|| kind
== '@'))
717 /* Substitute the actual value for a formal parameter. */
720 sub_actual (int start
, sb
*in
, sb
*t
, struct hash_control
*formal_hash
,
721 int kind
, sb
*out
, int copyifnotthere
)
726 src
= get_apost_token (start
, in
, t
, kind
);
727 /* See if it's in the macro's hash table, unless this is
728 macro_strip_at and kind is '@' and the token did not end in '@'. */
731 && (src
== start
|| in
->ptr
[src
- 1] != '@'))
734 ptr
= (formal_entry
*) hash_find (formal_hash
, sb_terminate (t
));
739 sb_add_sb (out
, &ptr
->actual
);
743 sb_add_sb (out
, &ptr
->def
);
746 else if (kind
== '&')
748 /* Doing this permits people to use & in macro bodies. */
749 sb_add_char (out
, '&');
752 else if (copyifnotthere
)
758 sb_add_char (out
, '\\');
764 /* Expand the body of a macro. */
767 macro_expand_body (sb
*in
, sb
*out
, formal_entry
*formals
,
768 struct hash_control
*formal_hash
, const macro_entry
*macro
)
771 int src
= 0, inquote
= 0, macro_line
= 0;
772 formal_entry
*loclist
= NULL
;
773 const char *err
= NULL
;
777 while (src
< in
->len
&& !err
)
779 if (in
->ptr
[src
] == '&')
784 if (src
+ 1 < in
->len
&& in
->ptr
[src
+ 1] == '&')
785 src
= sub_actual (src
+ 2, in
, &t
, formal_hash
, '\'', out
, 1);
787 sb_add_char (out
, in
->ptr
[src
++]);
791 /* FIXME: Why do we do this? */
792 /* At least in alternate mode this seems correct; without this
793 one can't append a literal to a parameter. */
794 src
= sub_actual (src
+ 1, in
, &t
, formal_hash
, '&', out
, 0);
797 else if (in
->ptr
[src
] == '\\')
800 if (src
< in
->len
&& in
->ptr
[src
] == '(')
802 /* Sub in till the next ')' literally. */
804 while (src
< in
->len
&& in
->ptr
[src
] != ')')
806 sb_add_char (out
, in
->ptr
[src
++]);
811 err
= _("missing `)'");
813 as_bad_where (macro
->file
, macro
->line
+ macro_line
, _("missing `)'"));
815 else if (src
< in
->len
&& in
->ptr
[src
] == '@')
817 /* Sub in the macro invocation number. */
821 sprintf (buffer
, "%d", macro_number
);
822 sb_add_string (out
, buffer
);
824 else if (src
< in
->len
&& in
->ptr
[src
] == '&')
826 /* This is a preprocessor variable name, we don't do them
828 sb_add_char (out
, '\\');
829 sb_add_char (out
, '&');
832 else if (macro_mri
&& src
< in
->len
&& ISALNUM (in
->ptr
[src
]))
837 if (ISDIGIT (in
->ptr
[src
]))
838 ind
= in
->ptr
[src
] - '0';
839 else if (ISUPPER (in
->ptr
[src
]))
840 ind
= in
->ptr
[src
] - 'A' + 10;
842 ind
= in
->ptr
[src
] - 'a' + 10;
844 for (f
= formals
; f
!= NULL
; f
= f
->next
)
846 if (f
->index
== ind
- 1)
848 if (f
->actual
.len
!= 0)
849 sb_add_sb (out
, &f
->actual
);
851 sb_add_sb (out
, &f
->def
);
859 src
= sub_actual (src
, in
, &t
, formal_hash
, '\'', out
, 0);
862 else if ((macro_alternate
|| macro_mri
)
863 && is_name_beginner (in
->ptr
[src
])
866 || (src
> 0 && in
->ptr
[src
- 1] == '@')))
869 || src
+ 5 >= in
->len
870 || strncasecmp (in
->ptr
+ src
, "LOCAL", 5) != 0
871 || ! ISWHITE (in
->ptr
[src
+ 5]))
874 src
= sub_actual (src
, in
, &t
, formal_hash
,
875 (macro_strip_at
&& inquote
) ? '@' : '\'',
880 src
= sb_skip_white (src
+ 5, in
);
881 while (in
->ptr
[src
] != '\n')
884 formal_entry
*f
= new_formal ();
886 src
= get_token (src
, in
, &f
->name
);
887 name
= sb_terminate (&f
->name
);
888 if (! hash_find (formal_hash
, name
))
893 f
->index
= LOCAL_INDEX
;
897 sprintf (buf
, IS_ELF
? ".LL%04x" : "LL%04x", ++loccnt
);
898 sb_add_string (&f
->actual
, buf
);
900 err
= hash_jam (formal_hash
, name
, f
);
906 as_bad_where (macro
->file
,
907 macro
->line
+ macro_line
,
908 _("`%s' was already used as parameter (or another local) name"),
913 src
= sb_skip_comma (src
, in
);
917 else if (in
->ptr
[src
] == '"'
918 || (macro_mri
&& in
->ptr
[src
] == '\''))
921 sb_add_char (out
, in
->ptr
[src
++]);
923 else if (in
->ptr
[src
] == '@' && macro_strip_at
)
927 && in
->ptr
[src
] == '@')
929 sb_add_char (out
, '@');
934 && in
->ptr
[src
] == '='
936 && in
->ptr
[src
+ 1] == '=')
941 src
= get_token (src
+ 2, in
, &t
);
942 ptr
= (formal_entry
*) hash_find (formal_hash
, sb_terminate (&t
));
945 /* FIXME: We should really return a warning string here,
946 but we can't, because the == might be in the MRI
947 comment field, and, since the nature of the MRI
948 comment field depends upon the exact instruction
949 being used, we don't have enough information here to
950 figure out whether it is or not. Instead, we leave
951 the == in place, which should cause a syntax error if
952 it is not in a comment. */
953 sb_add_char (out
, '=');
954 sb_add_char (out
, '=');
961 sb_add_string (out
, "-1");
965 sb_add_char (out
, '0');
971 if (in
->ptr
[src
] == '\n')
973 sb_add_char (out
, in
->ptr
[src
++]);
979 while (loclist
!= NULL
)
985 name
= sb_terminate (&loclist
->name
);
986 hash_delete (formal_hash
, name
, f
== NULL
);
987 del_formal (loclist
);
994 /* Assign values to the formal parameters of a macro, and expand the
998 macro_expand (int idx
, sb
*in
, macro_entry
*m
, sb
*out
)
1005 const char *err
= NULL
;
1009 /* Reset any old value the actuals may have. */
1010 for (f
= m
->formals
; f
; f
= f
->next
)
1011 sb_reset (&f
->actual
);
1013 while (f
!= NULL
&& f
->index
< 0)
1018 /* The macro may be called with an optional qualifier, which may
1019 be referred to in the macro body as \0. */
1020 if (idx
< in
->len
&& in
->ptr
[idx
] == '.')
1022 /* The Microtec assembler ignores this if followed by a white space.
1023 (Macro invocation with empty extension) */
1026 && in
->ptr
[idx
] != ' '
1027 && in
->ptr
[idx
] != '\t')
1029 formal_entry
*n
= new_formal ();
1031 n
->index
= QUAL_INDEX
;
1033 n
->next
= m
->formals
;
1036 idx
= get_any_string (idx
, in
, &n
->actual
);
1041 /* Peel off the actuals and store them away in the hash tables' actuals. */
1042 idx
= sb_skip_white (idx
, in
);
1043 while (idx
< in
->len
)
1047 /* Look and see if it's a positional or keyword arg. */
1049 while (scan
< in
->len
1050 && !ISSEP (in
->ptr
[scan
])
1051 && !(macro_mri
&& in
->ptr
[scan
] == '\'')
1052 && (!macro_alternate
&& in
->ptr
[scan
] != '='))
1054 if (scan
< in
->len
&& !macro_alternate
&& in
->ptr
[scan
] == '=')
1058 /* It's OK to go from positional to keyword. */
1060 /* This is a keyword arg, fetch the formal name and
1061 then the actual stuff. */
1063 idx
= get_token (idx
, in
, &t
);
1064 if (in
->ptr
[idx
] != '=')
1066 err
= _("confusion in formal parameters");
1070 /* Lookup the formal in the macro's list. */
1071 ptr
= (formal_entry
*) hash_find (m
->formal_hash
, sb_terminate (&t
));
1073 as_bad (_("Parameter named `%s' does not exist for macro `%s'"),
1078 /* Insert this value into the right place. */
1079 if (ptr
->actual
.len
)
1081 as_warn (_("Value for parameter `%s' of macro `%s' was already specified"),
1084 sb_reset (&ptr
->actual
);
1086 idx
= get_any_string (idx
+ 1, in
, &ptr
->actual
);
1087 if (ptr
->actual
.len
> 0)
1095 err
= _("can't mix positional and keyword arguments");
1106 err
= _("too many positional arguments");
1113 for (pf
= &m
->formals
; *pf
!= NULL
; pf
= &(*pf
)->next
)
1114 if ((*pf
)->index
>= c
)
1115 c
= (*pf
)->index
+ 1;
1122 if (f
->type
!= FORMAL_VARARG
)
1123 idx
= get_any_string (idx
, in
, &f
->actual
);
1126 sb_add_buffer (&f
->actual
, in
->ptr
+ idx
, in
->len
- idx
);
1129 if (f
->actual
.len
> 0)
1135 while (f
!= NULL
&& f
->index
< 0);
1139 idx
= sb_skip_comma (idx
, in
);
1142 if (in
->ptr
[idx
] == ',')
1144 if (ISWHITE (in
->ptr
[idx
]))
1151 for (ptr
= m
->formals
; ptr
; ptr
= ptr
->next
)
1153 if (ptr
->type
== FORMAL_REQUIRED
&& ptr
->actual
.len
== 0)
1154 as_bad (_("Missing value for required parameter `%s' of macro `%s'"),
1164 sb_add_string (&t
, macro_strip_at
? "$NARG" : "NARG");
1165 ptr
= (formal_entry
*) hash_find (m
->formal_hash
, sb_terminate (&t
));
1166 sprintf (buffer
, "%d", narg
);
1167 sb_add_string (&ptr
->actual
, buffer
);
1170 err
= macro_expand_body (&m
->sub
, out
, m
->formals
, m
->formal_hash
, m
);
1173 /* Discard any unnamed formal arguments. */
1181 if ((*pf
)->name
.len
!= 0)
1199 /* Check for a macro. If one is found, put the expansion into
1200 *EXPAND. Return 1 if a macro is found, 0 otherwise. */
1203 check_macro (const char *line
, sb
*expand
,
1204 const char **error
, macro_entry
**info
)
1211 if (! is_name_beginner (*line
)
1212 && (! macro_mri
|| *line
!= '.'))
1216 while (is_part_of_name (*s
))
1218 if (is_name_ender (*s
))
1221 copy
= (char *) alloca (s
- line
+ 1);
1222 memcpy (copy
, line
, s
- line
);
1223 copy
[s
- line
] = '\0';
1224 for (cls
= copy
; *cls
!= '\0'; cls
++)
1225 *cls
= TOLOWER (*cls
);
1227 macro
= (macro_entry
*) hash_find (macro_hash
, copy
);
1232 /* Wrap the line up in an sb. */
1234 while (*s
!= '\0' && *s
!= '\n' && *s
!= '\r')
1235 sb_add_char (&line_sb
, *s
++);
1238 *error
= macro_expand (0, &line_sb
, macro
, expand
);
1242 /* Export the macro information if requested. */
1249 /* Delete a macro. */
1252 delete_macro (const char *name
)
1258 len
= strlen (name
);
1259 copy
= (char *) alloca (len
+ 1);
1260 for (i
= 0; i
< len
; ++i
)
1261 copy
[i
] = TOLOWER (name
[i
]);
1264 /* We can only ask hash_delete to free memory if we are deleting
1265 macros in reverse order to their definition.
1266 So just clear out the entry. */
1267 if ((macro
= (macro_entry
*) hash_find (macro_hash
, copy
)) != NULL
)
1269 hash_jam (macro_hash
, copy
, NULL
);
1273 as_warn (_("Attempt to purge non-existant macro `%s'"), copy
);
1276 /* Handle the MRI IRP and IRPC pseudo-ops. These are handled as a
1277 combined macro definition and execution. This returns NULL on
1278 success, or an error message otherwise. */
1281 expand_irp (int irpc
, int idx
, sb
*in
, sb
*out
, int (*get_line
) (sb
*))
1285 struct hash_control
*h
;
1288 idx
= sb_skip_white (idx
, in
);
1291 if (! buffer_and_nest (NULL
, "ENDR", &sub
, get_line
))
1292 return _("unexpected end of file in irp or irpc");
1298 idx
= get_token (idx
, in
, &f
.name
);
1299 if (f
.name
.len
== 0)
1300 return _("missing model parameter");
1303 err
= hash_jam (h
, sb_terminate (&f
.name
), &f
);
1309 f
.type
= FORMAL_OPTIONAL
;
1313 idx
= sb_skip_comma (idx
, in
);
1316 /* Expand once with a null string. */
1317 err
= macro_expand_body (&sub
, out
, &f
, h
, 0);
1321 bfd_boolean in_quotes
= FALSE
;
1323 if (irpc
&& in
->ptr
[idx
] == '"')
1329 while (idx
< in
->len
)
1332 idx
= get_any_string (idx
, in
, &f
.actual
);
1335 if (in
->ptr
[idx
] == '"')
1340 in_quotes
= ! in_quotes
;
1342 nxt
= sb_skip_white (idx
+ 1, in
);
1349 sb_reset (&f
.actual
);
1350 sb_add_char (&f
.actual
, in
->ptr
[idx
]);
1354 err
= macro_expand_body (&sub
, out
, &f
, h
, 0);
1358 idx
= sb_skip_comma (idx
, in
);
1359 else if (! in_quotes
)
1360 idx
= sb_skip_white (idx
, in
);
1365 sb_kill (&f
.actual
);
This page took 0.056586 seconds and 4 git commands to generate.