mirror of
https://github.com/Nexoniarz/Finch.git
synced 2026-11-03 08:54:25 +00:00
Structs, arrays, owned strings, memory model, modules, debug info
- struct with default values; constructors Point(1, 2) / Point(x: 1); field access, auto-deref through pointers - []T arrays with bounds checks, literals, for-each, push/pop/insert/remove/clear/resize/find/contains/join/slice/reverse/sort - str carries its length: .len, s[i], +, comparison, sub/find/split/trim/upper/lower/replace/repeat/bytes, str(x), int(s), float(s) - Memory: values own their memory and are freed at the end of their block; assignment copies, temporaries move; parameters are lent and only copied when the function changes them; defer; new()/free() for manual heap memory - input(), read_file/write_file/file_exists, exit(), fn main([]str args) - Finch modules: import name, module.fn(), module.Struct - C structs from headers (fields, fixed arrays, nested); passed and returned by value with the System V x86-64 ABI; addr(fn) gives C a callback - link "file.c" compiles and links your own C code - -g emits DWARF debug info (gdb/lldb) - Small C runtime (runtime/finch_rt.c) embedded in the compiler, cached in ~/.cache/finch - Tests: 58, all clean under valgrind (MEMCHECK=1 tests/run.sh) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Nexoniarz
parent
0591cd20f3
commit
1dc976bd8f
59 changed files with 4577 additions and 1047 deletions
439
src/cimport.cpp
439
src/cimport.cpp
|
|
@ -41,189 +41,300 @@ std::string str(CXString s) {
|
|||
return out;
|
||||
}
|
||||
|
||||
// C type -> Finch type. Returns false (with a reason) if Finch can't express it yet.
|
||||
bool mapType(CXType t, Type &out, std::string &why) {
|
||||
t = clang_getCanonicalType(t);
|
||||
long long size = clang_Type_getSizeOf(t);
|
||||
auto sized = [&](bool isSigned) {
|
||||
switch (size) {
|
||||
case 1: out = isSigned ? Type::I8 : Type::U8; return true;
|
||||
case 2: out = isSigned ? Type::I16 : Type::U16; return true;
|
||||
case 4: out = isSigned ? Type::I32 : Type::U32; return true;
|
||||
case 8: out = isSigned ? Type::I64 : Type::U64; return true;
|
||||
}
|
||||
why = "uses a " + std::to_string(size * 8) + "-bit number";
|
||||
return false;
|
||||
};
|
||||
// Where a C type is used decides how `char *` looks in Finch: in function signatures it is
|
||||
// a `str`; inside structs, globals and behind pointers it stays a raw `ptr[char]`.
|
||||
enum class Ctx { Signature, Data };
|
||||
|
||||
switch (t.kind) {
|
||||
case CXType_Void: out = Type::Void; return true;
|
||||
case CXType_Bool: out = Type::Bool; return true;
|
||||
case CXType_Char_S:
|
||||
case CXType_Char_U: out = Type::Char; return true;
|
||||
case CXType_SChar:
|
||||
case CXType_Short:
|
||||
case CXType_Int:
|
||||
case CXType_Long:
|
||||
case CXType_LongLong: return sized(true);
|
||||
case CXType_UChar:
|
||||
case CXType_UShort:
|
||||
case CXType_UInt:
|
||||
case CXType_ULong:
|
||||
case CXType_ULongLong: return sized(false);
|
||||
case CXType_Enum: return sized(true);
|
||||
case CXType_Float: out = Type::F32; return true;
|
||||
case CXType_Double: out = Type::F64; return true;
|
||||
case CXType_Pointer: {
|
||||
CXType pointee = clang_getCanonicalType(clang_getPointeeType(t));
|
||||
if (pointee.kind == CXType_Char_S || pointee.kind == CXType_Char_U) {
|
||||
out = Type::Str; // char* is a C string
|
||||
struct Importer {
|
||||
CImports &out;
|
||||
CXTranslationUnit tu = nullptr;
|
||||
std::string header;
|
||||
std::map<std::string, std::string> recordNames; // record USR -> Finch name (typedef wins)
|
||||
std::map<std::string, int> defining; // USR -> 1 while its fields are being mapped
|
||||
int anon = 0;
|
||||
|
||||
explicit Importer(CImports &o) : out(o) {}
|
||||
|
||||
// The Finch name of a C record: its typedef name, its tag, or a made-up one.
|
||||
std::string recordName(CXType t) {
|
||||
CXCursor decl = clang_getTypeDeclaration(t);
|
||||
std::string usr = str(clang_getCursorUSR(decl));
|
||||
auto it = recordNames.find(usr);
|
||||
if (it != recordNames.end()) return it->second;
|
||||
std::string name = str(clang_getCursorSpelling(decl));
|
||||
if (name.empty() || name.find(' ') != std::string::npos) name = "anon_struct_" + std::to_string(++anon);
|
||||
recordNames[usr] = name;
|
||||
return name;
|
||||
}
|
||||
|
||||
// Fill out.structs[name] for a complete record; returns its name, or "" if it can't be one.
|
||||
std::string defineRecord(CXType t) {
|
||||
t = clang_getCanonicalType(t);
|
||||
CXCursor decl = clang_getTypeDeclaration(t);
|
||||
std::string usr = str(clang_getCursorUSR(decl));
|
||||
std::string name = recordName(t);
|
||||
if (out.structs.count(name) || defining.count(usr)) return name;
|
||||
long long size = clang_Type_getSizeOf(t);
|
||||
if (size < 0) return ""; // incomplete (opaque) struct
|
||||
defining[usr] = 1;
|
||||
|
||||
CStruct s;
|
||||
s.name = name;
|
||||
s.size = size;
|
||||
s.align = clang_Type_getAlignOf(t);
|
||||
if (clang_getCursorKind(decl) == CXCursor_UnionDecl) s.unsupported = "is a C union";
|
||||
struct Ctx2 { Importer *self; CStruct *s; } c2{this, &s};
|
||||
clang_Type_visitFields(t, [](CXCursor field, CXClientData data) -> CXVisitorResult {
|
||||
auto &c = *static_cast<Ctx2 *>(data);
|
||||
CField f;
|
||||
f.name = str(clang_getCursorSpelling(field));
|
||||
CXType ft = clang_getCanonicalType(clang_getCursorType(field));
|
||||
f.offset = clang_Cursor_getOffsetOfField(field) / 8;
|
||||
f.size = clang_Type_getSizeOf(ft);
|
||||
f.align = clang_Type_getAlignOf(ft);
|
||||
std::string why;
|
||||
if (clang_Cursor_isBitField(field)) {
|
||||
c.s->unsupported = "has bit fields";
|
||||
f.hidden = true;
|
||||
} else if (ft.kind == CXType_Record &&
|
||||
clang_getCursorKind(clang_getTypeDeclaration(ft)) == CXCursor_UnionDecl) {
|
||||
f.hidden = true; // unions are kept as opaque bytes
|
||||
} else if (!c.self->mapType(ft, f.type, why, Ctx::Data)) {
|
||||
f.hidden = true;
|
||||
}
|
||||
if (f.hidden) c.s->hasHidden = true;
|
||||
if (f.name.empty()) f.hidden = true;
|
||||
c.s->fields.push_back(f);
|
||||
return CXVisit_Continue;
|
||||
}, &c2);
|
||||
defining.erase(usr);
|
||||
out.structs[name] = s;
|
||||
return name;
|
||||
}
|
||||
|
||||
// C type -> Finch type. Returns false (with a reason) if Finch can't express it.
|
||||
bool mapType(CXType t, Type &res, std::string &why, Ctx ctx) {
|
||||
t = clang_getCanonicalType(t);
|
||||
long long size = clang_Type_getSizeOf(t);
|
||||
auto sized = [&](bool isSigned) {
|
||||
switch (size) {
|
||||
case 1: res = isSigned ? Type::I8 : Type::U8; return true;
|
||||
case 2: res = isSigned ? Type::I16 : Type::U16; return true;
|
||||
case 4: res = isSigned ? Type::I32 : Type::U32; return true;
|
||||
case 8: res = isSigned ? Type::I64 : Type::U64; return true;
|
||||
}
|
||||
why = "uses a " + std::to_string(size * 8) + "-bit number";
|
||||
return false;
|
||||
};
|
||||
|
||||
switch (t.kind) {
|
||||
case CXType_Void: res = Type::Void; return true;
|
||||
case CXType_Bool: res = Type::Bool; return true;
|
||||
case CXType_Char_S:
|
||||
case CXType_Char_U: res = Type::Char; return true;
|
||||
case CXType_SChar:
|
||||
case CXType_Short:
|
||||
case CXType_Int:
|
||||
case CXType_Long:
|
||||
case CXType_LongLong: return sized(true);
|
||||
case CXType_UChar:
|
||||
case CXType_UShort:
|
||||
case CXType_UInt:
|
||||
case CXType_ULong:
|
||||
case CXType_ULongLong: return sized(false);
|
||||
case CXType_Enum: return sized(true);
|
||||
case CXType_Float: res = Type::F32; return true;
|
||||
case CXType_Double: res = Type::F64; return true;
|
||||
case CXType_Pointer: {
|
||||
CXType pointee = clang_getCanonicalType(clang_getPointeeType(t));
|
||||
if ((pointee.kind == CXType_Char_S || pointee.kind == CXType_Char_U) && ctx == Ctx::Signature) {
|
||||
res = Type::Str; // char* in a signature is a C string
|
||||
return true;
|
||||
}
|
||||
Type inner;
|
||||
std::string ignored;
|
||||
if (pointee.kind == CXType_Void || pointee.kind == CXType_FunctionProto ||
|
||||
pointee.kind == CXType_FunctionNoProto || !mapType(pointee, inner, ignored, Ctx::Data) ||
|
||||
inner.kind == Type::Void || inner.kind == Type::Fixed)
|
||||
res = Type::Ptr; // an opaque `ptr` you can pass around
|
||||
else
|
||||
res = Type::ptrTo(inner);
|
||||
return true;
|
||||
}
|
||||
Type inner;
|
||||
std::string ignored;
|
||||
// pointers to structs, functions, void...: an opaque `ptr` you can pass around
|
||||
if (pointee.kind == CXType_Void || !mapType(pointee, inner, ignored) || inner.kind == Type::Void)
|
||||
out = Type::Ptr;
|
||||
else
|
||||
out = Type::ptrTo(inner);
|
||||
case CXType_Record: {
|
||||
if (clang_getCursorKind(clang_getTypeDeclaration(t)) == CXCursor_UnionDecl) {
|
||||
why = "uses a C union by value";
|
||||
return false;
|
||||
}
|
||||
std::string name = defineRecord(t);
|
||||
if (name.empty()) {
|
||||
why = "uses an incomplete C struct by value";
|
||||
return false;
|
||||
}
|
||||
res = Type(Type::Named);
|
||||
res.name = name;
|
||||
res.module = "C";
|
||||
return true;
|
||||
}
|
||||
case CXType_ConstantArray: {
|
||||
Type inner;
|
||||
if (!mapType(clang_getArrayElementType(t), inner, why, Ctx::Data)) return false;
|
||||
res = Type(Type::Fixed);
|
||||
res.elem = std::make_shared<Type>(inner);
|
||||
res.count = clang_getArraySize(t);
|
||||
return true;
|
||||
}
|
||||
case CXType_LongDouble: why = "uses long double"; return false;
|
||||
default: why = "uses the C type '" + str(clang_getTypeSpelling(t)) + "'"; return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Simple #defines: a single number, maybe negative, maybe in parentheses.
|
||||
bool macroValue(CXCursor c, CConst &res) {
|
||||
CXToken *toks;
|
||||
unsigned n;
|
||||
clang_tokenize(tu, clang_getCursorExtent(c), &toks, &n);
|
||||
std::vector<std::string> parts;
|
||||
for (unsigned k = 1; k < n; k++) { // token 0 is the macro's name
|
||||
if (clang_getTokenKind(toks[k]) == CXToken_Comment) continue;
|
||||
parts.push_back(str(clang_getTokenSpelling(tu, toks[k])));
|
||||
}
|
||||
clang_disposeTokens(tu, toks, n);
|
||||
|
||||
while (parts.size() >= 2 && parts.front() == "(" && parts.back() == ")") {
|
||||
parts.erase(parts.begin());
|
||||
parts.pop_back();
|
||||
}
|
||||
bool neg = false;
|
||||
if (parts.size() == 2 && parts[0] == "-") {
|
||||
neg = true;
|
||||
parts.erase(parts.begin());
|
||||
}
|
||||
if (parts.size() != 1) return false;
|
||||
const std::string &lit = parts[0];
|
||||
if (lit.empty() || !(std::isdigit((unsigned char)lit[0]) || lit[0] == '.')) return false;
|
||||
|
||||
bool isFloat = lit.find_first_of(".eE") != std::string::npos && lit.rfind("0x", 0) != 0;
|
||||
char *end;
|
||||
if (isFloat) {
|
||||
res.type = Type::F64;
|
||||
res.f = std::strtod(lit.c_str(), &end);
|
||||
if (neg) res.f = -res.f;
|
||||
} else {
|
||||
res.type = Type::I64;
|
||||
res.i = (long long)std::strtoull(lit.c_str(), &end, 0); // C rules: 0x.., 0755
|
||||
if (neg) res.i = -res.i;
|
||||
}
|
||||
for (; *end; end++) // allow suffixes: 10UL, 1.0f
|
||||
if (!std::strchr("uUlLfF", *end)) return false;
|
||||
return true;
|
||||
}
|
||||
case CXType_Record: why = "passes a C struct by value (structs are coming)"; return false;
|
||||
case CXType_LongDouble: why = "uses long double"; return false;
|
||||
default: why = "uses the C type '" + str(clang_getTypeSpelling(t)) + "'"; return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Simple #defines: a single number, maybe negative, maybe in parentheses.
|
||||
bool macroValue(CXTranslationUnit tu, CXCursor c, CConst &out) {
|
||||
CXToken *toks;
|
||||
unsigned n;
|
||||
clang_tokenize(tu, clang_getCursorExtent(c), &toks, &n);
|
||||
std::vector<std::string> parts;
|
||||
for (unsigned k = 1; k < n; k++) { // token 0 is the macro's name
|
||||
if (clang_getTokenKind(toks[k]) == CXToken_Comment) continue;
|
||||
parts.push_back(str(clang_getTokenSpelling(tu, toks[k])));
|
||||
void visitTop(CXCursor c) {
|
||||
std::string name = str(clang_getCursorSpelling(c));
|
||||
switch (clang_getCursorKind(c)) {
|
||||
case CXCursor_TypedefDecl: {
|
||||
// typedef struct {...} Name; -> the struct is called Name in Finch
|
||||
CXType u = clang_getCanonicalType(clang_getTypedefDeclUnderlyingType(c));
|
||||
if (u.kind == CXType_Record) {
|
||||
std::string usr = str(clang_getCursorUSR(clang_getTypeDeclaration(u)));
|
||||
// prefer the typedef name, unless the struct is already known under its tag
|
||||
auto it = recordNames.find(usr);
|
||||
bool used = it != recordNames.end() && out.structs.count(it->second);
|
||||
if (!used && !out.structs.count(name)) recordNames[usr] = name;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case CXCursor_FunctionDecl: {
|
||||
if (out.fns.count(name)) break;
|
||||
CFunc f;
|
||||
f.name = name;
|
||||
f.header = header;
|
||||
if (clang_Cursor_getStorageClass(c) == CX_SC_Static) {
|
||||
f.unsupported = "is a static inline C function (it has no code to link against)";
|
||||
out.fns[name] = f;
|
||||
break;
|
||||
}
|
||||
CXType ft = clang_getCanonicalType(clang_getCursorType(c));
|
||||
if (ft.kind == CXType_FunctionNoProto) {
|
||||
f.unsupported = "has no parameter list in its C declaration";
|
||||
out.fns[name] = f;
|
||||
break;
|
||||
}
|
||||
std::string why;
|
||||
if (!mapType(clang_getResultType(ft), f.ret, why, Ctx::Signature)) f.unsupported = why;
|
||||
int n = clang_getNumArgTypes(ft);
|
||||
for (int k = 0; k < n && f.unsupported.empty(); k++) {
|
||||
Type t;
|
||||
if (!mapType(clang_getArgType(ft, k), t, why, Ctx::Signature)) f.unsupported = why;
|
||||
f.params.push_back(t);
|
||||
}
|
||||
f.variadic = clang_isFunctionTypeVariadic(ft);
|
||||
out.fns[name] = f;
|
||||
break;
|
||||
}
|
||||
case CXCursor_VarDecl: {
|
||||
if (clang_Cursor_getStorageClass(c) != CX_SC_Extern || out.globals.count(name)) break;
|
||||
CGlobal g;
|
||||
std::string why;
|
||||
if (mapType(clang_getCursorType(c), g.type, why, Ctx::Data)) out.globals[name] = g;
|
||||
break;
|
||||
}
|
||||
case CXCursor_StructDecl:
|
||||
if (clang_isCursorDefinition(c) && !name.empty() && name.find(' ') == std::string::npos) {
|
||||
std::string usr = str(clang_getCursorUSR(c));
|
||||
if (!recordNames.count(usr)) recordNames[usr] = name;
|
||||
}
|
||||
break;
|
||||
case CXCursor_EnumDecl:
|
||||
clang_visitChildren(c, [](CXCursor k, CXCursor, CXClientData d) {
|
||||
static_cast<Importer *>(d)->visitTop(k);
|
||||
return CXChildVisit_Continue;
|
||||
}, this);
|
||||
break;
|
||||
case CXCursor_EnumConstantDecl: {
|
||||
CConst k;
|
||||
k.type = Type::I64;
|
||||
k.i = clang_getEnumConstantDeclValue(c);
|
||||
out.consts.emplace(name, k);
|
||||
break;
|
||||
}
|
||||
case CXCursor_MacroDefinition: {
|
||||
if (clang_Cursor_isMacroBuiltin(c) || clang_Cursor_isMacroFunctionLike(c)) break;
|
||||
CConst k;
|
||||
if (macroValue(c, k)) out.consts.emplace(name, k);
|
||||
break;
|
||||
}
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
clang_disposeTokens(tu, toks, n);
|
||||
|
||||
while (parts.size() >= 2 && parts.front() == "(" && parts.back() == ")") {
|
||||
parts.erase(parts.begin());
|
||||
parts.pop_back();
|
||||
}
|
||||
bool neg = false;
|
||||
if (parts.size() == 2 && parts[0] == "-") {
|
||||
neg = true;
|
||||
parts.erase(parts.begin());
|
||||
}
|
||||
if (parts.size() != 1) return false;
|
||||
const std::string &lit = parts[0];
|
||||
if (lit.empty() || !(std::isdigit((unsigned char)lit[0]) || lit[0] == '.')) return false;
|
||||
|
||||
bool isFloat = lit.find_first_of(".eE") != std::string::npos && lit.rfind("0x", 0) != 0;
|
||||
char *end;
|
||||
if (isFloat) {
|
||||
out.type = Type::F64;
|
||||
out.f = std::strtod(lit.c_str(), &end);
|
||||
if (neg) out.f = -out.f;
|
||||
} else {
|
||||
out.type = Type::I64;
|
||||
out.i = (long long)std::strtoull(lit.c_str(), &end, 0); // C rules: 0x.., 0755
|
||||
if (neg) out.i = -out.i;
|
||||
}
|
||||
for (; *end; end++) // allow suffixes: 10UL, 1.0f
|
||||
if (!std::strchr("uUlLfF", *end)) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
struct Visit {
|
||||
CImports *out;
|
||||
CXTranslationUnit tu;
|
||||
std::string header;
|
||||
};
|
||||
|
||||
CXChildVisitResult visit(CXCursor c, CXCursor, CXClientData data) {
|
||||
Visit &v = *static_cast<Visit *>(data);
|
||||
CImports &out = *v.out;
|
||||
std::string name = str(clang_getCursorSpelling(c));
|
||||
|
||||
switch (clang_getCursorKind(c)) {
|
||||
case CXCursor_FunctionDecl: {
|
||||
if (out.fns.count(name)) break;
|
||||
CFunc f;
|
||||
f.name = name;
|
||||
f.header = v.header;
|
||||
if (clang_Cursor_getStorageClass(c) == CX_SC_Static) {
|
||||
f.unsupported = "is a static inline C function (it has no code to link against)";
|
||||
out.fns[name] = f;
|
||||
break;
|
||||
}
|
||||
CXType ft = clang_getCanonicalType(clang_getCursorType(c));
|
||||
if (ft.kind == CXType_FunctionNoProto) {
|
||||
f.unsupported = "has no parameter list in its C declaration";
|
||||
out.fns[name] = f;
|
||||
break;
|
||||
}
|
||||
std::string why;
|
||||
if (!mapType(clang_getResultType(ft), f.ret, why)) f.unsupported = why;
|
||||
int n = clang_getNumArgTypes(ft);
|
||||
for (int k = 0; k < n && f.unsupported.empty(); k++) {
|
||||
Type t;
|
||||
if (!mapType(clang_getArgType(ft, k), t, why)) f.unsupported = why;
|
||||
f.params.push_back(t);
|
||||
}
|
||||
f.variadic = clang_isFunctionTypeVariadic(ft);
|
||||
out.fns[name] = f;
|
||||
break;
|
||||
}
|
||||
case CXCursor_VarDecl: {
|
||||
if (clang_Cursor_getStorageClass(c) != CX_SC_Extern || out.globals.count(name)) break;
|
||||
CGlobal g;
|
||||
std::string why;
|
||||
if (mapType(clang_getCursorType(c), g.type, why)) out.globals[name] = g;
|
||||
break;
|
||||
}
|
||||
case CXCursor_EnumDecl:
|
||||
clang_visitChildren(c, visit, data);
|
||||
break;
|
||||
case CXCursor_EnumConstantDecl: {
|
||||
CConst k;
|
||||
k.type = Type::I64;
|
||||
k.i = clang_getEnumConstantDeclValue(c);
|
||||
out.consts.emplace(name, k);
|
||||
break;
|
||||
}
|
||||
case CXCursor_MacroDefinition: {
|
||||
if (clang_Cursor_isMacroBuiltin(c) || clang_Cursor_isMacroFunctionLike(c)) break;
|
||||
CConst k;
|
||||
if (macroValue(v.tu, c, k)) out.consts.emplace(name, k);
|
||||
break;
|
||||
}
|
||||
default: break;
|
||||
}
|
||||
return CXChildVisit_Continue;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
CImports importHeaders(const std::vector<Import> &imports, const std::string &dir) {
|
||||
CImports importHeaders(const std::vector<Import> &imports, const std::vector<std::string> &dirs) {
|
||||
CImports out;
|
||||
if (imports.empty()) return out;
|
||||
bool any = false;
|
||||
for (const Import &im : imports) any |= im.isC;
|
||||
if (!any) return out;
|
||||
|
||||
std::vector<std::string> args = {"-x", "c", "-std=gnu11", "-I" + dir};
|
||||
std::vector<std::string> args = {"-x", "c", "-std=gnu11"};
|
||||
for (const std::string &d : dirs) args.push_back("-I" + d);
|
||||
for (const std::string &d : systemIncludeDirs()) args.push_back("-isystem" + d);
|
||||
std::vector<const char *> argv;
|
||||
for (const std::string &a : args) argv.push_back(a.c_str());
|
||||
|
||||
Importer imp(out);
|
||||
CXIndex index = clang_createIndex(0, 0);
|
||||
for (const Import &im : imports) {
|
||||
if (!im.isC) continue;
|
||||
std::string src = "#include \"" + im.path + "\"\n";
|
||||
CXUnsavedFile file = {"finch_import.c", src.c_str(), (unsigned long)src.size()};
|
||||
CXTranslationUnit tu = nullptr;
|
||||
CXErrorCode err = clang_parseTranslationUnit2(
|
||||
index, "finch_import.c", argv.data(), (int)argv.size(), &file, 1,
|
||||
CXTranslationUnit_DetailedPreprocessingRecord | CXTranslationUnit_SkipFunctionBodies, &tu);
|
||||
if (err != CXError_Success || !tu) fail(im.pos.line, im.pos.col, "couldn't read C header '" + im.path + "'");
|
||||
if (err != CXError_Success || !tu) failAt(im.pos.file, im.pos.line, im.pos.col, "couldn't read C header '" + im.path + "'");
|
||||
|
||||
for (unsigned k = 0; k < clang_getNumDiagnostics(tu); k++) {
|
||||
CXDiagnostic d = clang_getDiagnostic(tu, k);
|
||||
|
|
@ -231,14 +342,18 @@ CImports importHeaders(const std::vector<Import> &imports, const std::string &di
|
|||
std::string msg = str(clang_getDiagnosticSpelling(d));
|
||||
clang_disposeDiagnostic(d);
|
||||
if (msg.find("file not found") != std::string::npos)
|
||||
fail(im.pos.line, im.pos.col, "can't find the C header '" + im.path + "'");
|
||||
fail(im.pos.line, im.pos.col, "C header '" + im.path + "' has an error: " + msg);
|
||||
failAt(im.pos.file, im.pos.line, im.pos.col, "can't find the C header '" + im.path + "'");
|
||||
failAt(im.pos.file, im.pos.line, im.pos.col, "C header '" + im.path + "' has an error: " + msg);
|
||||
}
|
||||
clang_disposeDiagnostic(d);
|
||||
}
|
||||
|
||||
Visit v{&out, tu, im.path};
|
||||
clang_visitChildren(clang_getTranslationUnitCursor(tu), visit, &v);
|
||||
imp.tu = tu;
|
||||
imp.header = im.path;
|
||||
clang_visitChildren(clang_getTranslationUnitCursor(tu), [](CXCursor c, CXCursor, CXClientData d) {
|
||||
static_cast<Importer *>(d)->visitTop(c);
|
||||
return CXChildVisit_Continue;
|
||||
}, &imp);
|
||||
clang_disposeTranslationUnit(tu);
|
||||
}
|
||||
clang_disposeIndex(index);
|
||||
|
|
|
|||
Loading…
Reference in a new issue