The value from +alloc can be a permanent (NSDate).

[cycript.git] / Analyze.cpp

diff --git a/Analyze.cpp b/Analyze.cpp
index 922dfb1cd3d56d88c56ff74a6ccc23dbfb81eacd..f1ef1073652197e10ebad5b610b8d713ca96f610 100644 (file)
--- a/Analyze.cpp
+++ b/Analyze.cpp
@@ -28,6 +28,7 @@
 
 #include <clang-c/Index.h>
 
 
 #include <clang-c/Index.h>
 

+#include "Bridge.hpp"

 #include "Functor.hpp"
 #include "Replace.hpp"
 #include "Syntax.hpp"
 #include "Functor.hpp"
 #include "Replace.hpp"
 #include "Syntax.hpp"


@@ -288,42 +289,47 @@ static CYStatement *CYTranslateBlock(CXTranslationUnit unit, CXCursor cursor) {
     return $ CYBlock(statements);
 }
 
     return $ CYBlock(statements);
 }
 

-static CYTypedIdentifier *CYDecodeType(CXType type);
-static void CYParseType(CXType type, CYTypedIdentifier *typed);
+static CYType *CYDecodeType(CXType type);
+static void CYParseType(CXType type, CYType *typed);

 
 

-static CYTypedIdentifier *CYDecodeType(CXType type, const CYCXString &identifier) {
-    CYTypedIdentifier *typed(CYDecodeType(type));
-    typed->identifier_ = $ CYIdentifier(identifier.Pool($pool));
-    return 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, CYTypedIdentifier *typed) {
+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')
     CYCXString spelling(cursor);
 
     switch (CXCursorKind kind = clang_getCursorKind(cursor)) {
         case CXCursor_EnumDecl:
             if (spelling[0] != '\0')

-                // XXX: should we have a special enum keyword?
-                typed->specifier_ = $ CYTypeVariable($I(spelling.Pool($pool)));
+                typed->specifier_ = $ CYTypeReference(CYTypeReferenceEnum, $I(spelling.Pool($pool)));

             else
             else

-                // XXX: maybe replace with "enum : int" instead of "int"
-                CYParseType(clang_getEnumDeclIntegerType(cursor), typed);
+                CYParseEnumeration(cursor, typed);

         break;
 
         case CXCursor_StructDecl: {
             if (spelling[0] != '\0')
         break;
 
         case CXCursor_StructDecl: {
             if (spelling[0] != '\0')

-                typed->specifier_ = $ CYTypeReference($I(spelling.Pool($pool)));
-            else {
-                CYList<CYTypeStructField> fields;
-                CYForChild(cursor, fun([&](CXCursor child) {
-                    if (clang_getCursorKind(child) == CXCursor_FieldDecl) {
-                        CYTypedIdentifier *field(CYDecodeType(clang_getCursorType(child), child));
-                        fields->*$ CYTypeStructField(field);
-                    }
-                }));
-
-                typed->specifier_ = $ CYTypeStruct(NULL, $ CYStructTail(fields));
-            }
+                typed->specifier_ = $ CYTypeReference(CYTypeReferenceStruct, $I(spelling.Pool($pool)));
+            else
+                CYParseStructure(cursor, typed);

         } break;
 
         case CXCursor_UnionDecl: {
         } break;
 
         case CXCursor_UnionDecl: {


@@ -337,19 +343,19 @@ static void CYParseCursor(CXType type, CXCursor cursor, CYTypedIdentifier *typed
     }
 }
 
     }
 }
 

-static CYTypedParameter *CYParseSignature(CXType type, CYTypedIdentifier *typed) {
+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)
     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)));
+        parameters->*$ CYTypedParameter(CYDecodeType(clang_getArgType(type, i)), NULL);

     return parameters;
 }
 
     return parameters;
 }
 

-static void CYParseFunction(CXType type, CYTypedIdentifier *typed) {
+static void CYParseFunction(CXType type, CYType *typed) {

     typed = typed->Modify($ CYTypeFunctionWith(clang_isFunctionTypeVariadic(type), CYParseSignature(type, typed)));
 }
 
     typed = typed->Modify($ CYTypeFunctionWith(clang_isFunctionTypeVariadic(type), CYParseSignature(type, typed)));
 }
 

