--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/nasmbuild/nasm-2.13rc9/asm/pragma.c	Thu Mar 30 20:58:41 2017 +0000
@@ -0,0 +1,218 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * Parse and handle [pragma] directives.  The preprocessor handles
+ * %pragma preproc directives separately, all other namespaces are
+ * simply converted to [pragma].
+ */
+
+#include "compiler.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "assemble.h"
+#include "error.h"
+
+/*
+ * Handle [pragma] directives.  [pragma] is generally produced by
+ * the %pragma preprocessor directive, which simply passes on any
+ * string that it finds *except* %pragma preproc.  The idea is
+ * that pragmas are of the form:
+ *
+ * %pragma <facility> <opname> [<options>...]
+ *
+ * ... where "facility" can be either a generic facility or a backend
+ * name.
+ *
+ * The following names are currently reserved for global facilities;
+ * so far none of these have any defined pragmas at all:
+ *
+ * preproc	- preprocessor
+ * asm		- assembler
+ * list		- listing generator
+ * file		- generic file handling
+ * input	- input file handling
+ * output	- backend-independent output handling
+ * debug	- backend-independent debug handling
+ * ignore	- dummy pragma (can be used to "comment out")
+ *
+ * This function should generally not error out if it doesn't understand
+ * what a pragma is for, for unknown arguments, etc; the whole point of
+ * a pragma is that future releases might add new ones that should be
+ * ignored rather than be an error.  Erroring out is acceptable for
+ * known pragmas suffering from parsing errors and so on.
+ *
+ * Adding default-suppressed warnings would, however, be a good idea
+ * at some point.
+ */
+static struct pragma_facility global_pragmas[] =
+{
+    { "preproc",	NULL }, /* This shouldn't happen... */
+    { "asm",		NULL },
+    { "list",		NULL },
+    { "file",		NULL },
+    { "input",		NULL },
+    { "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.)
+ */
+static bool search_pragma_list(const struct pragma_facility *list,
+                               const char *default_name,
+			       struct pragma *pragma)
+{
+    const struct pragma_facility *pf;
+    enum directive_result rv;
+
+    if (!list)
+	return false;
+
+    for (pf = list; pf->name; pf++) {
+        if (!nasm_stricmp(pragma->facility_name, pf->name))
+            goto found_it;
+    }
+
+    if (default_name && !nasm_stricmp(pragma->facility_name, default_name))
+        goto found_it;
+
+    return false;
+
+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;
+
+    switch (rv) {
+    case DIRR_UNKNOWN:
+        switch (pragma->opcode) {
+        case D_none:
+            nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_BAD_PRAGMA,
+                       "empty %%pragma %s", pragma->facility_name);
+            break;
+        default:
+            nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_UNKNOWN_PRAGMA,
+                       "unknown %%pragma %s %s",
+                       pragma->facility_name, pragma->opname);
+            break;
+        }
+        break;
+
+    case DIRR_OK:
+    case DIRR_ERROR:
+        break;                  /* Nothing to do */
+
+    case DIRR_BADPARAM:
+        /*
+         * This one is an error.  Don't use it if forward compatibility
+         * would be compromised, as opposed to an inherent error.
+         */
+        nasm_error(ERR_NONFATAL, "bad argument to %%pragma %s %s",
+                   pragma->facility_name, pragma->opname);
+        break;
+
+    default:
+        panic();
+    }
+    return true;
+}
+
+void process_pragma(char *str)
+{
+    struct pragma pragma;
+    char *p;
+
+    nasm_zero(&pragma);
+
+    pragma.facility_name = nasm_get_word(str, &p);
+    if (!pragma.facility_name) {
+	nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_BAD_PRAGMA,
+		   "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"))
+        return;
+
+    pragma.opname = nasm_get_word(p, &p);
+    if (!pragma.opname)
+        pragma.opcode = D_none;
+    else
+        pragma.opcode = find_directive(pragma.opname);
+
+    pragma.tail = nasm_skip_spaces(p);
+
+    /* Look for a global pragma namespace */
+    if (search_pragma_list(global_pragmas, NULL, &pragma))
+	return;
+
+    /* Look to see if it is an output backend pragma */
+    if (search_pragma_list(ofmt->pragmas, ofmt->shortname, &pragma))
+	return;
+
+    /* Look to see if it is a debug format pragma */
+    if (search_pragma_list(dfmt->pragmas, dfmt->shortname, &pragma))
+	return;
+
+    /*
+     * Note: it would be nice to warn for an unknown namespace,
+     * but in order to do so we need to walk *ALL* the backends
+     * in order to make sure we aren't dealing with a pragma that
+     * is for another backend.  On the other hand, that could
+     * also be a warning with a separate warning flag.
+     *
+     * Leave this for the future, however, the warning classes are
+     * already defined for future compatibility.
+     */
+}