kit

source.c (5597B)

---

 /* SourceManager — file-id authority for diagnostics, dependency output,
  * and DWARF. */
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "core/core.h"
 #include "core/heap.h"
 #include "core/pool.h"
 #include "core/slice.h"
 
 typedef struct SrcMgrFile {
   SourceFile info;
 } SrcMgrFile;
 
 typedef struct SrcMgrInclude {
   SourceInclude info;
 } SrcMgrInclude;
 
 struct SourceManager {
   Compiler* c;
   Heap* heap;
 
   SrcMgrFile* files;
   u32 nfiles;
   u32 files_cap;
 
   SrcMgrInclude* includes;
   u32 nincludes;
   u32 includes_cap;
 };
 
 struct SourceDepIter {
   SourceManager* sm;
   u32 idx;
 };
 
 static int files_grow(SourceManager* sm, u32 want) {
   u32 new_cap;
   SrcMgrFile* nf;
   if (want <= sm->files_cap) return 0;
   new_cap = sm->files_cap ? sm->files_cap * 2 : 16;
   while (new_cap < want) new_cap *= 2;
   nf = (SrcMgrFile*)sm->heap->realloc(
       sm->heap, sm->files, sizeof(*sm->files) * sm->files_cap,
       sizeof(*sm->files) * new_cap, _Alignof(SrcMgrFile));
   if (!nf) return 1;
   sm->files = nf;
   sm->files_cap = new_cap;
   return 0;
 }
 
 static int includes_grow(SourceManager* sm) {
   u32 new_cap;
   SrcMgrInclude* ni;
   if (sm->nincludes < sm->includes_cap) return 0;
   new_cap = sm->includes_cap ? sm->includes_cap * 2 : 16;
   ni = (SrcMgrInclude*)sm->heap->realloc(
       sm->heap, sm->includes, sizeof(*sm->includes) * sm->includes_cap,
       sizeof(*sm->includes) * new_cap, _Alignof(SrcMgrInclude));
   if (!ni) return 1;
   sm->includes = ni;
   sm->includes_cap = new_cap;
   return 0;
 }
 
 SourceManager* source_new(Compiler* c) {
   Heap* h = c->ctx->heap;
   SourceManager* sm =
       (SourceManager*)h->alloc(h, sizeof(*sm), _Alignof(SourceManager));
   if (!sm) return NULL;
   memset(sm, 0, sizeof(*sm));
   sm->c = c;
   sm->heap = h;
   if (files_grow(sm, 1)) {
     h->free(h, sm, sizeof(*sm));
     return NULL;
   }
   memset(&sm->files[0], 0, sizeof(sm->files[0]));
   sm->nfiles = 1;
   return sm;
 }
 
 void source_free(SourceManager* sm) {
   if (!sm) return;
   if (sm->files)
     sm->heap->free(sm->heap, sm->files, sizeof(*sm->files) * sm->files_cap);
   if (sm->includes)
     sm->heap->free(sm->heap, sm->includes,
                    sizeof(*sm->includes) * sm->includes_cap);
   sm->heap->free(sm->heap, sm, sizeof(*sm));
 }
 
 static KitStatus file_register(SourceManager* sm, Slice name,
                                SourceFileKind kind, int system_header,
                                u32* id_out) {
   Sym sym;
   u32 id;
   if (files_grow(sm, sm->nfiles + 1)) return KIT_NOMEM;
   sym = pool_intern_slice(sm->c->global, name);
   id = sm->nfiles++;
   memset(&sm->files[id], 0, sizeof(sm->files[id]));
   sm->files[id].info.id = id;
   sm->files[id].info.name = sym;
   sm->files[id].info.path = (kind == SRC_FILE_REAL) ? sym : 0;
   sm->files[id].info.kind = (u8)kind;
   sm->files[id].info.system_header = (u8)(system_header ? 1 : 0);
   *id_out = id;
   return KIT_OK;
 }
 
 KitStatus source_add_file(SourceManager* sm, const char* path,
                           int system_header, u32* id_out) {
   return file_register(sm, slice_from_cstr(path ? path : ""), SRC_FILE_REAL,
                        system_header, id_out);
 }
 
 KitStatus source_add_memory(SourceManager* sm, KitSlice name, u32* id_out) {
   return file_register(sm, name, SRC_FILE_MEMORY, 0, id_out);
 }
 
 KitStatus source_add_builtin(SourceManager* sm, KitSlice name, u32* id_out) {
   return file_register(sm, name, SRC_FILE_BUILTIN, 0, id_out);
 }
 
 KitStatus source_add_include(SourceManager* sm, u32 includer_file_id,
                              u32 included_file_id, SrcLoc include_loc,
                              int system) {
   if (includes_grow(sm)) return KIT_NOMEM;
   sm->includes[sm->nincludes].info.includer_file_id = includer_file_id;
   sm->includes[sm->nincludes].info.included_file_id = included_file_id;
   sm->includes[sm->nincludes].info.include_loc = include_loc;
   sm->includes[sm->nincludes].info.system = (u8)(system ? 1 : 0);
   sm->nincludes++;
   return KIT_OK;
 }
 
 KitStatus source_add_macro_expansion(SourceManager* sm, Sym macro_name,
                                      SrcLoc spelling_loc, SrcLoc expansion_loc,
                                      u32* id_out) {
   (void)spelling_loc;
   (void)expansion_loc;
   if (files_grow(sm, sm->nfiles + 1)) return KIT_NOMEM;
   {
     u32 id = sm->nfiles++;
     memset(&sm->files[id], 0, sizeof(sm->files[id]));
     sm->files[id].info.id = id;
     sm->files[id].info.name = macro_name;
     sm->files[id].info.kind = SRC_FILE_MACRO;
     *id_out = id;
   }
   return KIT_OK;
 }
 
 const SourceFile* source_file(SourceManager* sm, u32 file_id) {
   if (file_id == 0 || file_id >= sm->nfiles) return NULL;
   return &sm->files[file_id].info;
 }
 
 const SourceExpansion* source_expansion(SourceManager* sm,
                                         u32 expansion_file_id) {
   (void)sm;
   (void)expansion_file_id;
   return NULL;
 }
 
 SrcLoc source_spelling_loc(SourceManager* sm, SrcLoc loc) {
   (void)sm;
   return loc;
 }
 SrcLoc source_expansion_loc(SourceManager* sm, SrcLoc loc) {
   (void)sm;
   return loc;
 }
 
 SourceDepIter* source_depiter_new(SourceManager* sm) {
   SourceDepIter* it = (SourceDepIter*)sm->heap->alloc(sm->heap, sizeof(*it),
                                                       _Alignof(SourceDepIter));
   if (!it) return NULL;
   it->sm = sm;
   it->idx = 0;
   return it;
 }
 
 const SourceInclude* source_depiter_next(SourceDepIter* it) {
   if (!it || it->idx >= it->sm->nincludes) return NULL;
   return &it->sm->includes[it->idx++].info;
 }
 
 void source_depiter_free(SourceDepIter* it) {
   if (!it) return;
   it->sm->heap->free(it->sm->heap, it, sizeof(*it));
 }