kit

c.c (5341B)

---

 #include "c.h"
 
 #include "decl/decl.h"
 #include "lex/lex.h"
 #include "parse/parse.h"
 #include "pp/pp.h"
 
 static SrcLoc c_no_loc(void) {
   SrcLoc loc;
   loc.file_id = 0;
   loc.line = 0;
   loc.col = 0;
   return loc;
 }
 
 static _Noreturn void c_bad_options(Compiler* c, const char* msg) {
   compiler_panic(c, c_no_loc(), "bad C frontend options: %.*s",
                  KIT_SLICE_ARG(kit_slice_cstr(msg)));
 }
 
 static void c_apply_pp_options(Pp* pp, const KitPreprocessOptions* opts) {
   u32 i;
 
   for (i = 0; i < opts->ninclude_dirs; ++i) {
     pp_add_include_dir(pp, opts->include_dirs[i], 0);
   }
   for (i = 0; i < opts->nsystem_include_dirs; ++i) {
     pp_add_include_dir(pp, opts->system_include_dirs[i], 1);
   }
   for (i = 0; i < opts->ndefines; ++i) {
     const char* body =
         opts->defines[i].body.len ? opts->defines[i].body.s : "1";
     pp_define(pp, opts->defines[i].name.s, body);
   }
   for (i = 0; i < opts->nundefines; ++i) {
     pp_undef(pp, opts->undefines[i].s);
   }
 }
 
 typedef struct CFrontend {
   KitCompiler* c;
 } CFrontend;
 
 static KitFrontendState* c_frontend_new(KitCompiler* c) {
   KitHeap* h;
   CFrontend* fe;
   if (!c) return NULL;
   h = kit_compiler_context(c)->heap;
   fe = (CFrontend*)h->alloc(h, sizeof(*fe), _Alignof(CFrontend));
   if (!fe) return NULL;
   fe->c = c;
   return (KitFrontendState*)fe;
 }
 
 static KitStatus c_frontend_compile_cg(KitFrontendState* frontend,
                                        const KitFrontendCompileOptions* fe_opts,
                                        const KitSourceInput* input, KitCg* cg) {
   CFrontend* fe = (CFrontend*)frontend;
   KitCompiler* c;
   /* Code, diagnostics, and preprocessor settings all arrive on the common
    * KitFrontendCompileOptions; the C frontend uses no language_options. */
   const KitSlice* bytes;
   Pool* pool;
   Lexer* lex;
   Pp* pp;
   DeclTable* decls;
 
   if (!fe || !fe->c) return KIT_INVALID;
   c = fe->c;
   if (!fe_opts || !input || !cg) c_bad_options(c, "compile args missing");
   bytes = &input->bytes;
 
   kit_frontend_metrics_scope_begin(c, "compile.c.setup");
   kit_frontend_metrics_scope_begin(c, "compile.c.pool_new");
   pool = c_pool_new(c);
   kit_frontend_metrics_scope_end(c, "compile.c.pool_new");
   if (!pool) compiler_panic(c, c_no_loc(), "C compiler out of memory");
   kit_frontend_metrics_scope_begin(c, "compile.c.lex_open");
   lex = lex_open_mem(c, input->name.s, bytes->s, bytes->len);
   if (lex) lex_skip_shebang(lex);
   kit_frontend_metrics_scope_end(c, "compile.c.lex_open");
   kit_frontend_metrics_scope_begin(c, "compile.c.pp_new");
   pp = pp_new(c);
   kit_frontend_metrics_scope_end(c, "compile.c.pp_new");
   if (!lex || !pp || !cg)
     compiler_panic(c, c_no_loc(), "C compiler out of memory");
   kit_frontend_metrics_scope_begin(c, "compile.c.decl_new");
   decls = decl_new(c, pool, cg);
   kit_frontend_metrics_scope_end(c, "compile.c.decl_new");
   kit_frontend_metrics_scope_end(c, "compile.c.setup");
 
   kit_frontend_metrics_scope_begin(c, "compile.c.pp_options");
   kit_frontend_metrics_count(c, "compile.c.pp_include_dirs",
                              fe_opts->preprocess.ninclude_dirs);
   kit_frontend_metrics_count(c, "compile.c.pp_system_include_dirs",
                              fe_opts->preprocess.nsystem_include_dirs);
   kit_frontend_metrics_count(c, "compile.c.pp_defines",
                              fe_opts->preprocess.ndefines);
   kit_frontend_metrics_count(c, "compile.c.pp_undefines",
                              fe_opts->preprocess.nundefines);
   c_apply_pp_options(pp, &fe_opts->preprocess);
   kit_frontend_metrics_scope_end(c, "compile.c.pp_options");
   kit_frontend_metrics_scope_begin(c, "compile.c.pp_push_input");
   pp_push_input(pp, lex);
   kit_frontend_metrics_scope_end(c, "compile.c.pp_push_input");
 
   kit_frontend_metrics_scope_begin(c, "compile.c.parse_codegen");
   parse_c(c, pool, pp, decls, cg, (KitSymVis)fe_opts->code.default_visibility);
   kit_frontend_metrics_scope_end(c, "compile.c.parse_codegen");
 
   kit_frontend_metrics_scope_begin(c, "compile.c.cleanup");
   decl_free(decls);
   pp_free(pp);
   c_pool_free(pool);
   kit_frontend_metrics_scope_end(c, "compile.c.cleanup");
   return KIT_OK;
 }
 
 static void c_frontend_free(KitFrontendState* frontend) {
   CFrontend* fe = (CFrontend*)frontend;
   KitHeap* h;
   if (!fe) return;
   h = kit_compiler_context(fe->c)->heap;
   h->free(h, fe, sizeof(*fe));
 }
 
 /* C is just another frontend: it claims its source/header extensions so the
  * language-for-path lookup resolves them by the same registry walk as every
  * other language, with no special fallback. */
 static const KitSlice c_extensions[] = {KIT_SLICE_LIT("c"), KIT_SLICE_LIT("h")};
 /* Canonical `-x` name; mirrors the driver's "c" spelling. */
 static const KitSlice c_names[] = {KIT_SLICE_LIT("c")};
 
 const KitFrontendVTable kit_c_frontend_vtable = {
     c_frontend_new,
     c_frontend_compile_cg,
     NULL, /* compile_obj: semantic frontends are wrapped by compile session */
     c_frontend_free,
     c_extensions,
     (uint32_t)(sizeof c_extensions / sizeof c_extensions[0]),
     c_names,
     (uint32_t)(sizeof c_names / sizeof c_names[0]),
     /* commit/abort: C has no durable cross-compile state yet */
     NULL,
     NULL,
     {true, KIT_FRONTEND_LTO_CG, false},
     NULL, /* parse_options: C has no frontend-specific flags */
     NULL, /* free_options */
 };