--- /dev/null
+/*
+ * Invoke an external C preprocessor
+ *
+ * Copyright (C) 2007 Paul Barker
+ * Copyright (C) 2001-2007 Peter Johnson
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. 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 AUTHOR AND OTHER 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 AUTHOR OR OTHER 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.
+ */
+
+#include <util.h>
+#include <libyasm.h>
+
+/* TODO: Find some non-arbitrary values for these constants. */
+#define TMP_BUF_SIZE 4096
+#define CMDLINE_SIZE 32770
+
+extern int isatty(int);
+
+/* Flags. */
+#define CPP_HAS_BEEN_INVOKED 0x01
+
+typedef struct cpp_arg_entry {
+ TAILQ_ENTRY(cpp_arg_entry) entry;
+
+ char *op;
+ char *param;
+} cpp_arg_entry;
+
+typedef struct yasm_preproc_cpp {
+ yasm_preproc_base preproc; /* base structure */
+
+ TAILQ_HEAD(, cpp_arg_entry) cpp_args;
+ cpp_arg_entry *pos;
+
+ FILE *f_in, *f_out;
+ yasm_linemap *cur_lm;
+ yasm_errwarns *errwarns;
+
+ int flags;
+} yasm_preproc_cpp;
+
+yasm_preproc_module yasm_cpp_LTX_preproc;
+
+/* TODO: Make these filenames safer and more portable, maybe using tmpnam()? */
+static const char *in_filename = ".cpp.in";
+static const char *out_filename = ".cpp.out";
+
+/* Invoke the c preprocessor. */
+static void
+cpp_invoke(yasm_preproc_cpp *pp)
+{
+ int r;
+ char *cmdline, *p, *limit, *tmp;
+ cpp_arg_entry *arg;
+ size_t op_len, param_len, sz;
+
+ /* Initialize command line. */
+ cmdline = p = yasm_xmalloc(CMDLINE_SIZE);
+ limit = p + CMDLINE_SIZE;
+ strcpy(p, "cpp");
+ p += 3;
+
+ /* Append arguments from the list. */
+ TAILQ_FOREACH(arg, (&pp->cpp_args), entry) {
+ /*
+ We need a space before arg->op and a space before arg->param, so
+ 2 extra characters.
+ */
+ op_len = strlen(arg->op);
+ param_len = strlen(arg->param);
+ sz = op_len + param_len + 2;
+
+ if (p + sz >= limit)
+ yasm__fatal("command line too long");
+
+ *p++ = ' ';
+ strcpy(p, arg->op);
+ p += op_len;
+ *p++ = ' ';
+ strcpy(p, arg->param);
+ p += param_len;
+
+ yasm_xfree(arg->param);
+ }
+
+ /* Append final arguments. */
+ r = asprintf(&tmp, " -x assembler-with-cpp -o %s %s",
+ out_filename, in_filename);
+ if (r == -1)
+ yasm__fatal("failed to construct command line for cpp");
+
+ /* r is the length of the string stored in tmp. */
+ if (p + r + 1 >= limit)
+ yasm__fatal("command line too long");
+
+ strcpy(p, tmp);
+ yasm_xfree(tmp);
+ p += r;
+ *p = '\0';
+
+#if 0
+ /* Print the command line before executing. */
+ printf("%s\n", cmdline);
+#endif
+ r = system(cmdline);
+ if (r)
+ yasm__fatal("C preprocessor failed");
+
+ yasm_xfree(cmdline);
+}
+
+static yasm_preproc *
+cpp_preproc_create(FILE *f, const char *in, yasm_linemap *lm,
+ yasm_errwarns *errwarns)
+{
+ yasm_preproc_cpp *pp = yasm_xmalloc(sizeof(yasm_preproc_cpp));
+
+ pp->preproc.module = &yasm_cpp_LTX_preproc;
+ pp->f_in = f;
+ pp->f_out = NULL;
+ pp->cur_lm = lm;
+ pp->errwarns = errwarns;
+ pp->flags = 0;
+
+ pp->pos = NULL;
+ TAILQ_INIT(&pp->cpp_args);
+
+ return (yasm_preproc *)pp;
+}
+
+static void
+cpp_preproc_destroy(yasm_preproc *preproc)
+{
+ yasm_preproc_cpp *pp = (yasm_preproc_cpp *)preproc;
+
+ if (pp->f_out) {
+ fclose(pp->f_out);
+ }
+
+ /* Remove both temporary files. */
+ remove(in_filename);
+ remove(out_filename);
+
+ yasm_xfree(preproc);
+}
+
+static size_t
+cpp_preproc_input(yasm_preproc *preproc, char *buf, size_t max_size)
+{
+ size_t n;
+ FILE *f_tmp;
+ int tty;
+ char *tmp_buf;
+ yasm_preproc_cpp *pp = (yasm_preproc_cpp *)preproc;
+
+ if (! (pp->flags & CPP_HAS_BEEN_INVOKED) ) {
+ pp->flags |= CPP_HAS_BEEN_INVOKED;
+
+ tmp_buf = (char *)yasm_xmalloc(TMP_BUF_SIZE);
+
+ f_tmp = fopen(in_filename, "w");
+
+ tty = (isatty(fileno(f_tmp)) > 0);
+ while (!feof(pp->f_in)) {
+ if (tty) {
+ /* TODO: Handle reading from tty into tmp_buf. */
+ yasm__fatal("incapable of reading from a tty");
+ } else {
+ if (((n = fread(tmp_buf, 1, TMP_BUF_SIZE, pp->f_in)) == 0) &&
+ ferror(pp->f_in)) {
+ yasm_error_set(YASM_ERROR_IO,
+ N_("error when reading from input file"));
+ yasm_errwarn_propagate(pp->errwarns,
+ yasm_linemap_get_current(pp->cur_lm));
+ }
+ }
+
+ if (fwrite(tmp_buf, 1, n, f_tmp) != n) {
+ yasm__fatal("error writing to temporary file");
+ }
+ }
+
+ yasm_xfree(tmp_buf);
+ fclose(f_tmp);
+
+ cpp_invoke(pp);
+
+ pp->f_out = fopen(out_filename, "r");
+
+ if (!pp->f_out) {
+ yasm__fatal("Could not open preprocessed file \"%s\"", out_filename);
+ }
+ }
+
+ /*
+ Once the preprocessor has been run, we're just dealing with a normal
+ file.
+ */
+ if (((n = fread(buf, 1, max_size, pp->f_out)) == 0) &&
+ ferror(pp->f_out)) {
+ yasm_error_set(YASM_ERROR_IO, N_("error when reading from preprocessed file"));
+ yasm_errwarn_propagate(pp->errwarns,
+ yasm_linemap_get_current(pp->cur_lm));
+ }
+
+ return n;
+}
+
+static size_t
+cpp_preproc_get_included_file(yasm_preproc *preproc, char *buf,
+ size_t max_size)
+{
+ /* TODO */
+
+ return 0;
+}
+
+static void
+cpp_preproc_add_include_file(yasm_preproc *preproc, const char *filename)
+{
+ yasm_preproc_cpp *pp = (yasm_preproc_cpp *)preproc;
+
+ cpp_arg_entry *arg = yasm_xmalloc(sizeof(cpp_arg_entry));
+ arg->op = "-include";
+ arg->param = yasm__xstrdup(filename);
+
+ TAILQ_INSERT_TAIL(&pp->cpp_args, arg, entry);
+}
+
+static void
+cpp_preproc_predefine_macro(yasm_preproc *preproc, const char *macronameval)
+{
+ yasm_preproc_cpp *pp = (yasm_preproc_cpp *)preproc;
+
+ cpp_arg_entry *arg = yasm_xmalloc(sizeof(cpp_arg_entry));
+ arg->op = "-D";
+ arg->param = yasm__xstrdup(macronameval);
+
+ TAILQ_INSERT_TAIL(&pp->cpp_args, arg, entry);
+}
+
+static void
+cpp_preproc_undefine_macro(yasm_preproc *preproc, const char *macroname)
+{
+ yasm_preproc_cpp *pp = (yasm_preproc_cpp *)preproc;
+
+ cpp_arg_entry *arg = yasm_xmalloc(sizeof(cpp_arg_entry));
+ arg->op = "-U";
+ arg->param = yasm__xstrdup(macroname);
+
+ TAILQ_INSERT_TAIL(&pp->cpp_args, arg, entry);
+}
+
+static void
+cpp_preproc_define_builtin(yasm_preproc *preproc, const char *macronameval)
+{
+ /* Handle a builtin as if it were a predefine. */
+ cpp_preproc_predefine_macro(preproc, macronameval);
+}
+
+yasm_preproc_module yasm_cpp_LTX_preproc = {
+ "Run input through enternal C preprocessor",
+ "cpp",
+ cpp_preproc_create,
+ cpp_preproc_destroy,
+ cpp_preproc_input,
+ cpp_preproc_get_included_file,
+ cpp_preproc_add_include_file,
+ cpp_preproc_predefine_macro,
+ cpp_preproc_undefine_macro,
+ cpp_preproc_define_builtin
+};
+
+/*
+ TODO: We will need to pass the list of include directories to the external
+ preprocessor.
+*/
projects / yasm / commitdiff