-static void CYParseType(CXType type, CYTypedIdentifier *typed) {
+static void CYParseType(CXType type, CYType *typed) {

     switch (CXTypeKind kind = type.kind) {
         case CXType_Unexposed: {
             CXType result(clang_getResultType(type));
     switch (CXTypeKind kind = type.kind) {
         case CXType_Unexposed: {
             CXType result(clang_getResultType(type));


@@ -381,6 +387,9 @@ static void CYParseType(CXType type, CYTypedIdentifier *typed) {
         case CXType_LongLong: typed->specifier_ = $ CYTypeIntegral(CYTypeSigned, 3); break;
         case CXType_ULongLong: typed->specifier_ = $ CYTypeIntegral(CYTypeUnsigned, 3); 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));
         case CXType_BlockPointer: {
             CXType pointee(clang_getPointeeType(type));
             _assert(!clang_isFunctionTypeVariadic(pointee));


@@ -401,8 +410,13 @@ static void CYParseType(CXType type, CYTypedIdentifier *typed) {
         break;
 
         case CXType_IncompleteArray:
         break;
 
         case CXType_IncompleteArray:

-            // XXX: I should support these :/
-            _assert(false);
+            // 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:
         break;
 
         case CXType_ObjCId:


@@ -433,7 +447,7 @@ static void CYParseType(CXType type, CYTypedIdentifier *typed) {
         break;
 
         case CXType_Record:
         break;
 
         case CXType_Record:

-            typed->specifier_ = $ CYTypeReference($I($pool.strdup(CYCXString(clang_getTypeSpelling(type)))));
+            typed->specifier_ = $ CYTypeReference(CYTypeReferenceStruct, $I($pool.strdup(CYCXString(clang_getTypeSpelling(type)))));

         break;
 
         case CXType_Typedef:
         break;
 
         case CXType_Typedef:


@@ -459,8 +473,8 @@ static void CYParseType(CXType type, CYTypedIdentifier *typed) {
         typed = typed->Modify($ CYTypeConstant());
 }
 
         typed = typed->Modify($ CYTypeConstant());
 }
 

-static CYTypedIdentifier *CYDecodeType(CXType type) {
-    CYTypedIdentifier *typed($ CYTypedIdentifier(NULL));
+static CYType *CYDecodeType(CXType type) {
+    CYType *typed($ CYType(NULL));

     CYParseType(type, typed);
     return typed;
 }
     CYParseType(type, typed);
     return typed;
 }


@@ -469,22 +483,48 @@ static CXChildVisitResult CYChildVisit(CXCursor cursor, CXCursor parent, CXClien
     CYChildBaton &baton(*static_cast<CYChildBaton *>(arg));
     CXTranslationUnit &unit(baton.unit);
 
     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 priority(2);
     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::cerr << spelling << " " << position << std::endl;*/
 
 
     /*CXSourceLocation location(clang_getCursorLocation(cursor));
     CYCXPosition<> position(location);
     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_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);
             CXSourceRange range(clang_getCursorExtent(cursor));
             CYTokens tokens(unit, range);
             _assert(tokens.size() != 0);


@@ -537,10 +577,6 @@ static CXChildVisitResult CYChildVisit(CXCursor cursor, CXCursor parent, CXClien
                 value << body.str();
                 out << ';' << '}' << ')';
             }
                 value << body.str();
                 out << ';' << '}' << ')';
             }

-        } catch (const CYException &error) {
-            CYPool pool;
-            //std::cerr << error.PoolCString(pool) << std::endl;
-            goto skip;

         } break;
 
         case CXCursor_StructDecl: {
         } break;
 
         case CXCursor_StructDecl: {


@@ -549,25 +585,24 @@ static CXChildVisitResult CYChildVisit(CXCursor cursor, CXCursor parent, CXClien
             if (!clang_isCursorDefinition(cursor))
                 priority = 1;
 
             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);
+
+            CYOptions options;
+            CYOutput out(*value.rdbuf(), options);
+            CYTypeExpression(&typed).Output(out, CYNoBFC);

 
 

-            value << "new Type([" << types.str() << "],[" << names.str() << "]).withName(\"" << name << "\")";
-            name += "$cy";
+            value << ".withName(\"" << name << "\")";
+            name = "$cys" + name;
+            flags = CYBridgeType;

         } break;
 
         } break;
 

-        case CXCursor_TypedefDecl: try {
+        case CXCursor_TypedefDecl: {

             CYLocalPool local;
 
             CYLocalPool local;
 

-            CYTypedIdentifier *typed(CYDecodeType(clang_getTypedefDeclUnderlyingType(cursor)));
+            CYType *typed(CYDecodeType(clang_getTypedefDeclUnderlyingType(cursor)));

             if (typed->specifier_ == NULL)
                 value << "(typedef " << CYCXString(clang_getTypeSpelling(clang_getTypedefDeclUnderlyingType(cursor))) << ")";
             else {
             if (typed->specifier_ == NULL)
                 value << "(typedef " << CYCXString(clang_getTypeSpelling(clang_getTypedefDeclUnderlyingType(cursor))) << ")";
             else {


@@ -575,14 +610,10 @@ static CXChildVisitResult CYChildVisit(CXCursor cursor, CXCursor parent, CXClien
                 CYOutput out(*value.rdbuf(), options);
                 CYTypeExpression(typed).Output(out, CYNoBFC);
             }
                 CYOutput out(*value.rdbuf(), options);
                 CYTypeExpression(typed).Output(out, CYNoBFC);
             }

-        } catch (const CYException &error) {
-            CYPool pool;
-            //std::cerr << error.PoolCString(pool) << std::endl;
-            goto skip;

         } break;
 
         case CXCursor_FunctionDecl:
         } break;
 
         case CXCursor_FunctionDecl:

-        case CXCursor_VarDecl: try {
+        case CXCursor_VarDecl: {

             std::string label;
 
             CYList<CYFunctionParameter> parameters;
             std::string label;
 
             CYList<CYFunctionParameter> parameters;


@@ -632,28 +663,26 @@ static CXChildVisitResult CYChildVisit(CXCursor cursor, CXCursor parent, CXClien
                 function->Output(out, CYNoBFC);
                 //std::cerr << value.str() << std::endl;
             }
                 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;
         } break;

-    }

 
 

-    {
+        default:
+            result = CXChildVisit_Recurse;
+            goto skip;
+        break;
+    } {

         CYKey &key(baton.keys[name]);
         CYKey &key(baton.keys[name]);

-        if (key.priority_ < priority) {
+        if (key.priority_ <= priority) {

             key.priority_ = priority;
             key.code_ = value.str();
             key.flags_ = flags;
         }
             key.priority_ = priority;
             key.code_ = value.str();
             key.flags_ = flags;
         }

+    } } catch (const CYException &error) {
+        CYPool pool;
+        //std::cerr << error.PoolCString(pool) << std::endl;

     }
 
   skip:
     }
 
   skip:

-    return CXChildVisit_Continue;
+    return result;

 }
 
 int main(int argc, const char *argv[]) {
 }
 
 int main(int argc, const char *argv[]) {