1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2018 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 * ----------------------------------------------------------------------- */
35 * Parse and handle [pragma] directives. The preprocessor handles
36 * %pragma preproc directives separately, all other namespaces are
37 * simply converted to [pragma].
52 static enum directive_result
output_pragma(const struct pragma
*pragma
);
53 static enum directive_result
limit_pragma(const struct pragma
*pragma
);
56 * Handle [pragma] directives. [pragma] is generally produced by
57 * the %pragma preprocessor directive, which simply passes on any
58 * string that it finds *except* %pragma preproc. The idea is
59 * that pragmas are of the form:
61 * %pragma <facility> <opname> [<options>...]
63 * ... where "facility" can be either a generic facility or a backend
66 * The following names are currently reserved for global facilities;
67 * so far none of these have any defined pragmas at all:
69 * preproc - preprocessor
70 * limit - limit setting
72 * list - listing generator
73 * file - generic file handling
74 * input - input file handling
75 * output - backend-independent output handling
76 * debug - backend-independent debug handling
77 * ignore - dummy pragma (can be used to "comment out")
79 * This function should generally not error out if it doesn't understand
80 * what a pragma is for, for unknown arguments, etc; the whole point of
81 * a pragma is that future releases might add new ones that should be
82 * ignored rather than be an error. Erroring out is acceptable for
83 * known pragmas suffering from parsing errors and so on.
85 * Adding default-suppressed warnings would, however, be a good idea
88 static struct pragma_facility global_pragmas
[] =
91 { "limit", limit_pragma
},
96 /* None of these should actually happen due to special handling */
97 { "preproc", NULL
}, /* Handled in the preprocessor by necessity */
105 * Search a pragma list for a known pragma facility and if so, invoke
106 * the handler. Return true if processing is complete.
107 * The "default name", if set, matches the final NULL entry (used
108 * for backends, so multiple backends can share the same list under
109 * some circumstances.)
111 static bool search_pragma_list(const struct pragma_facility
*list
,
112 const char *default_name
,
113 pragma_handler generic_handler
,
114 struct pragma
*pragma
)
116 const struct pragma_facility
*pf
;
117 enum directive_result rv
;
122 for (pf
= list
; pf
->name
; pf
++) {
123 if (!nasm_stricmp(pragma
->facility_name
, pf
->name
))
127 if (default_name
&& !nasm_stricmp(pragma
->facility_name
, default_name
))
133 pragma
->facility
= pf
;
135 /* If the handler is NULL all pragmas are unknown... */
137 rv
= pf
->handler(pragma
);
141 /* Is there an additional, applicable generic handler? */
142 if (rv
== DIRR_UNKNOWN
&& generic_handler
)
143 rv
= generic_handler(pragma
);
147 switch (pragma
->opcode
) {
149 nasm_error(ERR_WARNING
|ERR_PASS2
|ERR_WARN_BAD_PRAGMA
,
150 "empty %%pragma %s", pragma
->facility_name
);
153 nasm_error(ERR_WARNING
|ERR_PASS2
|ERR_WARN_UNKNOWN_PRAGMA
,
154 "unknown %%pragma %s %s",
155 pragma
->facility_name
, pragma
->opname
);
162 break; /* Nothing to do */
166 * This one is an error. Don't use it if forward compatibility
167 * would be compromised, as opposed to an inherent error.
169 nasm_error(ERR_NONFATAL
, "bad argument to %%pragma %s %s",
170 pragma
->facility_name
, pragma
->opname
);
179 void process_pragma(char *str
)
181 struct pragma pragma
;
186 pragma
.facility_name
= nasm_get_word(str
, &p
);
187 if (!pragma
.facility_name
) {
188 nasm_error(ERR_WARNING
|ERR_PASS2
|ERR_WARN_BAD_PRAGMA
,
189 "empty pragma directive");
190 return; /* Empty pragma */
194 * The facility "ignore" means just that; don't even complain of
195 * the absence of an operation.
197 if (!nasm_stricmp(pragma
.facility_name
, "ignore"))
201 * The "output" and "debug" facilities are aliases for the
202 * current output and debug formats, respectively.
204 if (!nasm_stricmp(pragma
.facility_name
, "output"))
205 pragma
.facility_name
= ofmt
->shortname
;
206 if (!nasm_stricmp(pragma
.facility_name
, "debug"))
207 pragma
.facility_name
= dfmt
->shortname
;
209 pragma
.opname
= nasm_get_word(p
, &p
);
211 pragma
.opcode
= D_none
;
213 pragma
.opcode
= directive_find(pragma
.opname
);
215 pragma
.tail
= nasm_trim_spaces(p
);
217 /* Look for a global pragma namespace */
218 if (search_pragma_list(global_pragmas
, NULL
, NULL
, &pragma
))
221 /* Look to see if it is an output backend pragma */
222 if (search_pragma_list(ofmt
->pragmas
, ofmt
->shortname
,
223 output_pragma
, &pragma
))
226 /* Look to see if it is a debug format pragma */
227 if (search_pragma_list(dfmt
->pragmas
, dfmt
->shortname
, NULL
, &pragma
))
231 * Note: it would be nice to warn for an unknown namespace,
232 * but in order to do so we need to walk *ALL* the backends
233 * in order to make sure we aren't dealing with a pragma that
234 * is for another backend. On the other hand, that could
235 * also be a warning with a separate warning flag.
237 * Leave this for the future, however, the warning classes are
238 * already defined for future compatibility.
243 * Generic pragmas that apply to all output backends; these are handled
244 * specially so they can be made selective based on the output format.
246 static enum directive_result
output_pragma(const struct pragma
*pragma
)
248 switch (pragma
->opcode
) {
251 set_label_mangle(LM_GPREFIX
, pragma
->tail
);
255 set_label_mangle(LM_GSUFFIX
, pragma
->tail
);
258 set_label_mangle(LM_LPREFIX
, pragma
->tail
);
261 set_label_mangle(LM_LSUFFIX
, pragma
->tail
);
269 * %pragma limit to set resource limits
271 static enum directive_result
limit_pragma(const struct pragma
*pragma
)
273 return nasm_set_limit(pragma
->opname
, pragma
->tail
);