kit

cpp.c (7292B)

---

 #include <kit/compile.h>
 #include <kit/core.h>
 #include <kit/preprocess.h>
 #include <stdint.h>
 
 #include "cflags.h"
 #include "driver.h"
 
 /* `kit cpp` — standalone C preprocessor. Reads one C source (path or
  * `-` for stdin), writes the preprocessed token stream to `-o PATH` or
  * stdout. Feature-equivalent to `kit cc -E` but without cc's source-
  * classification / link-input scaffolding.
  *
  * Flag surface is the cflags subset shared with cc + as:
  *   -I DIR, -IDIR        user include path
  *   -isystem DIR         system include path
  *   -D NAME[=BODY]       define
  *   -U NAME              undefine
  *   -o PATH              output (default: stdout)
  *   -target TRIPLE       cross-target (default: host)
  *   -                    stdin source
  *
  * The classical cpp-only flags (-P, -dM, -C, -CC) are not yet supported
  * by kit's preprocessor — they would land equally in `kit cc -E`. */
 
 #define CPP_TOOL "cpp"
 
 typedef struct CppOptions {
   const char* output_path;
   const char* source_path; /* NULL when stdin source */
   int from_stdin;
   KitTargetSpec target;
 } CppOptions;
 
 void driver_help_cpp(void) {
   driver_printf(
       "%.*s",
       KIT_SLICE_ARG(KIT_SLICE_LIT(
           "kit cpp — standalone C preprocessor\n"
           "\n"
           "USAGE\n"
           "  kit cpp [options] INPUT.c\n"
           "  kit cpp [options] -            (read from stdin)\n"
           "\n"
           "DESCRIPTION\n"
           "  Runs the C preprocessor on a single input and writes the "
           "resulting\n"
           "  token stream to -o (or stdout when -o is absent). Functionally\n"
           "  equivalent to `kit cc -E` but without cc's link/source-input\n"
           "  classification.\n"
           "\n"
           "OPTIONS\n"
           "  -o PATH           Output path (default: stdout)\n"
           "  -I DIR, -IDIR     Add a user include directory\n"
           "  -isystem DIR      Add a system include directory\n"
           "  -D NAME[=BODY]    Define a preprocessor macro\n"
           "  -U NAME           Undefine a preprocessor macro\n"
           "  -target TRIPLE    Cross-target. See `kit cc --help` for the\n"
           "                    accepted arches/OSes. Default: host.\n"
           "  -h, --help        Show this help and exit\n"
           "\n"
           "EXIT CODES\n"
           "  0   success           1   preprocess / I/O error           2   "
           "bad "
           "usage\n")));
 }
 
 static void cpp_usage(void) {
   driver_errf(CPP_TOOL, "%.*s",
               KIT_SLICE_ARG(KIT_SLICE_LIT(
                   "usage: kit cpp [options] INPUT.c\n"
                   "       kit cpp --help    for full option reference")));
 }
 
 static int cpp_parse(int argc, char** argv, CppOptions* o, DriverEnv* env,
                      DriverCflags* cf, DriverTargetFeatures* tf) {
   int i;
 
   o->target = driver_host_target();
 
   for (i = 1; i < argc; ++i) {
     const char* a = argv[i];
     int r;
 
     r = driver_cflags_try_consume(cf, env, CPP_TOOL, argc, argv, &i);
     if (r < 0) return 1;
     if (r > 0) continue;
 
     if (driver_streq(a, "-o")) {
       if (++i >= argc) {
         driver_errf(CPP_TOOL, "-o requires an argument");
         return 1;
       }
       o->output_path = argv[i];
       continue;
     }
 
     if (driver_streq(a, "-target")) {
       if (++i >= argc) {
         driver_errf(CPP_TOOL, "-target requires an argument");
         return 1;
       }
       if (driver_target_from_triple(argv[i], &o->target) != 0) {
         driver_errf(CPP_TOOL, "unrecognized target: %.*s",
                     KIT_SLICE_ARG(kit_slice_cstr(argv[i])));
         return 1;
       }
       continue;
     }
 
     {
       int tr =
           driver_target_features_try_consume(tf, env, CPP_TOOL, argc, argv, &i);
       if (tr < 0) return 1;
       if (tr > 0) continue;
     }
 
     if (driver_streq(a, "-")) {
       if (o->source_path || o->from_stdin) {
         driver_errf(CPP_TOOL, "multiple inputs not supported");
         return 1;
       }
       o->from_stdin = 1;
       continue;
     }
 
     if (a[0] == '-' && a[1] != '\0') {
       driver_errf(CPP_TOOL, "unknown flag: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(a)));
       return 1;
     }
 
     if (o->source_path || o->from_stdin) {
       driver_errf(CPP_TOOL, "multiple inputs not supported");
       return 1;
     }
     o->source_path = a;
   }
 
   if (!o->source_path && !o->from_stdin) {
     driver_errf(CPP_TOOL, "no input file");
     cpp_usage();
     return 1;
   }
   return 0;
 }
 
 int driver_cpp(int argc, char** argv) {
   DriverEnv env;
   CppOptions o = {0};
   DriverCflags cf = {0};
   DriverTargetFeatures tf = {0};
   KitContext ctx;
   KitPreprocessOptions pp;
   KitTarget* target = NULL;
   KitCompiler* compiler = NULL;
   KitWriter* writer = NULL;
   KitFileData src = {0};
   KitSlice input;
   KitSlice input_name = KIT_SLICE_NULL;
   uint8_t* stdin_buf = NULL;
   size_t stdin_size = 0;
   int rc = 1;
   int loaded = 0;
 
   if (argc < 2 || driver_argv_wants_help(argc, argv, 1)) {
     driver_help_cpp();
     return 0;
   }
 
   driver_env_init(&env);
 
   if (driver_cflags_init(&cf, &env, argc) != 0 ||
       driver_target_features_init(&tf, &env, argc) != 0) {
     driver_errf(CPP_TOOL, "out of memory");
     driver_target_features_fini(&tf, &env);
     driver_cflags_fini(&cf, &env);
     driver_env_fini(&env);
     return 2;
   }
 
   if (cpp_parse(argc, argv, &o, &env, &cf, &tf) != 0) {
     driver_target_features_fini(&tf, &env);
     driver_cflags_fini(&cf, &env);
     driver_env_fini(&env);
     return 2;
   }
   driver_cflags_fill_pp(&cf, &pp);
 
   ctx = driver_env_to_context(&env);
 
   if (o.from_stdin) {
     if (!driver_read_stdin(&env, &stdin_buf, &stdin_size)) {
       driver_errf(CPP_TOOL, "failed to read stdin");
       goto out;
     }
     input_name = KIT_SLICE_LIT("<stdin>");
     input.data = stdin_buf;
     input.len = stdin_size;
   } else {
     if (ctx.file_io->read_all(ctx.file_io->user, o.source_path, &src) !=
         KIT_OK) {
       driver_errf(CPP_TOOL, "failed to read: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(o.source_path)));
       goto out;
     }
     loaded = 1;
     input_name = kit_slice_cstr(o.source_path);
     input.data = src.data;
     input.len = src.size;
   }
 
   if (o.output_path) {
     if (ctx.file_io->open_writer(ctx.file_io->user, o.output_path, &writer) !=
         KIT_OK) {
       driver_errf(CPP_TOOL, "failed to open output: %.*s",
                   KIT_SLICE_ARG(kit_slice_cstr(o.output_path)));
       goto out;
     }
   } else {
     writer = driver_stdout_writer(&env);
     if (!writer) {
       driver_errf(CPP_TOOL, "out of memory");
       goto out;
     }
   }
 
   if (driver_target_new(&ctx, o.target, &tf, CPP_TOOL, &target) != KIT_OK ||
       driver_compiler_new(target, &ctx, &compiler) != KIT_OK) {
     driver_errf(CPP_TOOL, "failed to initialize compiler");
     goto out;
   }
 
   rc = kit_cpp_preprocess(compiler, &pp, input_name, &input, writer) == KIT_OK
            ? 0
            : 1;
 
 out:
   if (compiler) driver_compiler_free(compiler);
   kit_target_free(target);
   if (writer) kit_writer_close(writer);
   if (loaded) ctx.file_io->release(ctx.file_io->user, &src);
   if (stdin_buf) driver_free(&env, stdin_buf, stdin_size);
   driver_target_features_fini(&tf, &env);
   driver_cflags_fini(&cf, &env);
   driver_env_fini(&env);
   return rc;
 }