mirror of
https://github.com/Nexoniarz/Finch.git
synced 2026-11-03 00:44:27 +00:00
1dc976bd8f
- 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>
361 lines
15 KiB
C++
361 lines
15 KiB
C++
#include "cimport.h"
|
|
#include "error.h"
|
|
|
|
#include <clang-c/Index.h>
|
|
|
|
#include <cctype>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
|
|
namespace {
|
|
|
|
// Ask the system C compiler where it looks for headers, so we find the same stdio.h it would.
|
|
std::vector<std::string> systemIncludeDirs() {
|
|
const char *cc = std::getenv("CC");
|
|
std::string cmd = std::string(cc ? cc : "cc") + " -E -v -x c /dev/null 2>&1";
|
|
std::vector<std::string> dirs;
|
|
FILE *p = popen(cmd.c_str(), "r");
|
|
if (!p) return dirs;
|
|
char line[4096];
|
|
bool inList = false;
|
|
while (std::fgets(line, sizeof line, p)) {
|
|
std::string l = line;
|
|
if (l.rfind("#include <...> search starts here:", 0) == 0) { inList = true; continue; }
|
|
if (l.rfind("End of search list.", 0) == 0) break;
|
|
if (!inList) continue;
|
|
size_t a = l.find_first_not_of(' ');
|
|
size_t z = l.find_last_not_of(" \n");
|
|
if (a == std::string::npos) continue;
|
|
std::string d = l.substr(a, z - a + 1);
|
|
if (d.size() > 20 && d.compare(d.size() - 20, 20, " (framework directory)") == 0) continue;
|
|
dirs.push_back(d);
|
|
}
|
|
pclose(p);
|
|
return dirs;
|
|
}
|
|
|
|
std::string str(CXString s) {
|
|
std::string out = clang_getCString(s) ? clang_getCString(s) : "";
|
|
clang_disposeString(s);
|
|
return out;
|
|
}
|
|
|
|
// 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 };
|
|
|
|
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;
|
|
}
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
};
|
|
|
|
} // namespace
|
|
|
|
CImports importHeaders(const std::vector<Import> &imports, const std::vector<std::string> &dirs) {
|
|
CImports 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"};
|
|
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) 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);
|
|
if (clang_getDiagnosticSeverity(d) >= CXDiagnostic_Error) {
|
|
std::string msg = str(clang_getDiagnosticSpelling(d));
|
|
clang_disposeDiagnostic(d);
|
|
if (msg.find("file not found") != std::string::npos)
|
|
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);
|
|
}
|
|
|
|
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);
|
|
return out;
|
|
}
|