aniani/nasm
0
0
Fork 1
mirror of https://github.com/netwide-assembler/nasm.git synced 2025-07-24 10:25:42 -04:00
Code

pragma: handle default name/fallback handler for NULL list; cleanups

Browse Source 
The previous code would fail to process any directive if the directive
list was NULL. However, we also need to process the default name
passed to search_pragma_list() (e.g. "elf32"), as well as the global
name (e.g. "output") and call the default handler in that case.

In the process, improve the handling such that if one handler returns
DIRR_UNKNOWN, try calling subsequent handlers in the list.

Finally, factor out as much as possible to generic handlers.

Signed-off-by: H. Peter Anvin <hpa@zytor.com>
This commit is contained in:
H. Peter Anvin 2019-09-30 13:14:29 -07:00
parent 9781db8906
commit 1dd926e8ce
1 changed files with 148 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

221
asm/pragma.c
View File

@ -47,7 +47,9 @@
#include "error.h"
#include "listing.h"
static enum directive_result ignore_pragma(const struct pragma *pragma);
static enum directive_result output_pragma(const struct pragma *pragma);
static enum directive_result debug_pragma(const struct pragma *pragma);
static enum directive_result limit_pragma(const struct pragma *pragma);
/*
@ -90,68 +92,114 @@ static struct pragma_facility global_pragmas[] =
{ "list", list_pragma },
{ "file", NULL },
{ "input", NULL },
{ "output", output_pragma },
{ "debug", debug_pragma },
{ "ignore", ignore_pragma },
/* None of these should actually happen due to special handling */
/* This will never actually get this far... */
{ "preproc", NULL }, /* Handled in the preprocessor by necessity */
{ "output", NULL },
{ "debug", NULL },
{ "ignore", NULL },
{ NULL, NULL }
};
/*
* Search a pragma list for a known pragma facility and if so, invoke
* the handler. Return true if processing is complete.
* The "default name", if set, matches the final NULL entry (used
* for backends, so multiple backends can share the same list under
* some circumstances.)
* Invoke a pragma handler
*/
static bool search_pragma_list(const struct pragma_facility *list,
const char *default_name,
pragma_handler generic_handler,
struct pragma *pragma)
static enum directive_result
call_pragma(const struct pragma_facility *pf, struct pragma *pragma)
{
const struct pragma_facility *pf;
enum directive_result rv;
if (!pf || !pf->handler)
return DIRR_UNKNOWN;
if (!list)
return false;
for (pf = list; pf->name; pf++) {
if (!nasm_stricmp(pragma->facility_name, pf->name))
goto found_it;
pragma->facility = pf;
return pf->handler(pragma);
}
if (default_name && !nasm_stricmp(pragma->facility_name, default_name))
goto found_it;
/*
* Search a pragma list for a known pragma facility and if so, invoke
* the handler. Return true if processing is complete. The "default
* name", *or def->name*, if set, matches the final NULL entry (used
* for backends, so multiple backends can share the same list under
* some circumstances, and the backends can implement common operations.)
*/
static enum directive_result
search_pragma_list(const struct pragma_facility *list,
const char *defaultname,
const struct pragma_facility *def,
const struct pragma *cpragma)
{
const struct pragma_facility *pf = NULL;
enum directive_result rv;
bool facility_match, is_default;
struct pragma pragma = *cpragma;
const char *facname = pragma.facility_name;
return false;
/* Is there a default facility and we match its name? */
is_default = def && def->name && !nasm_stricmp(facname, def->name);
facility_match = is_default;
/*
* Promote def->name to defaultname if both are set. This handles
* e.g. output -> elf32 so that we can handle elf32-specific
* directives in that handler.
*/
if (defaultname) {
if (is_default)
facname = defaultname;
else
facility_match = !nasm_stricmp(facname, defaultname);
}
if (facname && list) {
for (pf = list; pf->name; pf++) {
if (!nasm_stricmp(facname, pf->name)) {
facility_match = true;
rv = call_pragma(pf, &pragma);
if (rv != DIRR_UNKNOWN)
goto found_it;
}
}
if (facility_match) {
/*
* Facility name match but no matching directive; handler in NULL
* entry at end of list?
*/
rv = call_pragma(pf, &pragma);
if (rv != DIRR_UNKNOWN)
goto found_it;
}
}
if (facility_match) {
/*
* Facility match but still nothing: def->handler if it exists
*/
rv = call_pragma(def, &pragma);
} else {
/*
* No facility matched
*/
return DIRR_UNKNOWN;
}
/*
* Otherwise we found the facility but not any supported directive,
* fall through...
*/
found_it:
pragma->facility = pf;
/* If the handler is NULL all pragmas are unknown... */
if (pf->handler)
rv = pf->handler(pragma);
else
rv = DIRR_UNKNOWN;
/* Is there an additional, applicable generic handler? */
if (rv == DIRR_UNKNOWN && generic_handler)
rv = generic_handler(pragma);
switch (rv) {
case DIRR_UNKNOWN:
switch (pragma->opcode) {
switch (pragma.opcode) {
case D_none:
/*!
*!pragma-bad [off] empty or malformed %pragma
*!pragma-bad [off] malformed %pragma
*!=bad-pragma
*! warns about a malformed or otherwise unparsable
*! \c{%pragma} directive.
*/
nasm_warn(ERR_PASS2|WARN_PRAGMA_BAD,
"empty %%pragma %s", pragma->facility_name);
"empty %%pragma %s", pragma.facility_name);
break;
default:
/*!
@ -162,9 +210,10 @@ found_it:
*/
nasm_warn(ERR_PASS2|WARN_PRAGMA_UNKNOWN,
"unknown %%pragma %s %s",
pragma->facility_name, pragma->opname);
pragma.facility_name, pragma.opname);
break;
}
rv = DIRR_ERROR; /* Already printed an error message */
break;
case DIRR_OK:
@ -177,13 +226,13 @@ found_it:
* would be compromised, as opposed to an inherent error.
*/
nasm_error(ERR_NONFATAL, "bad argument to %%pragma %s %s",
pragma->facility_name, pragma->opname);
pragma.facility_name, pragma.opname);
break;
default:
panic();
}
return true;
return rv;
}
/* This warning message is intended for future use */
@ -194,8 +243,16 @@ found_it:
*! this particular assembly session. This is not yet implemented.
*/
/* Naked %pragma */
/*!
*!pragma-empty [off] empty %pragma directive
*! warns about a \c{%pragma} directive containing nothing.
*! This is treated identically to \c{%pragma ignore} except
*! for this optional warning.
*/
void process_pragma(char *str)
{
const struct pragma_facility *pf;
struct pragma pragma;
char *p;
@ -203,26 +260,11 @@ void process_pragma(char *str)
pragma.facility_name = nasm_get_word(str, &p);
if (!pragma.facility_name) {
nasm_warn(ERR_PASS2|WARN_PRAGMA_BAD,
"empty pragma directive");
return; /* Empty pragma */
}
/*
* The facility "ignore" means just that; don't even complain of
* the absence of an operation.
*/
if (!nasm_stricmp(pragma.facility_name, "ignore"))
/* Empty %pragma */
nasm_warn(ERR_PASS2|WARN_PRAGMA_EMPTY,
"empty %%pragma directive, ignored");
return;
/*
* The "output" and "debug" facilities are aliases for the
* current output and debug formats, respectively.
*/
if (!nasm_stricmp(pragma.facility_name, "output"))
pragma.facility_name = ofmt->shortname;
if (!nasm_stricmp(pragma.facility_name, "debug"))
pragma.facility_name = dfmt->shortname;
}
pragma.opname = nasm_get_word(p, &p);
if (!pragma.opname)
@ -232,17 +274,24 @@ void process_pragma(char *str)
pragma.tail = nasm_trim_spaces(p);
/* Look for a global pragma namespace */
if (search_pragma_list(global_pragmas, NULL, NULL, &pragma))
/*
* Search the global pragma namespaces. This is done
* as a loop rather than than letting search_pragma_list()
* just run, because we don't want to keep searching if
* we have a facility match, thus we want to call
* search_pragma_list() individually for each namespace.
*/
for (pf = global_pragmas; pf->name; pf++) {
if (search_pragma_list(NULL, NULL, pf, &pragma) != DIRR_UNKNOWN)
return;
}
/* Is it an output pragma? */
if (output_pragma(&pragma) != DIRR_UNKNOWN)
return;
/* Look to see if it is an output backend pragma */
if (search_pragma_list(ofmt->pragmas, ofmt->shortname,
output_pragma, &pragma))
return;
/* Look to see if it is a debug format pragma */
if (search_pragma_list(dfmt->pragmas, dfmt->shortname, NULL, &pragma))
/* Is it a debug pragma */
if (debug_pragma(&pragma) != DIRR_UNKNOWN)
return;
/*
@ -257,11 +306,30 @@ void process_pragma(char *str)
*/
}
/* %pragma ignore */
static enum directive_result ignore_pragma(const struct pragma *pragma)
{
(void)pragma;
return DIRR_OK; /* Even for D_none! */
}
/*
* Generic pragmas that apply to all output backends; these are handled
* specially so they can be made selective based on the output format.
* Process output and debug pragmas, by either list name or generic
* name. Note that the output/debug format list can hook the default
* names if they so choose.
*/
static enum directive_result output_pragma_common(const struct pragma *);
static enum directive_result output_pragma(const struct pragma *pragma)
{
static const struct pragma_facility
output_pragma_def = { "output", output_pragma_common };
return search_pragma_list(ofmt->pragmas, ofmt->shortname,
&output_pragma_def, pragma);
}
/* Generic pragmas that apply to all output backends */
static enum directive_result output_pragma_common(const struct pragma *pragma)
{
switch (pragma->opcode) {
case D_PREFIX:
@ -283,6 +351,15 @@ static enum directive_result output_pragma(const struct pragma *pragma)
}
}
static enum directive_result debug_pragma(const struct pragma *pragma)
{
static const struct pragma_facility
debug_pragma_def = { "debug", NULL };
return search_pragma_list(dfmt->pragmas, dfmt->shortname,
&debug_pragma_def, pragma);
}
/*
* %pragma limit to set resource limits
*/