-/* Cycript - Optimizing JavaScript Compiler/Runtime
- * Copyright (C) 2009-2015 Jay Freeman (saurik)
+/* Cycript - The Truly Universal Scripting Language
+ * Copyright (C) 2009-2016 Jay Freeman (saurik)
*/
/* GNU Affero General Public License, Version 3 {{{ */
#include <clang-c/Index.h>
+#include "Bridge.hpp"
#include "Functor.hpp"
#include "Replace.hpp"
#include "Syntax.hpp"
}
struct CYKey {
+ unsigned priority_ = 0;
+
std::string code_;
unsigned flags_;
};
return $ CYBlock(statements);
}
+static CYType *CYDecodeType(CXType type);
+static void CYParseType(CXType type, CYType *typed);
+
+static void CYParseEnumeration(CXCursor cursor, CYType *typed) {
+ CYList<CYEnumConstant> constants;
+
+ CYForChild(cursor, fun([&](CXCursor child) {
+ if (clang_getCursorKind(child) == CXCursor_EnumConstantDecl)
+ constants->*$ CYEnumConstant($I($pool.strdup(CYCXString(child))), $D(clang_getEnumConstantDeclValue(child)));
+ }));
+
+ CYType *integer(CYDecodeType(clang_getEnumDeclIntegerType(cursor)));
+ typed->specifier_ = $ CYTypeEnum(NULL, integer->specifier_, constants);
+}
+
+static void CYParseStructure(CXCursor cursor, CYType *typed) {
+ CYList<CYTypeStructField> fields;
+ CYForChild(cursor, fun([&](CXCursor child) {
+ if (clang_getCursorKind(child) == CXCursor_FieldDecl)
+ fields->*$ CYTypeStructField(CYDecodeType(clang_getCursorType(child)), $I(CYCXString(child).Pool($pool)));
+ }));
+
+ typed->specifier_ = $ CYTypeStruct(NULL, $ CYStructTail(fields));
+}
+
+static void CYParseCursor(CXType type, CXCursor cursor, CYType *typed) {
+ CYCXString spelling(cursor);
+
+ switch (CXCursorKind kind = clang_getCursorKind(cursor)) {
+ case CXCursor_EnumDecl:
+ if (spelling[0] != '\0')
+ typed->specifier_ = $ CYTypeReference(CYTypeReferenceEnum, $I(spelling.Pool($pool)));
+ else
+ CYParseEnumeration(cursor, typed);
+ break;
+
+ case CXCursor_StructDecl: {
+ if (spelling[0] != '\0')
+ typed->specifier_ = $ CYTypeReference(CYTypeReferenceStruct, $I(spelling.Pool($pool)));
+ else
+ CYParseStructure(cursor, typed);
+ } break;
+
+ case CXCursor_UnionDecl: {
+ _assert(false);
+ } break;
+
+ default:
+ std::cerr << "C:" << CYCXString(kind) << std::endl;
+ _assert(false);
+ break;
+ }
+}
+
+static CYTypedParameter *CYParseSignature(CXType type, CYType *typed) {
+ CYParseType(clang_getResultType(type), typed);
+ CYList<CYTypedParameter> parameters;
+ for (int i(0), e(clang_getNumArgTypes(type)); i != e; ++i)
+ parameters->*$ CYTypedParameter(CYDecodeType(clang_getArgType(type, i)), NULL);
+ return parameters;
+}
+
+static void CYParseFunction(CXType type, CYType *typed) {
+ typed = typed->Modify($ CYTypeFunctionWith(clang_isFunctionTypeVariadic(type), CYParseSignature(type, typed)));
+}
+
+static void CYParseType(CXType type, CYType *typed) {
+ switch (CXTypeKind kind = type.kind) {
+ case CXType_Unexposed: {
+ CXType result(clang_getResultType(type));
+ if (result.kind == CXType_Invalid)
+ CYParseCursor(type, clang_getTypeDeclaration(type), typed);
+ else
+ // clang marks function pointers as Unexposed but still supports them
+ CYParseFunction(type, typed);
+ } break;
+
+ case CXType_Bool: typed->specifier_ = $ CYTypeVariable("bool"); break;
+ case CXType_WChar: typed->specifier_ = $ CYTypeVariable("wchar_t"); break;
+ case CXType_Float: typed->specifier_ = $ CYTypeFloating(0); break;
+ case CXType_Double: typed->specifier_ = $ CYTypeFloating(1); break;
+ case CXType_LongDouble: typed->specifier_ = $ CYTypeFloating(2); break;
+
+ case CXType_Char_U: typed->specifier_ = $ CYTypeCharacter(CYTypeNeutral); break;
+ case CXType_Char_S: typed->specifier_ = $ CYTypeCharacter(CYTypeNeutral); break;
+ case CXType_SChar: typed->specifier_ = $ CYTypeCharacter(CYTypeSigned); break;
+ case CXType_UChar: typed->specifier_ = $ CYTypeCharacter(CYTypeUnsigned); break;
+
+ case CXType_Short: typed->specifier_ = $ CYTypeIntegral(CYTypeSigned, 0); break;
+ case CXType_UShort: typed->specifier_ = $ CYTypeIntegral(CYTypeUnsigned, 0); break;
+
+ case CXType_Int: typed->specifier_ = $ CYTypeIntegral(CYTypeSigned, 1); break;
+ case CXType_UInt: typed->specifier_ = $ CYTypeIntegral(CYTypeUnsigned, 1); break;
+
+ case CXType_Long: typed->specifier_ = $ CYTypeIntegral(CYTypeSigned, 2); break;
+ case CXType_ULong: typed->specifier_ = $ CYTypeIntegral(CYTypeUnsigned, 2); break;
+
+ case CXType_LongLong: typed->specifier_ = $ CYTypeIntegral(CYTypeSigned, 3); break;
+ case CXType_ULongLong: typed->specifier_ = $ CYTypeIntegral(CYTypeUnsigned, 3); break;
+
+ case CXType_Int128: typed->specifier_ = $ CYTypeInt128(CYTypeSigned); break;
+ case CXType_UInt128: typed->specifier_ = $ CYTypeInt128(CYTypeUnsigned); break;
+
+ case CXType_BlockPointer: {
+ CXType pointee(clang_getPointeeType(type));
+ _assert(!clang_isFunctionTypeVariadic(pointee));
+ typed = typed->Modify($ CYTypeBlockWith(CYParseSignature(pointee, typed)));
+ } break;
+
+ case CXType_ConstantArray:
+ CYParseType(clang_getArrayElementType(type), typed);
+ typed = typed->Modify($ CYTypeArrayOf($D(clang_getArraySize(type))));
+ break;
+
+ case CXType_Enum:
+ typed->specifier_ = $ CYTypeVariable($pool.strdup(CYCXString(clang_getTypeSpelling(type))));
+ break;
+
+ case CXType_FunctionProto:
+ CYParseFunction(type, typed);
+ break;
+
+ case CXType_IncompleteArray:
+ // XXX: I probably should not decay to Pointer
+ CYParseType(clang_getArrayElementType(type), typed);
+ typed = typed->Modify($ CYTypePointerTo());
+ break;
+
+ case CXType_ObjCClass:
+ typed->specifier_ = $ CYTypeVariable("Class");
+ break;
+
+ case CXType_ObjCId:
+ typed->specifier_ = $ CYTypeVariable("id");
+ break;
+
+ case CXType_ObjCInterface:
+ typed->specifier_ = $ CYTypeVariable($pool.strdup(CYCXString(clang_getTypeSpelling(type))));
+ break;
+
+ case CXType_ObjCObjectPointer: {
+ CXType pointee(clang_getPointeeType(type));
+ if (pointee.kind != CXType_Unexposed) {
+ CYParseType(pointee, typed);
+ typed = typed->Modify($ CYTypePointerTo());
+ } else
+ // Clang seems to have internal typedefs for id and Class that are awkward
+ _assert(false);
+ } break;
+
+ case CXType_ObjCSel:
+ typed->specifier_ = $ CYTypeVariable("SEL");
+ break;
+
+ case CXType_Pointer:
+ CYParseType(clang_getPointeeType(type), typed);
+ typed = typed->Modify($ CYTypePointerTo());
+ break;
+
+ case CXType_Record:
+ typed->specifier_ = $ CYTypeReference(CYTypeReferenceStruct, $I($pool.strdup(CYCXString(clang_getTypeSpelling(type)))));
+ break;
+
+ case CXType_Typedef:
+ // use the declaration in order to isolate the name of the typedef itself
+ typed->specifier_ = $ CYTypeVariable($pool.strdup(CYCXString(clang_getTypeDeclaration(type))));
+ break;
+
+ case CXType_Vector:
+ _assert(false);
+ break;
+
+ case CXType_Void:
+ typed->specifier_ = $ CYTypeVoid();
+ break;
+
+ default:
+ std::cerr << "T:" << CYCXString(clang_getTypeKindSpelling(kind)) << std::endl;
+ std::cerr << "_: " << CYCXString(clang_getTypeSpelling(type)) << std::endl;
+ _assert(false);
+ }
+
+ if (clang_isConstQualifiedType(type))
+ typed = typed->Modify($ CYTypeConstant());
+}
+
+static CYType *CYDecodeType(CXType type) {
+ CYType *typed($ CYType(NULL));
+ CYParseType(type, typed);
+ return typed;
+}
+
static CXChildVisitResult CYChildVisit(CXCursor cursor, CXCursor parent, CXClientData arg) {
CYChildBaton &baton(*static_cast<CYChildBaton *>(arg));
CXTranslationUnit &unit(baton.unit);
+ CXChildVisitResult result(CXChildVisit_Continue);
CYCXString spelling(cursor);
std::string name(spelling);
std::ostringstream value;
- unsigned flags(0);
+ unsigned priority(2);
+ unsigned flags(CYBridgeHold);
/*CXSourceLocation location(clang_getCursorLocation(cursor));
CYCXPosition<> position(location);
- std::cout << spelling << " " << position << std::endl;*/
+ std::cerr << spelling << " " << position << std::endl;*/
- switch (CXCursorKind kind = clang_getCursorKind(cursor)) {
+ try { switch (CXCursorKind kind = clang_getCursorKind(cursor)) {
case CXCursor_EnumConstantDecl: {
value << clang_getEnumConstantDeclValue(cursor);
} break;
- case CXCursor_MacroDefinition: try {
+ case CXCursor_EnumDecl: {
+ // the enum constants are implemented separately *also*
+ // XXX: maybe move output logic to function we can call
+ result = CXChildVisit_Recurse;
+
+ if (spelling[0] == '\0')
+ goto skip;
+ // XXX: this was blindly copied from StructDecl
+ if (!clang_isCursorDefinition(cursor))
+ priority = 1;
+
+ CYLocalPool pool;
+
+ CYType typed;
+ CYParseEnumeration(cursor, &typed);
+
+ CYOptions options;
+ CYOutput out(*value.rdbuf(), options);
+ CYTypeExpression(&typed).Output(out, CYNoBFC);
+
+ value << ".withName(\"" << name << "\")";
+ name = "$cye" + name;
+ flags = CYBridgeType;
+ } break;
+
+ case CXCursor_MacroDefinition: {
CXSourceRange range(clang_getCursorExtent(cursor));
CYTokens tokens(unit, range);
_assert(tokens.size() != 0);
value << body.str();
out << ';' << '}' << ')';
}
- } catch (const CYException &error) {
- CYPool pool;
- //std::cerr << error.PoolCString(pool) << std::endl;
- goto skip;
} break;
case CXCursor_StructDecl: {
- if (!clang_isCursorDefinition(cursor))
- goto skip;
if (spelling[0] == '\0')
goto skip;
+ if (!clang_isCursorDefinition(cursor))
+ priority = 1;
- std::ostringstream types;
- std::ostringstream names;
+ CYLocalPool pool;
- CYForChild(cursor, fun([&](CXCursor child) {
- if (clang_getCursorKind(child) == CXCursor_FieldDecl) {
- CXType type(clang_getCursorType(child));
- types << "(typedef " << CYCXString(clang_getTypeSpelling(type)) << "),";
- names << "'" << CYCXString(child) << "',";
- }
- }));
+ CYType typed;
+ CYParseStructure(cursor, &typed);
- name += "$cy";
- value << "new Type([" << types.str() << "],[" << names.str() << "])";
+ CYOptions options;
+ CYOutput out(*value.rdbuf(), options);
+ CYTypeExpression(&typed).Output(out, CYNoBFC);
+
+ value << ".withName(\"" << name << "\")";
+ name = "$cys" + name;
+ flags = CYBridgeType;
} break;
case CXCursor_TypedefDecl: {
- CXType type(clang_getTypedefDeclUnderlyingType(cursor));
- value << "(typedef " << CYCXString(clang_getTypeSpelling(type)) << ")";
+ CYLocalPool local;
+
+ CYType *typed(CYDecodeType(clang_getTypedefDeclUnderlyingType(cursor)));
+ if (typed->specifier_ == NULL)
+ value << "(typedef " << CYCXString(clang_getTypeSpelling(clang_getTypedefDeclUnderlyingType(cursor))) << ")";
+ else {
+ CYOptions options;
+ CYOutput out(*value.rdbuf(), options);
+ CYTypeExpression(typed).Output(out, CYNoBFC);
+ }
} break;
case CXCursor_FunctionDecl:
- case CXCursor_VarDecl: try {
+ case CXCursor_VarDecl: {
std::string label;
CYList<CYFunctionParameter> parameters;
goto skip;
if (code == NULL) {
+ value << "*";
CXType type(clang_getCursorType(cursor));
- value << "*(typedef " << CYCXString(clang_getTypeSpelling(type)) << ").pointerTo()(dlsym(RTLD_DEFAULT,'" << label.substr(1) << "'))";
+ CYType *typed(CYDecodeType(type));
+ CYOptions options;
+ CYOutput out(*value.rdbuf(), options);
+ CYTypeExpression(typed).Output(out, CYNoBFC);
+ value << ".pointerTo()(dlsym(RTLD_DEFAULT,'" << label.substr(1) << "'))";
} else {
CYOptions options;
CYOutput out(*value.rdbuf(), options);
function->Output(out, CYNoBFC);
//std::cerr << value.str() << std::endl;
}
- } catch (const CYException &error) {
- CYPool pool;
- //std::cerr << error.PoolCString(pool) << std::endl;
- goto skip;
- } break;
-
- default: {
- return CXChildVisit_Recurse;
} break;
- }
- {
+ default:
+ result = CXChildVisit_Recurse;
+ goto skip;
+ break;
+ } {
CYKey &key(baton.keys[name]);
- key.code_ = value.str();
- key.flags_ = flags;
+ if (key.priority_ <= priority) {
+ key.priority_ = priority;
+ key.code_ = value.str();
+ key.flags_ = flags;
+ }
+ } } catch (const CYException &error) {
+ CYPool pool;
+ //std::cerr << error.PoolCString(pool) << std::endl;
}
skip:
- return CXChildVisit_Continue;
+ return result;
}
int main(int argc, const char *argv[]) {
projects / cycript.git / blobdiff