kit

cpp.c (10734B)

---

 #include <kit/compile.h>
 #include <kit/core.h>
 #include <kit/preprocess.h>
 #include <stdint.h>
 
 #include "cflags.h"
 #include "driver.h"
 #include "hosted.h"
 #include "runtime.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;
   int freestanding;
   int nostdinc;
   const char* sysroot;
   const char* support_dir;
   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 (default: host)\n"
           "  -h, --help        Show this help and exit\n"
           "  --version         Show Kit version and exit\n"
           "\n"
           "TARGETS\n"
           "  Hosted triples: aarch64/x86_64/riscv64 with linux-gnu,\n"
           "  linux-musl, or freebsd where listed by the release;\n"
           "  aarch64/x86_64-windows, aarch64-linux-android21, and\n"
           "  aarch64/x86_64-apple-darwin. Freestanding triples are\n"
           "  aarch64-none-elf, x86_64-none-elf, riscv64-none-elf,\n"
           "  riscv32-none-elf, and arm-none-eabi. Hosted cross headers require\n"
           "  explicit -isystem/-I paths or the sysroot workflow in `kit cc`.\n"
           "\n"
           "INPUT/OUTPUT NOTES\n"
           "  `-` is accepted as stdin. A leading-dash file is not introduced\n"
           "  with `--` in this release; spell it as ./-name.c. Normal output\n"
           "  is stdout, so diagnostics remain on stderr when output is piped.\n"
           "\n"
           "EXAMPLES\n"
           "  kit cpp -I include -DVALUE=42 source.c -o source.i\n"
           "  printf '#if FLAG\\nok\\n#endif\\n' | kit cpp -DFLAG=1 -\n"
           "  kit cpp ./-generated.c\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_err_unknown_target(CPP_TOOL, argv[i]);
         return 1;
       }
       continue;
     }
 
     if (driver_streq(a, "--sysroot") || driver_streq(a, "-isysroot")) {
       if (++i >= argc) {
         driver_errf(CPP_TOOL, "%s requires an argument", a);
         return 1;
       }
       o->sysroot = argv[i];
       continue;
     }
     if (driver_strneq(a, "--sysroot=", 10)) {
       o->sysroot = a + 10;
       continue;
     }
     if (driver_streq(a, "--support-dir")) {
       if (++i >= argc) {
         driver_errf(CPP_TOOL, "--support-dir requires an argument");
         return 1;
       }
       o->support_dir = argv[i];
       continue;
     }
     if (driver_strneq(a, "--support-dir=", 14)) {
       o->support_dir = a + 14;
       continue;
     }
     if (driver_streq(a, "-ffreestanding")) {
       o->freestanding = 1;
       continue;
     }
     if (driver_streq(a, "-fhosted")) {
       o->freestanding = 0;
       continue;
     }
     if (driver_streq(a, "-nostdinc")) {
       o->nostdinc = 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};
   DriverHostedPlan hosted = {0};
   DriverRuntimeSupport runtime = {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;
   int runtime_resolved = 0;
   int hosted_engaged = 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 + DRIVER_HOSTED_MAX_DEFINES +
                              DRIVER_HOSTED_MAX_INCLUDES) != 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;
   }
   ctx = driver_env_to_context(&env);
 
   if (!o.freestanding && !o.nostdinc &&
       (o.sysroot || driver_target_default_hosted_profile(o.target))) {
     DriverHostedRequest req = {0};
     uint32_t i;
     req.env = &env;
     req.tool = CPP_TOOL;
     req.target = o.target;
     req.sysroot = o.sysroot;
     req.link_inputs = 0;
     if (driver_hosted_resolve(&req, &hosted) != 0) goto out;
     hosted_engaged = hosted.profile_name != NULL;
     for (i = 0; i < hosted.nsystem_includes; ++i)
       cf.system_include_dirs[cf.nsystem_include_dirs++] =
           hosted.system_includes[i];
     for (i = 0; i < hosted.ndefines; ++i)
       cf.defines[cf.ndefines++] = hosted.defines[i];
   }
 
   if (driver_runtime_resolve(&env, o.support_dir, argv[0], &runtime) != 0) {
     driver_errf(CPP_TOOL, "support dir not found");
     goto out;
   }
   runtime_resolved = 1;
   if (!o.nostdinc &&
       (hosted_engaged
            ? driver_runtime_append_freestanding_headers(&runtime, &cf)
            : driver_runtime_add_freestanding_headers(&runtime, &cf)) != 0) {
     driver_errf(CPP_TOOL, "failed to add freestanding headers");
     goto out;
   }
   driver_cflags_fill_pp(&cf, &pp);
 
   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);
   if (runtime_resolved) driver_runtime_support_fini(&env, &runtime);
   driver_hosted_plan_fini(&env, &hosted);
   driver_target_features_fini(&tf, &env);
   driver_cflags_fini(&cf, &env);
   driver_env_fini(&env);
   return rc;
 }