X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/7341eedbaf526ef2f0986b576c656906050e270a..068672f645dcdcf868fea6bbbef715880f019a1d:/Analyze.cpp diff --git a/Analyze.cpp b/Analyze.cpp index 7b3e2ca..5bf4914 100644 --- a/Analyze.cpp +++ b/Analyze.cpp @@ -28,6 +28,7 @@ #include +#include "Bridge.hpp" #include "Functor.hpp" #include "Replace.hpp" #include "Syntax.hpp" @@ -288,26 +289,244 @@ static CYStatement *CYTranslateBlock(CXTranslationUnit unit, CXCursor cursor) { return $ CYBlock(statements); } +static CYType *CYDecodeType(CXType type); +static void CYParseType(CXType type, CYType *typed); + +static void CYParseEnumeration(CXCursor cursor, CYType *typed) { + CYList 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 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 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(arg)); CXTranslationUnit &unit(baton.unit); + CXChildVisitResult result(CXChildVisit_Continue); CYCXString spelling(cursor); std::string name(spelling); std::ostringstream value; unsigned priority(2); - unsigned flags(0); + 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: { + 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; + + // the enum constants are implemented separately *also* + // XXX: maybe move output logic to function we can call + result = CXChildVisit_Recurse; + } break; + + case CXCursor_MacroDefinition: { CXSourceRange range(clang_getCursorExtent(cursor)); CYTokens tokens(unit, range); _assert(tokens.size() != 0); @@ -360,10 +579,6 @@ static CXChildVisitResult CYChildVisit(CXCursor cursor, CXCursor parent, CXClien value << body.str(); out << ';' << '}' << ')'; } - } catch (const CYException &error) { - CYPool pool; - //std::cerr << error.PoolCString(pool) << std::endl; - goto skip; } break; case CXCursor_StructDecl: { @@ -372,28 +587,35 @@ static CXChildVisitResult CYChildVisit(CXCursor cursor, CXCursor parent, CXClien 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 parameters; @@ -434,8 +656,13 @@ static CXChildVisitResult CYChildVisit(CXCursor cursor, CXCursor parent, CXClien 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); @@ -443,28 +670,26 @@ static CXChildVisitResult CYChildVisit(CXCursor cursor, CXCursor parent, CXClien 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]); - if (key.priority_ < priority) { + 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[]) {