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
*);
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 to find the first pseudo op on the line. */
186 /* With normal syntax we can suck what we want till we get
187 to the dot. With the alternate, labels have to start in
188 the first column, since we can't tell what's a label and
189 what's a pseudoop. */
191 if (! LABELS_WITHOUT_COLONS
)
193 /* Skip leading whitespace. */
194 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
200 /* Skip over a label, if any. */
201 if (i
>= ptr
->len
|| ! is_name_beginner (ptr
->ptr
[i
]))
204 while (i
< ptr
->len
&& is_part_of_name (ptr
->ptr
[i
]))
206 if (i
< ptr
->len
&& is_name_ender (ptr
->ptr
[i
]))
208 if (LABELS_WITHOUT_COLONS
)
210 /* Skip whitespace. */
211 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
213 /* Check for the colon. */
214 if (i
>= ptr
->len
|| ptr
->ptr
[i
] != ':')
223 /* Skip trailing whitespace. */
224 while (i
< ptr
->len
&& ISWHITE (ptr
->ptr
[i
]))
227 if (i
< ptr
->len
&& (ptr
->ptr
[i
] == '.'
231 if (! flag_m68k_mri
&& ptr
->ptr
[i
] == '.')
234 && strncasecmp (ptr
->ptr
+ i
, "IRPC", from_len
= 4) != 0
235 && strncasecmp (ptr
->ptr
+ i
, "IRP", from_len
= 3) != 0
236 && strncasecmp (ptr
->ptr
+ i
, "IREPC", from_len
= 5) != 0
237 && strncasecmp (ptr
->ptr
+ i
, "IREP", from_len
= 4) != 0
238 && strncasecmp (ptr
->ptr
+ i
, "REPT", from_len
= 4) != 0
239 && strncasecmp (ptr
->ptr
+ i
, "REP", from_len
= 3) != 0)
242 ? strncasecmp (ptr
->ptr
+ i
, from
, from_len
) == 0
244 && (ptr
->len
== (i
+ from_len
)
245 || ! (is_part_of_name (ptr
->ptr
[i
+ from_len
])
246 || is_name_ender (ptr
->ptr
[i
+ from_len
]))))
248 if (strncasecmp (ptr
->ptr
+ i
, to
, to_len
) == 0
249 && (ptr
->len
== (i
+ to_len
)
250 || ! (is_part_of_name (ptr
->ptr
[i
+ to_len
])
251 || is_name_ender (ptr
->ptr
[i
+ to_len
]))))
256 /* Reset the string to not include the ending rune. */
257 ptr
->len
= line_start
;
263 /* Add the original end-of-line char to the end and keep running. */
264 sb_add_char (ptr
, more
);
265 line_start
= ptr
->len
;
266 more
= get_line (ptr
);
269 /* Return 1 on success, 0 on unexpected EOF. */
273 /* Pick up a token. */
276 get_token (int idx
, sb
*in
, sb
*name
)
279 && is_name_beginner (in
->ptr
[idx
]))
281 sb_add_char (name
, in
->ptr
[idx
++]);
283 && is_part_of_name (in
->ptr
[idx
]))
285 sb_add_char (name
, in
->ptr
[idx
++]);
288 && is_name_ender (in
->ptr
[idx
]))
290 sb_add_char (name
, in
->ptr
[idx
++]);
293 /* Ignore trailing &. */
294 if (macro_alternate
&& idx
< in
->len
&& in
->ptr
[idx
] == '&')
299 /* Pick up a string. */
302 getstring (int idx
, sb
*in
, sb
*acc
)
305 && (in
->ptr
[idx
] == '"'
306 || in
->ptr
[idx
] == '('
307 || (in
->ptr
[idx
] == '<' && (macro_alternate
|| macro_mri
))
308 || (in
->ptr
[idx
] == '\'' && macro_alternate
)))
310 if (in
->ptr
[idx
] == '<')
313 char start_char
= '>';
317 while ((in
->ptr
[idx
] != end_char
|| nest
)
320 if (in
->ptr
[idx
] == '!')
323 sb_add_char (acc
, in
->ptr
[idx
++]);
327 if (in
->ptr
[idx
] == end_char
)
329 if (in
->ptr
[idx
] == start_char
)
331 sb_add_char (acc
, in
->ptr
[idx
++]);
336 else if (in
->ptr
[idx
] == '(')
352 sb_add_char (acc
, c
);
355 while ((c
!= ')' || nest
)
358 else if (in
->ptr
[idx
] == '"' || in
->ptr
[idx
] == '\'')
360 char tchar
= in
->ptr
[idx
];
365 while (idx
< in
->len
)
367 if (in
->ptr
[idx
- 1] == '\\')
372 if (macro_alternate
&& in
->ptr
[idx
] == '!')
376 sb_add_char (acc
, in
->ptr
[idx
]);
380 else if (escaped
&& in
->ptr
[idx
] == tchar
)
382 sb_add_char (acc
, tchar
);
387 if (in
->ptr
[idx
] == tchar
)
391 if (idx
>= in
->len
|| in
->ptr
[idx
] != tchar
)
395 sb_add_char (acc
, in
->ptr
[idx
]);
405 /* Fetch string from the input stream,
407 'Bxyx<whitespace> -> return 'Bxyza
408 %<expr> -> return string of decimal value of <expr>
409 "string" -> return string
410 (string) -> return (string-including-whitespaces)
411 xyx<whitespace> -> return xyz. */
414 get_any_string (int idx
, sb
*in
, sb
*out
)
417 idx
= sb_skip_white (idx
, in
);
421 if (in
->len
> idx
+ 2 && in
->ptr
[idx
+ 1] == '\'' && ISBASE (in
->ptr
[idx
]))
423 while (!ISSEP (in
->ptr
[idx
]))
424 sb_add_char (out
, in
->ptr
[idx
++]);
426 else if (in
->ptr
[idx
] == '%' && macro_alternate
)
431 /* Turns the next expression into a string. */
432 /* xgettext: no-c-format */
433 idx
= (*macro_expr
) (_("% operator needs absolute expression"),
437 sprintf (buf
, "%d", val
);
438 sb_add_string (out
, buf
);
440 else if (in
->ptr
[idx
] == '"'
441 || in
->ptr
[idx
] == '('
442 || (in
->ptr
[idx
] == '<' && (macro_alternate
|| macro_mri
))
443 || (macro_alternate
&& in
->ptr
[idx
] == '\''))
445 if (macro_alternate
&& ! macro_strip_at
)
447 /* Keep the quotes. */
448 sb_add_char (out
, '\"');
450 idx
= getstring (idx
, in
, out
);
451 sb_add_char (out
, '\"');
455 idx
= getstring (idx
, in
, out
);
461 && in
->ptr
[idx
] != ' '
462 && in
->ptr
[idx
] != '\t'
463 && in
->ptr
[idx
] != ','
464 && (in
->ptr
[idx
] != '<'
465 || (! macro_alternate
&& ! macro_mri
)))
467 if (in
->ptr
[idx
] == '"'
468 || in
->ptr
[idx
] == '\'')
470 char tchar
= in
->ptr
[idx
];
472 sb_add_char (out
, in
->ptr
[idx
++]);
474 && in
->ptr
[idx
] != tchar
)
475 sb_add_char (out
, in
->ptr
[idx
++]);
479 sb_add_char (out
, in
->ptr
[idx
++]);
487 /* Allocate a new formal. */
489 static formal_entry
*
492 formal_entry
*formal
;
494 formal
= xmalloc (sizeof (formal_entry
));
496 sb_new (&formal
->name
);
497 sb_new (&formal
->def
);
498 sb_new (&formal
->actual
);
500 formal
->type
= FORMAL_OPTIONAL
;
507 del_formal (formal_entry
*formal
)
509 sb_kill (&formal
->actual
);
510 sb_kill (&formal
->def
);
511 sb_kill (&formal
->name
);
515 /* Pick up the formal parameters of a macro definition. */
518 do_formals (macro_entry
*macro
, int idx
, sb
*in
)
520 formal_entry
**p
= ¯o
->formals
;
523 idx
= sb_skip_white (idx
, in
);
524 while (idx
< in
->len
)
526 formal_entry
*formal
= new_formal ();
529 idx
= get_token (idx
, in
, &formal
->name
);
530 if (formal
->name
.len
== 0)
532 if (macro
->formal_count
)
536 idx
= sb_skip_white (idx
, in
);
537 /* This is a formal. */
538 name
= sb_terminate (&formal
->name
);
541 && in
->ptr
[idx
] == ':'
542 && (! is_name_beginner (':')
543 || idx
+ 1 >= in
->len
544 || ! is_part_of_name (in
->ptr
[idx
+ 1])))
546 /* Got a qualifier. */
550 idx
= get_token (sb_skip_white (idx
+ 1, in
), in
, &qual
);
551 sb_terminate (&qual
);
553 as_bad_where (macro
->file
,
555 _("Missing parameter qualifier for `%s' in macro `%s'"),
558 else if (strcmp (qual
.ptr
, "req") == 0)
559 formal
->type
= FORMAL_REQUIRED
;
560 else if (strcmp (qual
.ptr
, "vararg") == 0)
561 formal
->type
= FORMAL_VARARG
;
563 as_bad_where (macro
->file
,
565 _("`%s' is not a valid parameter qualifier for `%s' in macro `%s'"),
570 idx
= sb_skip_white (idx
, in
);
572 if (idx
< in
->len
&& in
->ptr
[idx
] == '=')
575 idx
= get_any_string (idx
+ 1, in
, &formal
->def
);
576 idx
= sb_skip_white (idx
, in
);
577 if (formal
->type
== FORMAL_REQUIRED
)
579 sb_reset (&formal
->def
);
580 as_warn_where (macro
->file
,
582 _("Pointless default value for required parameter `%s' in macro `%s'"),
588 /* Add to macro's hash table. */
589 if (! hash_find (macro
->formal_hash
, name
))
590 hash_jam (macro
->formal_hash
, name
, formal
);
592 as_bad_where (macro
->file
,
594 _("A parameter named `%s' already exists for macro `%s'"),
598 formal
->index
= macro
->formal_count
++;
601 if (formal
->type
== FORMAL_VARARG
)
604 idx
= sb_skip_comma (idx
, in
);
605 if (idx
!= cidx
&& idx
>= in
->len
)
614 formal_entry
*formal
= new_formal ();
616 /* Add a special NARG formal, which macro_expand will set to the
617 number of arguments. */
618 /* The same MRI assemblers which treat '@' characters also use
619 the name $NARG. At least until we find an exception. */
625 sb_add_string (&formal
->name
, name
);
627 /* Add to macro's hash table. */
628 if (hash_find (macro
->formal_hash
, name
))
629 as_bad_where (macro
->file
,
631 _("Reserved word `%s' used as parameter in macro `%s'"),
634 hash_jam (macro
->formal_hash
, name
, formal
);
636 formal
->index
= NARG_INDEX
;
643 /* Define a new macro. Returns NULL on success, otherwise returns an
644 error message. If NAMEP is not NULL, *NAMEP is set to the name of
645 the macro which was defined. */
648 define_macro (int idx
, sb
*in
, sb
*label
,
649 int (*get_line
) (sb
*),
650 char *file
, unsigned int line
,
655 const char *error
= NULL
;
657 macro
= (macro_entry
*) xmalloc (sizeof (macro_entry
));
658 sb_new (¯o
->sub
);
663 macro
->formal_count
= 0;
665 macro
->formal_hash
= hash_new ();
667 idx
= sb_skip_white (idx
, in
);
668 if (! buffer_and_nest ("MACRO", "ENDM", ¯o
->sub
, get_line
))
669 error
= _("unexpected end of file in macro `%s' definition");
670 if (label
!= NULL
&& label
->len
!= 0)
672 sb_add_sb (&name
, label
);
673 macro
->name
= sb_terminate (&name
);
674 if (idx
< in
->len
&& in
->ptr
[idx
] == '(')
676 /* It's the label: MACRO (formals,...) sort */
677 idx
= do_formals (macro
, idx
+ 1, in
);
678 if (idx
< in
->len
&& in
->ptr
[idx
] == ')')
679 idx
= sb_skip_white (idx
+ 1, in
);
681 error
= _("missing `)' after formals in macro definition `%s'");
685 /* It's the label: MACRO formals,... sort */
686 idx
= do_formals (macro
, idx
, in
);
693 idx
= get_token (idx
, in
, &name
);
694 macro
->name
= sb_terminate (&name
);
696 error
= _("Missing macro name");
697 cidx
= sb_skip_white (idx
, in
);
698 idx
= sb_skip_comma (cidx
, in
);
699 if (idx
== cidx
|| idx
< in
->len
)
700 idx
= do_formals (macro
, idx
, in
);
704 if (!error
&& idx
< in
->len
)
705 error
= _("Bad parameter list for macro `%s'");
707 /* And stick it in the macro hash table. */
708 for (idx
= 0; idx
< name
.len
; idx
++)
709 name
.ptr
[idx
] = TOLOWER (name
.ptr
[idx
]);
710 if (hash_find (macro_hash
, macro
->name
))
711 error
= _("Macro `%s' was already defined");
713 error
= hash_jam (macro_hash
, macro
->name
, (PTR
) macro
);
716 *namep
= macro
->name
;
726 /* Scan a token, and then skip KIND. */
729 get_apost_token (int idx
, sb
*in
, sb
*name
, int kind
)
731 idx
= get_token (idx
, in
, name
);
733 && in
->ptr
[idx
] == kind
734 && (! macro_mri
|| macro_strip_at
)
735 && (! macro_strip_at
|| kind
== '@'))
740 /* Substitute the actual value for a formal parameter. */
743 sub_actual (int start
, sb
*in
, sb
*t
, struct hash_control
*formal_hash
,
744 int kind
, sb
*out
, int copyifnotthere
)
749 src
= get_apost_token (start
, in
, t
, kind
);
750 /* See if it's in the macro's hash table, unless this is
751 macro_strip_at and kind is '@' and the token did not end in '@'. */
754 && (src
== start
|| in
->ptr
[src
- 1] != '@'))
757 ptr
= (formal_entry
*) hash_find (formal_hash
, sb_terminate (t
));
762 sb_add_sb (out
, &ptr
->actual
);
766 sb_add_sb (out
, &ptr
->def
);
769 else if (kind
== '&')
771 /* Doing this permits people to use & in macro bodies. */
772 sb_add_char (out
, '&');
775 else if (copyifnotthere
)
781 sb_add_char (out
, '\\');
787 /* Expand the body of a macro. */
790 macro_expand_body (sb
*in
, sb
*out
, formal_entry
*formals
,
791 struct hash_control
*formal_hash
, const macro_entry
*macro
)
794 int src
= 0, inquote
= 0, macro_line
= 0;
795 formal_entry
*loclist
= NULL
;
796 const char *err
= NULL
;
800 while (src
< in
->len
&& !err
)
802 if (in
->ptr
[src
] == '&')
807 if (src
+ 1 < in
->len
&& in
->ptr
[src
+ 1] == '&')
808 src
= sub_actual (src
+ 2, in
, &t
, formal_hash
, '\'', out
, 1);
810 sb_add_char (out
, in
->ptr
[src
++]);
814 /* FIXME: Why do we do this? */
815 /* At least in alternate mode this seems correct; without this
816 one can't append a literal to a parameter. */
817 src
= sub_actual (src
+ 1, in
, &t
, formal_hash
, '&', out
, 0);
820 else if (in
->ptr
[src
] == '\\')
823 if (src
< in
->len
&& in
->ptr
[src
] == '(')
825 /* Sub in till the next ')' literally. */
827 while (src
< in
->len
&& in
->ptr
[src
] != ')')
829 sb_add_char (out
, in
->ptr
[src
++]);
834 err
= _("missing `)'");
836 as_bad_where (macro
->file
, macro
->line
+ macro_line
, _("missing `)'"));
838 else if (src
< in
->len
&& in
->ptr
[src
] == '@')
840 /* Sub in the macro invocation number. */
844 sprintf (buffer
, "%d", macro_number
);
845 sb_add_string (out
, buffer
);
847 else if (src
< in
->len
&& in
->ptr
[src
] == '&')
849 /* This is a preprocessor variable name, we don't do them
851 sb_add_char (out
, '\\');
852 sb_add_char (out
, '&');
855 else if (macro_mri
&& src
< in
->len
&& ISALNUM (in
->ptr
[src
]))
860 if (ISDIGIT (in
->ptr
[src
]))
861 ind
= in
->ptr
[src
] - '0';
862 else if (ISUPPER (in
->ptr
[src
]))
863 ind
= in
->ptr
[src
] - 'A' + 10;
865 ind
= in
->ptr
[src
] - 'a' + 10;
867 for (f
= formals
; f
!= NULL
; f
= f
->next
)
869 if (f
->index
== ind
- 1)
871 if (f
->actual
.len
!= 0)
872 sb_add_sb (out
, &f
->actual
);
874 sb_add_sb (out
, &f
->def
);
882 src
= sub_actual (src
, in
, &t
, formal_hash
, '\'', out
, 0);
885 else if ((macro_alternate
|| macro_mri
)
886 && is_name_beginner (in
->ptr
[src
])
889 || (src
> 0 && in
->ptr
[src
- 1] == '@')))
892 || src
+ 5 >= in
->len
893 || strncasecmp (in
->ptr
+ src
, "LOCAL", 5) != 0
894 || ! ISWHITE (in
->ptr
[src
+ 5]))
897 src
= sub_actual (src
, in
, &t
, formal_hash
,
898 (macro_strip_at
&& inquote
) ? '@' : '\'',
903 src
= sb_skip_white (src
+ 5, in
);
904 while (in
->ptr
[src
] != '\n')
907 formal_entry
*f
= new_formal ();
909 src
= get_token (src
, in
, &f
->name
);
910 name
= sb_terminate (&f
->name
);
911 if (! hash_find (formal_hash
, name
))
916 f
->index
= LOCAL_INDEX
;
920 sprintf (buf
, IS_ELF
? ".LL%04x" : "LL%04x", ++loccnt
);
921 sb_add_string (&f
->actual
, buf
);
923 err
= hash_jam (formal_hash
, name
, f
);
929 as_bad_where (macro
->file
,
930 macro
->line
+ macro_line
,
931 _("`%s' was already used as parameter (or another local) name"),
936 src
= sb_skip_comma (src
, in
);
940 else if (in
->ptr
[src
] == '"'
941 || (macro_mri
&& in
->ptr
[src
] == '\''))
944 sb_add_char (out
, in
->ptr
[src
++]);
946 else if (in
->ptr
[src
] == '@' && macro_strip_at
)
950 && in
->ptr
[src
] == '@')
952 sb_add_char (out
, '@');
957 && in
->ptr
[src
] == '='
959 && in
->ptr
[src
+ 1] == '=')
964 src
= get_token (src
+ 2, in
, &t
);
965 ptr
= (formal_entry
*) hash_find (formal_hash
, sb_terminate (&t
));
968 /* FIXME: We should really return a warning string here,
969 but we can't, because the == might be in the MRI
970 comment field, and, since the nature of the MRI
971 comment field depends upon the exact instruction
972 being used, we don't have enough information here to
973 figure out whether it is or not. Instead, we leave
974 the == in place, which should cause a syntax error if
975 it is not in a comment. */
976 sb_add_char (out
, '=');
977 sb_add_char (out
, '=');
984 sb_add_string (out
, "-1");
988 sb_add_char (out
, '0');
994 if (in
->ptr
[src
] == '\n')
996 sb_add_char (out
, in
->ptr
[src
++]);
1002 while (loclist
!= NULL
)
1007 /* Setting the value to NULL effectively deletes the entry. We
1008 avoid calling hash_delete because it doesn't reclaim memory. */
1009 hash_jam (formal_hash
, sb_terminate (&loclist
->name
), NULL
);
1010 del_formal (loclist
);
1017 /* Assign values to the formal parameters of a macro, and expand the
1021 macro_expand (int idx
, sb
*in
, macro_entry
*m
, sb
*out
)
1026 int is_positional
= 0;
1029 const char *err
= NULL
;
1033 /* Reset any old value the actuals may have. */
1034 for (f
= m
->formals
; f
; f
= f
->next
)
1035 sb_reset (&f
->actual
);
1037 while (f
!= NULL
&& f
->index
< 0)
1042 /* The macro may be called with an optional qualifier, which may
1043 be referred to in the macro body as \0. */
1044 if (idx
< in
->len
&& in
->ptr
[idx
] == '.')
1046 /* The Microtec assembler ignores this if followed by a white space.
1047 (Macro invocation with empty extension) */
1050 && in
->ptr
[idx
] != ' '
1051 && in
->ptr
[idx
] != '\t')
1053 formal_entry
*n
= new_formal ();
1055 n
->index
= QUAL_INDEX
;
1057 n
->next
= m
->formals
;
1060 idx
= get_any_string (idx
, in
, &n
->actual
);
1065 /* Peel off the actuals and store them away in the hash tables' actuals. */
1066 idx
= sb_skip_white (idx
, in
);
1067 while (idx
< in
->len
)
1071 /* Look and see if it's a positional or keyword arg. */
1073 while (scan
< in
->len
1074 && !ISSEP (in
->ptr
[scan
])
1075 && !(macro_mri
&& in
->ptr
[scan
] == '\'')
1076 && (!macro_alternate
&& in
->ptr
[scan
] != '='))
1078 if (scan
< in
->len
&& !macro_alternate
&& in
->ptr
[scan
] == '=')
1082 /* It's OK to go from positional to keyword. */
1084 /* This is a keyword arg, fetch the formal name and
1085 then the actual stuff. */
1087 idx
= get_token (idx
, in
, &t
);
1088 if (in
->ptr
[idx
] != '=')
1090 err
= _("confusion in formal parameters");
1094 /* Lookup the formal in the macro's list. */
1095 ptr
= (formal_entry
*) hash_find (m
->formal_hash
, sb_terminate (&t
));
1097 as_bad (_("Parameter named `%s' does not exist for macro `%s'"),
1102 /* Insert this value into the right place. */
1103 if (ptr
->actual
.len
)
1105 as_warn (_("Value for parameter `%s' of macro `%s' was already specified"),
1108 sb_reset (&ptr
->actual
);
1110 idx
= get_any_string (idx
+ 1, in
, &ptr
->actual
);
1111 if (ptr
->actual
.len
> 0)
1117 /* This is a positional arg. */
1121 err
= _("can't mix positional and keyword arguments");
1132 err
= _("too many positional arguments");
1139 for (pf
= &m
->formals
; *pf
!= NULL
; pf
= &(*pf
)->next
)
1140 if ((*pf
)->index
>= c
)
1141 c
= (*pf
)->index
+ 1;
1148 if (f
->type
!= FORMAL_VARARG
)
1149 idx
= get_any_string (idx
, in
, &f
->actual
);
1152 sb_add_buffer (&f
->actual
, in
->ptr
+ idx
, in
->len
- idx
);
1155 if (f
->actual
.len
> 0)
1161 while (f
!= NULL
&& f
->index
< 0);
1165 idx
= sb_skip_comma (idx
, in
);
1168 if (in
->ptr
[idx
] == ',')
1170 if (ISWHITE (in
->ptr
[idx
]))
1177 for (ptr
= m
->formals
; ptr
; ptr
= ptr
->next
)
1179 if (ptr
->type
== FORMAL_REQUIRED
&& ptr
->actual
.len
== 0)
1180 as_bad (_("Missing value for required parameter `%s' of macro `%s'"),
1190 sb_add_string (&t
, macro_strip_at
? "$NARG" : "NARG");
1191 ptr
= (formal_entry
*) hash_find (m
->formal_hash
, sb_terminate (&t
));
1192 sprintf (buffer
, "%d", narg
);
1193 sb_add_string (&ptr
->actual
, buffer
);
1196 err
= macro_expand_body (&m
->sub
, out
, m
->formals
, m
->formal_hash
, m
);
1199 /* Discard any unnamed formal arguments. */
1207 if ((*pf
)->name
.len
!= 0)
1225 /* Check for a macro. If one is found, put the expansion into
1226 *EXPAND. Return 1 if a macro is found, 0 otherwise. */
1229 check_macro (const char *line
, sb
*expand
,
1230 const char **error
, macro_entry
**info
)
1237 if (! is_name_beginner (*line
)
1238 && (! macro_mri
|| *line
!= '.'))
1242 while (is_part_of_name (*s
))
1244 if (is_name_ender (*s
))
1247 copy
= (char *) alloca (s
- line
+ 1);
1248 memcpy (copy
, line
, s
- line
);
1249 copy
[s
- line
] = '\0';
1250 for (cs
= copy
; *cs
!= '\0'; cs
++)
1251 *cs
= TOLOWER (*cs
);
1253 macro
= (macro_entry
*) hash_find (macro_hash
, copy
);
1258 /* Wrap the line up in an sb. */
1260 while (*s
!= '\0' && *s
!= '\n' && *s
!= '\r')
1261 sb_add_char (&line_sb
, *s
++);
1264 *error
= macro_expand (0, &line_sb
, macro
, expand
);
1268 /* Export the macro information if requested. */
1275 /* Free the memory allocated to a macro. */
1278 free_macro(macro_entry
*macro
)
1280 formal_entry
*formal
;
1282 for (formal
= macro
->formals
; formal
; )
1287 formal
= formal
->next
;
1290 hash_die (macro
->formal_hash
);
1291 sb_kill (¯o
->sub
);
1295 /* Delete a macro. */
1298 delete_macro (const char *name
)
1304 len
= strlen (name
);
1305 copy
= (char *) alloca (len
+ 1);
1306 for (i
= 0; i
< len
; ++i
)
1307 copy
[i
] = TOLOWER (name
[i
]);
1310 /* Since hash_delete doesn't free memory, just clear out the entry. */
1311 if ((macro
= hash_find (macro_hash
, copy
)) != NULL
)
1313 hash_jam (macro_hash
, copy
, NULL
);
1317 as_warn (_("Attempt to purge non-existant macro `%s'"), copy
);
1320 /* Handle the MRI IRP and IRPC pseudo-ops. These are handled as a
1321 combined macro definition and execution. This returns NULL on
1322 success, or an error message otherwise. */
1325 expand_irp (int irpc
, int idx
, sb
*in
, sb
*out
, int (*get_line
) (sb
*))
1329 struct hash_control
*h
;
1332 idx
= sb_skip_white (idx
, in
);
1335 if (! buffer_and_nest (NULL
, "ENDR", &sub
, get_line
))
1336 return _("unexpected end of file in irp or irpc");
1342 idx
= get_token (idx
, in
, &f
.name
);
1343 if (f
.name
.len
== 0)
1344 return _("missing model parameter");
1347 err
= hash_jam (h
, sb_terminate (&f
.name
), &f
);
1353 f
.type
= FORMAL_OPTIONAL
;
1357 idx
= sb_skip_comma (idx
, in
);
1360 /* Expand once with a null string. */
1361 err
= macro_expand_body (&sub
, out
, &f
, h
, 0);
1365 if (irpc
&& in
->ptr
[idx
] == '"')
1367 while (idx
< in
->len
)
1370 idx
= get_any_string (idx
, in
, &f
.actual
);
1373 if (in
->ptr
[idx
] == '"')
1377 nxt
= sb_skip_white (idx
+ 1, in
);
1384 sb_reset (&f
.actual
);
1385 sb_add_char (&f
.actual
, in
->ptr
[idx
]);
1388 err
= macro_expand_body (&sub
, out
, &f
, h
, 0);
1392 idx
= sb_skip_comma (idx
, in
);
1394 idx
= sb_skip_white (idx
, in
);
1399 sb_kill (&f
.actual
);
This page took 0.057122 seconds and 4 git commands to generate.