langin.cpp
impl/langin/langin.cpp · 379 line(s) · c
// ===========================================================================
// langin.cpp -- native ingest of the JVM language family into Sleela.
// ===========================================================================
#include "langin.h"
#include "../xclass/xclass_loader.h" // reuse emitSource() for .sleela rendering
#include <cctype>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <regex>
namespace sleela {
namespace langin {
const char* languageName(Language lang) noexcept {
switch (lang) {
case Language::Java: return "Java";
case Language::Kotlin: return "Kotlin";
case Language::Scala: return "Scala";
case Language::Groovy: return "Groovy";
case Language::Clojure: return "Clojure";
default: return "Unknown";
}
}
static std::string lower(std::string s) {
for (char& c : s) c = (char)std::tolower((unsigned char)c);
return s;
}
static bool endsWith(const std::string& s, const std::string& suf) {
return s.size() >= suf.size() && s.compare(s.size() - suf.size(), suf.size(), suf) == 0;
}
Language languageForPath(const std::string& path) {
std::string p = lower(path);
if (endsWith(p, ".java")) return Language::Java;
if (endsWith(p, ".kt") || endsWith(p, ".kts")) return Language::Kotlin;
if (endsWith(p, ".scala") || endsWith(p, ".sc")) return Language::Scala;
if (endsWith(p, ".groovy") || endsWith(p, ".gvy")) return Language::Groovy;
if (endsWith(p, ".clj") || endsWith(p, ".cljs") || endsWith(p, ".cljc")) return Language::Clojure;
return Language::Unknown;
}
// --- type mapping: source-language types -> Sleela's surface types ----------
// Sleela's surface types are int/double/boolean/String/void (parsed, not
// enforced). Anything else maps to a struct-handle "int" per the xclass model.
static std::string mapType(std::string t) {
// strip Kotlin/Scala nullability + whitespace + generics
std::string s;
for (char c : t) { if (!std::isspace((unsigned char)c)) s += c; }
// drop a trailing '?' (Kotlin nullable) and any generic <...>
if (!s.empty() && s.back() == '?') s.pop_back();
auto lt = s.find('<'); if (lt != std::string::npos) s = s.substr(0, lt);
std::string l = lower(s);
if (l == "void" || l == "unit" || l == "nothing") return "void";
if (l == "int" || l == "integer" || l == "long" || l == "short" || l == "byte" ||
l == "int" ) return "int";
if (l == "double" || l == "float" || l == "bigdecimal") return "double";
if (l == "boolean" || l == "bool") return "boolean";
if (l == "string" || l == "char" || l == "charsequence") return "String";
// any object/reference type is carried as a struct handle (int)
return "int";
}
// Build a default-return body for a mapped return type (mirrors xclass synthBody).
static std::unique_ptr<Block> synthBody(const std::string& retType) {
auto blk = std::make_unique<Block>();
if (retType == "void") return blk;
auto ret = std::make_unique<ReturnStmt>();
if (retType == "boolean") ret->value = std::make_unique<BoolLit>(false);
else if (retType == "double") ret->value = std::make_unique<DoubleLit>(0.0);
else if (retType == "String") ret->value = std::make_unique<StrLit>("");
else ret->value = std::make_unique<IntLit>(0);
blk->stmts.push_back(std::move(ret));
return blk;
}
// Split a parameter list "a: Int, b: String" or "int a, String b" into
// (type,name) pairs. Handles both Java-style (type name) and Kotlin/Scala-style
// (name: Type). Best-effort and skeleton-only.
static std::vector<Param> parseParams(const std::string& raw, Language lang) {
std::vector<Param> out;
std::string inner = raw;
// trim surrounding parens
auto lp = inner.find('('); auto rp = inner.rfind(')');
if (lp != std::string::npos && rp != std::string::npos && rp > lp)
inner = inner.substr(lp + 1, rp - lp - 1);
if (inner.find_first_not_of(" \t\r\n") == std::string::npos) return out;
std::stringstream ss(inner);
std::string item;
int depth = 0; std::string acc;
// split on top-level commas (ignore commas inside generics)
for (char c : inner) {
if (c == '<') depth++;
else if (c == '>') depth--;
if (c == ',' && depth == 0) { out.push_back({}); acc.clear(); }
// handled below via a cleaner tokenizer
}
out.clear();
std::vector<std::string> items; acc.clear(); depth = 0;
for (char c : inner) {
if (c == '<') depth++;
if (c == '>') depth--;
if (c == ',' && depth == 0) { items.push_back(acc); acc.clear(); }
else acc += c;
}
if (!acc.empty()) items.push_back(acc);
for (auto& it : items) {
Param p;
auto colon = it.find(':');
if ((lang == Language::Kotlin || lang == Language::Scala || lang == Language::Groovy)
&& colon != std::string::npos) {
// name: Type
std::string name = it.substr(0, colon);
std::string type = it.substr(colon + 1);
// trim
auto trim = [](std::string& s){ size_t a=s.find_first_not_of(" \t\r\n"); size_t b=s.find_last_not_of(" \t\r\n"); s = (a==std::string::npos)?"":s.substr(a,b-a+1); };
trim(name); trim(type);
// strip default values
auto eq = name.find('='); if (eq != std::string::npos) name = name.substr(0, eq);
auto eq2 = type.find('='); if (eq2 != std::string::npos) type = type.substr(0, eq2);
trim(name); trim(type);
p.name = name; p.type = mapType(type);
} else {
// Java/Groovy style: Type name (take last token as name)
std::stringstream ts(it); std::vector<std::string> toks; std::string t;
while (ts >> t) toks.push_back(t);
if (toks.empty()) continue;
p.name = toks.back();
p.type = mapType(toks.size() >= 2 ? toks[toks.size()-2] : "int");
}
if (p.name.empty()) p.name = "arg" + std::to_string(out.size());
if (p.type.empty()) p.type = "int";
out.push_back(p);
}
return out;
}
// --- primary-name / package extraction --------------------------------------
static std::string firstMatch(const std::string& text, const std::regex& re, int group = 1) {
std::smatch m;
if (std::regex_search(text, m, re) && (int)m.size() > group) return m[group].str();
return "";
}
// =========================================================================
// Per-language skeleton ingest. Each fills a ClassDecl (fields + method
// signatures) and a Meta. Bodies are synthesized (skeleton transpile).
// =========================================================================
static void ingest(const std::string& text, Language lang, const std::string& path,
Program& prog, std::vector<Meta>& metas) {
Meta meta;
meta.language = lang;
meta.sourceFile = path;
ClassDecl cls;
if (lang == Language::Clojure) {
// Clojure: (ns my.space) and (defn name [args] ...) / (def name ...).
meta.packageName = firstMatch(text, std::regex(R"(\(ns\s+([A-Za-z_][\w\.\-]*))"));
std::string base = meta.packageName.empty() ? "ClojureUnit" : meta.packageName;
// sanitize namespace into a Sleela identifier
std::string name; for (char c : base) name += (std::isalnum((unsigned char)c) ? c : '_');
cls.name = name.empty() ? "ClojureUnit" : name;
// functions: (defn foo [a b] ...)
std::regex defn(R"(\(defn-?\s+([A-Za-z_][\w\-\?!*]*)\s*\[([^\]]*)\])");
for (auto it = std::sregex_iterator(text.begin(), text.end(), defn);
it != std::sregex_iterator(); ++it) {
Method m; std::string fn = (*it)[1].str();
for (char& c : fn) if (!(std::isalnum((unsigned char)c) || c=='_')) c = '_';
m.name = fn; m.retType = "int";
// arg vector -> untyped params (Clojure is dynamic) => int handles
std::stringstream as((*it)[2].str()); std::string a; int i=0;
while (as >> a) { Param p; p.type="int"; std::string an; for(char c:a) an += (std::isalnum((unsigned char)c)?c:'_'); p.name = an.empty()?("arg"+std::to_string(i)):an; cls.methods.push_back({}); cls.methods.pop_back(); m.params.push_back(p); i++; }
m.body = synthBody(m.retType);
cls.methods.push_back(std::move(m));
}
// (def name ...) -> fields
std::regex defv(R"(\(def\s+([A-Za-z_][\w\-\?!*]*))");
for (auto it = std::sregex_iterator(text.begin(), text.end(), defv);
it != std::sregex_iterator(); ++it) {
Field f; std::string fn = (*it)[1].str();
for (char& c : fn) if (!(std::isalnum((unsigned char)c) || c=='_')) c = '_';
f.type = "int"; f.name = fn; cls.fields.push_back(std::move(f));
}
} else {
// Java / Kotlin / Scala / Groovy: package + class/interface/object + members.
meta.packageName = firstMatch(text, std::regex(R"(package\s+([A-Za-z_][\w\.]*))"));
// class / interface / object / trait name
std::smatch cm;
std::regex cdecl(R"((?:public\s+|final\s+|abstract\s+|open\s+|data\s+|sealed\s+)*(class|interface|object|trait)\s+([A-Za-z_]\w*))");
if (std::regex_search(text, cm, cdecl)) {
std::string kw = cm[1].str();
cls.name = cm[2].str();
meta.isInterface = (kw == "interface" || kw == "trait");
} else {
cls.name = "Unit";
}
if (text.find("abstract ") != std::string::npos) meta.isAbstract = true;
// Methods:
// Java/Groovy: [mods] RetType name(params) { | ;
// Kotlin: fun name(params): RetType
// Scala: def name(params): RetType
if (lang == Language::Kotlin) {
std::regex fn(R"(fun\s+([A-Za-z_]\w*)\s*\(([^\)]*)\)\s*(?::\s*([A-Za-z_][\w\.<>\?]*))?)");
for (auto it = std::sregex_iterator(text.begin(), text.end(), fn);
it != std::sregex_iterator(); ++it) {
Method m; m.name = (*it)[1].str();
m.retType = (*it)[3].matched ? mapType((*it)[3].str()) : "void";
m.params = parseParams("(" + (*it)[2].str() + ")", lang);
m.body = synthBody(m.retType); cls.methods.push_back(std::move(m));
}
// val/var fields: val name: Type
std::regex fld(R"((?:val|var)\s+([A-Za-z_]\w*)\s*:\s*([A-Za-z_][\w\.<>\?]*))");
for (auto it = std::sregex_iterator(text.begin(), text.end(), fld);
it != std::sregex_iterator(); ++it) {
Field f; f.name = (*it)[1].str(); f.type = mapType((*it)[2].str());
cls.fields.push_back(std::move(f));
}
} else if (lang == Language::Scala) {
std::regex fn(R"(def\s+([A-Za-z_]\w*)\s*\(([^\)]*)\)\s*(?::\s*([A-Za-z_][\w\.<>\[\]]*))?)");
for (auto it = std::sregex_iterator(text.begin(), text.end(), fn);
it != std::sregex_iterator(); ++it) {
Method m; m.name = (*it)[1].str();
m.retType = (*it)[3].matched ? mapType((*it)[3].str()) : "void";
m.params = parseParams("(" + (*it)[2].str() + ")", lang);
m.body = synthBody(m.retType); cls.methods.push_back(std::move(m));
}
std::regex fld(R"((?:val|var)\s+([A-Za-z_]\w*)\s*:\s*([A-Za-z_][\w\.<>\[\]]*))");
for (auto it = std::sregex_iterator(text.begin(), text.end(), fld);
it != std::sregex_iterator(); ++it) {
Field f; f.name = (*it)[1].str(); f.type = mapType((*it)[2].str());
cls.fields.push_back(std::move(f));
}
} else {
// Java / Groovy: RetType name(params) followed by { or ;
std::regex fn(R"((?:public\s+|private\s+|protected\s+|static\s+|final\s+|abstract\s+|def\s+)*([A-Za-z_][\w\.<>\[\]]*)\s+([A-Za-z_]\w*)\s*\(([^\)]*)\)\s*[\{;])");
for (auto it = std::sregex_iterator(text.begin(), text.end(), fn);
it != std::sregex_iterator(); ++it) {
std::string ret = (*it)[1].str(); std::string nm = (*it)[2].str();
if (ret == "new" || ret == "return" || ret == "if" || ret == "while" || ret == "for") continue;
Method m; m.name = nm; m.retType = mapType(ret);
m.params = parseParams("(" + (*it)[3].str() + ")", lang);
m.body = synthBody(m.retType); cls.methods.push_back(std::move(m));
}
// Java fields: [mods] Type name ; | =
std::regex fld(R"((?:public\s+|private\s+|protected\s+|static\s+|final\s+)+([A-Za-z_][\w\.<>\[\]]*)\s+([A-Za-z_]\w*)\s*[;=])");
for (auto it = std::sregex_iterator(text.begin(), text.end(), fld);
it != std::sregex_iterator(); ++it) {
Field f; f.type = mapType((*it)[1].str()); f.name = (*it)[2].str();
cls.fields.push_back(std::move(f));
}
}
}
if (cls.name.empty()) cls.name = "Unit";
meta.name = cls.name;
meta.fieldCount = (int)cls.fields.size();
meta.methodCount = (int)cls.methods.size();
metas.push_back(meta);
prog.classes.push_back(std::move(cls));
}
void loadDocument(const std::string& text, Language lang, const std::string& path,
Program& prog, std::vector<Meta>& metas) {
if (lang == Language::Unknown) {
throw std::runtime_error("langin: unrecognized JVM language for '" + path + "'");
}
size_t before = prog.classes.size();
ingest(text, lang, path, prog, metas);
if (prog.classes.size() == before) {
throw std::runtime_error("langin: no class/namespace recognized in '" + path + "'");
}
}
std::string infoLine(const Meta& m) {
std::ostringstream o;
o << m.name << " [" << languageName(m.language) << "]";
if (!m.packageName.empty()) o << " pkg=" << m.packageName;
if (m.isInterface) o << " interface";
if (m.isAbstract) o << " abstract";
o << " fields=" << m.fieldCount << " methods=" << m.methodCount;
return o.str();
}
Loaded loadFiles(const std::vector<std::string>& paths) {
Loaded out;
for (const auto& p : paths) {
Language lang = languageForPath(p);
std::ifstream in(p, std::ios::binary);
if (!in) throw std::runtime_error("langin: cannot open '" + p + "'");
std::stringstream ss; ss << in.rdbuf();
loadDocument(ss.str(), lang, p, out.program, out.metas);
}
// Synthesize an entry `main` if none present, so the Program runs.
bool hasMain = false;
for (const auto& c : out.program.classes)
for (const auto& m : c.methods)
if (m.name == "main" && m.params.empty()) hasMain = true;
if (!hasMain) {
ClassDecl shim; shim.name = "LangInMain";
Method main; main.retType = "void"; main.name = "main";
main.body = std::make_unique<Block>();
auto banner = std::make_unique<PrintStmt>();
banner->expr = std::make_unique<StrLit>(
"langin: ingested " + std::to_string(out.metas.size()) + " JVM-family unit(s)");
main.body->stmts.push_back(std::move(banner));
for (const auto& m : out.metas) {
auto line = std::make_unique<PrintStmt>();
line->expr = std::make_unique<StrLit>(" " + infoLine(m));
main.body->stmts.push_back(std::move(line));
}
shim.methods.push_back(std::move(main));
out.program.classes.push_back(std::move(shim));
}
out.emitted = sleela::xclass::emitSource(out.program);
return out;
}
// --- .xclass emission (structural descriptor) -------------------------------
static void xmlEscape(std::ostream& o, const std::string& s) {
for (char c : s) {
switch (c) {
case '&': o << "&"; break;
case '<': o << "<"; break;
case '>': o << ">"; break;
default: o << c;
}
}
}
std::string emitXclass(const Program& prog, const std::vector<Meta>& metas) {
std::ostringstream o;
o << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
for (size_t i = 0; i < prog.classes.size(); ++i) {
const ClassDecl& c = prog.classes[i];
const Meta* m = i < metas.size() ? &metas[i] : nullptr;
o << "<xclass version=\"1\" compiler=\"langin\" compiler-version=\"1.0.0\"";
if (m) o << " source-language=\"" << languageName(m->language) << "\"";
o << ">\n";
o << " <identity>\n";
o << " <name>"; xmlEscape(o, c.name); o << "</name>\n";
o << " <superclass>(none)</superclass>\n";
o << " <abstract>" << ((m && m->isAbstract) ? "true" : "false") << "</abstract>\n";
o << " <interface>" << ((m && m->isInterface) ? "true" : "false") << "</interface>\n";
o << " <public>true</public>\n";
o << " <method-count>" << c.methods.size() << "</method-count>\n";
o << " <field-count>" << c.fields.size() << "</field-count>\n";
o << " </identity>\n";
if (m && !m->packageName.empty()) {
o << " <provenance><package>"; xmlEscape(o, m->packageName);
o << "</package>";
if (!m->sourceFile.empty()) { o << "<source>"; xmlEscape(o, m->sourceFile); o << "</source>"; }
o << "</provenance>\n";
}
o << " <members>\n";
for (const auto& f : c.fields) {
o << " <field type=\""; xmlEscape(o, f.type); o << "\" name=\"";
xmlEscape(o, f.name); o << "\"/>\n";
}
for (const auto& mm : c.methods) {
o << " <method ret=\""; xmlEscape(o, mm.retType); o << "\" name=\"";
xmlEscape(o, mm.name); o << "\" params=\"" << mm.params.size() << "\"/>\n";
}
o << " </members>\n";
o << "</xclass>\n";
}
return o.str();
}
} // namespace langin
} // namespace sleela