Analyze.cpp

   1 /* Cycript - The Truly Universal Scripting Language
   2  * Copyright (C) 2009-2016  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU Affero General Public License, Version 3 {{{ */
   6 /*
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 **/
  20 /* }}} */
  21
  22 #include <cmath>
  23 #include <cstring>
  24 #include <iostream>
  25 #include <map>
  26 #include <sstream>
  27 #include <string>
  28
  29 #include <clang-c/Index.h>
  30
  31 #include "Bridge.hpp"
  32 #include "Functor.hpp"
  33 #include "Replace.hpp"
  34 #include "Syntax.hpp"
  35
  36 static CXChildVisitResult CYVisit(CXCursor cursor, CXCursor parent, CXClientData arg) {
  37     (*reinterpret_cast<const Functor<void (CXCursor)> *>(arg))(cursor);
  38     return CXChildVisit_Continue;
  39 }
  40
  41 static unsigned CYForChild(CXCursor cursor, const Functor<void (CXCursor)> &visitor) {
  42     return clang_visitChildren(cursor, &CYVisit, const_cast<void *>(static_cast<const void *>(&visitor)));
  43 }
  44
  45 static bool CYOneChild(CXCursor cursor, const Functor<void (CXCursor)> &visitor) {
  46     bool visited(false);
  47     CYForChild(cursor, fun([&](CXCursor child) {
  48         _assert(!visited);
  49         visited = true;
  50         visitor(child);
  51     }));
  52     return visited;
  53 }
  54
  55 struct CYCXString {
  56     CXString value_;
  57
  58     CYCXString(CXString value) :
  59         value_(value)
  60     {
  61     }
  62
  63     CYCXString(CXCursor cursor) :
  64         value_(clang_getCursorSpelling(cursor))
  65     {
  66     }
  67
  68     CYCXString(CXCursorKind kind) :
  69         value_(clang_getCursorKindSpelling(kind))
  70     {
  71     }
  72
  73     CYCXString(CXFile file) :
  74         value_(clang_getFileName(file))
  75     {
  76     }
  77
  78     CYCXString(CXTranslationUnit unit, CXToken token) :
  79         value_(clang_getTokenSpelling(unit, token))
  80     {
  81     }
  82
  83     ~CYCXString() {
  84         clang_disposeString(value_);
  85     }
  86
  87     operator const char *() const {
  88         return clang_getCString(value_);
  89     }
  90
  91     const char *Pool(CYPool &pool) const {
  92         return pool.strdup(*this);
  93     }
  94
  95     bool operator ==(const char *rhs) const {
  96         const char *lhs(*this);
  97         return lhs == rhs || strcmp(lhs, rhs) == 0;
  98     }
  99 };
 100
 101 template <void (&clang_get_Location)(CXSourceLocation, CXFile *, unsigned *, unsigned *, unsigned *) = clang_getSpellingLocation>
 102 struct CYCXPosition {
 103     CXFile file_;
 104     unsigned line_;
 105     unsigned column_;
 106     unsigned offset_;
 107
 108     CYCXPosition(CXSourceLocation location) {
 109         clang_get_Location(location, &file_, &line_, &column_, &offset_);
 110     }
 111
 112     CYCXPosition(CXTranslationUnit unit, CXToken token) :
 113         CYCXPosition(clang_getTokenLocation(unit, token))
 114     {
 115     }
 116
 117     CXSourceLocation Get(CXTranslationUnit unit) const {
 118         return clang_getLocation(unit, file_, line_, column_);
 119     }
 120 };
 121
 122 template <void (&clang_get_Location)(CXSourceLocation, CXFile *, unsigned *, unsigned *, unsigned *)>
 123 std::ostream &operator <<(std::ostream &out, const CYCXPosition<clang_get_Location> &position) {
 124     if (position.file_ != NULL)
 125         out << "[" << CYCXString(position.file_) << "]:";
 126     out << position.line_ << ":" << position.column_ << "@" << position.offset_;
 127     return out;
 128 }
 129
 130 struct CYKey {
 131     unsigned priority_ = 0;
 132
 133     std::string code_;
 134     unsigned flags_;
 135 };
 136
 137 typedef std::map<std::string, CYKey> CYKeyMap;
 138
 139 struct CYChildBaton {
 140     CXTranslationUnit unit;
 141     CYKeyMap &keys;
 142
 143     CYChildBaton(CXTranslationUnit unit, CYKeyMap &keys) :
 144         unit(unit),
 145         keys(keys)
 146     {
 147     }
 148 };
 149
 150 struct CYTokens {
 151   private:
 152     CXTranslationUnit unit_;
 153     CXToken *tokens_;
 154     unsigned count_;
 155     unsigned valid_;
 156
 157   public:
 158     CYTokens(CXTranslationUnit unit, CXSourceRange range) :
 159         unit_(unit)
 160     {
 161         clang_tokenize(unit_, range, &tokens_, &count_);
 162
 163
 164         // libclang's tokenizer is horribly broken and returns "extra" tokens.
 165         // this code goes back through the tokens and filters for good ones :/
 166
 167         CYCXPosition<> end(clang_getRangeEnd(range));
 168         CYCXString file(end.file_);
 169
 170         for (valid_ = 0; valid_ != count_; ++valid_) {
 171             CYCXPosition<> position(unit, tokens_[valid_]);
 172             _assert(CYCXString(position.file_) == file);
 173             if (position.offset_ >= end.offset_)
 174                 break;
 175         }
 176     }
 177
 178     CYTokens(CXTranslationUnit unit, CXCursor cursor) :
 179         CYTokens(unit, clang_getCursorExtent(cursor))
 180     {
 181     }
 182
 183     ~CYTokens() {
 184         clang_disposeTokens(unit_, tokens_, count_);
 185     }
 186
 187     operator CXToken *() const {
 188         return tokens_;
 189     }
 190
 191     size_t size() const {
 192         return valid_;
 193     }
 194 };
 195
 196 static CYUTF8String CYCXPoolUTF8Range(CYPool &pool, CXSourceRange range) {
 197     CYCXPosition<> start(clang_getRangeStart(range));
 198     CYCXPosition<> end(clang_getRangeEnd(range));
 199     CYCXString file(start.file_);
 200     _assert(file == CYCXString(end.file_));
 201
 202     CYPool temp;
 203     size_t size;
 204     char *data(static_cast<char *>(CYPoolFile(temp, file, &size)));
 205     _assert(start.offset_ <= size && end.offset_ <= size && start.offset_ <= end.offset_);
 206
 207     CYUTF8String code;
 208     code.size = end.offset_ - start.offset_;
 209     code.data = pool.strndup(data + start.offset_, code.size);
 210     return code;
 211 }
 212
 213 static CYExpression *CYTranslateExpression(CXTranslationUnit unit, CXCursor cursor) {
 214     switch (CXCursorKind kind = clang_getCursorKind(cursor)) {
 215         case CXCursor_CallExpr: {
 216             CYExpression *function(NULL);
 217             CYList<CYArgument> arguments;
 218             CYForChild(cursor, fun([&](CXCursor child) {
 219                 CYExpression *expression(CYTranslateExpression(unit, child));
 220                 if (function == NULL)
 221                     function = expression;
 222                 else
 223                     arguments->*$C_(expression);
 224             }));
 225             return $C(function, arguments);
 226         } break;
 227
 228         case CXCursor_DeclRefExpr: {
 229             return $V(CYCXString(cursor).Pool($pool));
 230         } break;
 231
 232         case CXCursor_IntegerLiteral: {
 233             // libclang doesn't provide any reasonable way to do this
 234             // note: clang_tokenize doesn't work if this is a macro
 235             // the token range starts inside the macro but ends after it
 236             // the tokenizer freaks out and either fails with 0 tokens
 237             // or returns some massive number of tokens ending here :/
 238
 239             CYUTF8String token(CYCXPoolUTF8Range($pool, clang_getCursorExtent(cursor)));
 240             double value(CYCastDouble(token));
 241             if (std::isnan(value))
 242                 return $V(token.data);
 243             return $ CYNumber(value);
 244         } break;
 245
 246         case CXCursor_CStyleCastExpr:
 247             // XXX: most of the time, this is a "NoOp" integer cast; but we should check it
 248
 249         case CXCursor_UnexposedExpr:
 250             // there is a very high probability that this is actually an "ImplicitCastExpr"
 251             // "Douglas Gregor" <dgregor@apple.com> err'd on the incorrect side of this one
 252             // http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20110926/046998.html
 253
 254         case CXCursor_ParenExpr: {
 255             CYExpression *pass(NULL);
 256             CYOneChild(cursor, fun([&](CXCursor child) {
 257                 pass = CYTranslateExpression(unit, child);
 258             }));
 259             return pass;
 260         } break;
 261
 262         default:
 263             //std::cerr << "E:" << CYCXString(kind) << std::endl;
 264             _assert(false);
 265     }
 266 }
 267
 268 static CYStatement *CYTranslateStatement(CXTranslationUnit unit, CXCursor cursor) {
 269     switch (CXCursorKind kind = clang_getCursorKind(cursor)) {
 270         case CXCursor_ReturnStmt: {
 271             CYExpression *value(NULL);
 272             CYOneChild(cursor, fun([&](CXCursor child) {
 273                 value = CYTranslateExpression(unit, child);
 274             }));
 275             return $ CYReturn(value);
 276         } break;
 277
 278         default:
 279             //std::cerr << "S:" << CYCXString(kind) << std::endl;
 280             _assert(false);
 281     }
 282 }
 283
 284 static CYStatement *CYTranslateBlock(CXTranslationUnit unit, CXCursor cursor) {
 285     CYList<CYStatement> statements;
 286     CYForChild(cursor, fun([&](CXCursor child) {
 287         statements->*CYTranslateStatement(unit, child);
 288     }));
 289     return $ CYBlock(statements);
 290 }
 291
 292 static CYTypedIdentifier *CYDecodeType(CXType type);
 293 static void CYParseType(CXType type, CYTypedIdentifier *typed);
 294
 295 static CYTypedIdentifier *CYDecodeType(CXType type, const CYCXString &identifier) {
 296     CYTypedIdentifier *typed(CYDecodeType(type));
 297     typed->identifier_ = $ CYIdentifier(identifier.Pool($pool));
 298     return typed;
 299 }
 300
 301 static void CYParseEnumeration(CXCursor cursor, CYTypedIdentifier *typed) {
 302     CYList<CYEnumConstant> constants;
 303
 304     CYForChild(cursor, fun([&](CXCursor child) {
 305         if (clang_getCursorKind(child) == CXCursor_EnumConstantDecl)
 306             constants->*$ CYEnumConstant($I($pool.strdup(CYCXString(child))), $D(clang_getEnumConstantDeclValue(child)));
 307     }));
 308
 309     CYTypedIdentifier *integer(CYDecodeType(clang_getEnumDeclIntegerType(cursor)));
 310     typed->specifier_ = $ CYTypeEnum(NULL, integer->specifier_, constants);
 311 }
 312
 313 static void CYParseStructure(CXCursor cursor, CYTypedIdentifier *typed) {
 314     CYList<CYTypeStructField> fields;
 315     CYForChild(cursor, fun([&](CXCursor child) {
 316         if (clang_getCursorKind(child) == CXCursor_FieldDecl) {
 317             CYTypedIdentifier *field(CYDecodeType(clang_getCursorType(child), child));
 318             fields->*$ CYTypeStructField(field);
 319         }
 320     }));
 321
 322     typed->specifier_ = $ CYTypeStruct(NULL, $ CYStructTail(fields));
 323 }
 324
 325 static void CYParseCursor(CXType type, CXCursor cursor, CYTypedIdentifier *typed) {
 326     CYCXString spelling(cursor);
 327
 328     switch (CXCursorKind kind = clang_getCursorKind(cursor)) {
 329         case CXCursor_EnumDecl:
 330             if (spelling[0] != '\0')
 331                 typed->specifier_ = $ CYTypeReference(CYTypeReferenceEnum, $I(spelling.Pool($pool)));
 332             else
 333                 CYParseEnumeration(cursor, typed);
 334         break;
 335
 336         case CXCursor_StructDecl: {
 337             if (spelling[0] != '\0')
 338                 typed->specifier_ = $ CYTypeReference(CYTypeReferenceStruct, $I(spelling.Pool($pool)));
 339             else
 340                 CYParseStructure(cursor, typed);
 341         } break;
 342
 343         case CXCursor_UnionDecl: {
 344             _assert(false);
 345         } break;
 346
 347         default:
 348             std::cerr << "C:" << CYCXString(kind) << std::endl;
 349             _assert(false);
 350             break;
 351     }
 352 }
 353
 354 static CYTypedParameter *CYParseSignature(CXType type, CYTypedIdentifier *typed) {
 355     CYParseType(clang_getResultType(type), typed);
 356     CYList<CYTypedParameter> parameters;
 357     for (int i(0), e(clang_getNumArgTypes(type)); i != e; ++i)
 358         parameters->*$ CYTypedParameter(CYDecodeType(clang_getArgType(type, i)));
 359     return parameters;
 360 }
 361
 362 static void CYParseFunction(CXType type, CYTypedIdentifier *typed) {
 363     typed = typed->Modify($ CYTypeFunctionWith(clang_isFunctionTypeVariadic(type), CYParseSignature(type, typed)));
 364 }
 365
 366 static void CYParseType(CXType type, CYTypedIdentifier *typed) {
 367     switch (CXTypeKind kind = type.kind) {
 368         case CXType_Unexposed: {
 369             CXType result(clang_getResultType(type));
 370             if (result.kind == CXType_Invalid)
 371                 CYParseCursor(type, clang_getTypeDeclaration(type), typed);
 372             else
 373                 // clang marks function pointers as Unexposed but still supports them
 374                 CYParseFunction(type, typed);
 375         } break;
 376
 377         case CXType_Bool: typed->specifier_ = $ CYTypeVariable("bool"); break;
 378         case CXType_Float: typed->specifier_ = $ CYTypeVariable("float"); break;
 379         case CXType_Double: typed->specifier_ = $ CYTypeVariable("double"); break;
 380
 381         case CXType_Char_U: typed->specifier_ = $ CYTypeCharacter(CYTypeNeutral); break;
 382         case CXType_Char_S: typed->specifier_ = $ CYTypeCharacter(CYTypeNeutral); break;
 383         case CXType_SChar: typed->specifier_ = $ CYTypeCharacter(CYTypeSigned); break;
 384         case CXType_UChar: typed->specifier_ = $ CYTypeCharacter(CYTypeUnsigned); break;
 385
 386         case CXType_Short: typed->specifier_ = $ CYTypeIntegral(CYTypeSigned, 0); break;
 387         case CXType_UShort: typed->specifier_ = $ CYTypeIntegral(CYTypeUnsigned, 0); break;
 388
 389         case CXType_Int: typed->specifier_ = $ CYTypeIntegral(CYTypeSigned, 1); break;
 390         case CXType_UInt: typed->specifier_ = $ CYTypeIntegral(CYTypeUnsigned, 1); break;
 391
 392         case CXType_Long: typed->specifier_ = $ CYTypeIntegral(CYTypeSigned, 2); break;
 393         case CXType_ULong: typed->specifier_ = $ CYTypeIntegral(CYTypeUnsigned, 2); break;
 394
 395         case CXType_LongLong: typed->specifier_ = $ CYTypeIntegral(CYTypeSigned, 3); break;
 396         case CXType_ULongLong: typed->specifier_ = $ CYTypeIntegral(CYTypeUnsigned, 3); break;
 397
 398         case CXType_Int128: typed->specifier_ = $ CYTypeInt128(CYTypeSigned); break;
 399         case CXType_UInt128: typed->specifier_ = $ CYTypeInt128(CYTypeUnsigned); break;
 400
 401         case CXType_BlockPointer: {
 402             CXType pointee(clang_getPointeeType(type));
 403             _assert(!clang_isFunctionTypeVariadic(pointee));
 404             typed = typed->Modify($ CYTypeBlockWith(CYParseSignature(pointee, typed)));
 405         } break;
 406
 407         case CXType_ConstantArray:
 408             CYParseType(clang_getArrayElementType(type), typed);
 409             typed = typed->Modify($ CYTypeArrayOf($D(clang_getArraySize(type))));
 410         break;
 411
 412         case CXType_Enum:
 413             typed->specifier_ = $ CYTypeVariable($pool.strdup(CYCXString(clang_getTypeSpelling(type))));
 414         break;
 415
 416         case CXType_FunctionProto:
 417             CYParseFunction(type, typed);
 418         break;
 419
 420         case CXType_IncompleteArray:
 421             // XXX: I probably should not decay to Pointer
 422             CYParseType(clang_getArrayElementType(type), typed);
 423             typed = typed->Modify($ CYTypePointerTo());
 424         break;
 425
 426         case CXType_ObjCClass:
 427             typed->specifier_ = $ CYTypeVariable("Class");
 428         break;
 429
 430         case CXType_ObjCId:
 431             typed->specifier_ = $ CYTypeVariable("id");
 432         break;
 433
 434         case CXType_ObjCInterface:
 435             typed->specifier_ = $ CYTypeVariable($pool.strdup(CYCXString(clang_getTypeSpelling(type))));
 436         break;
 437
 438         case CXType_ObjCObjectPointer: {
 439             CXType pointee(clang_getPointeeType(type));
 440             if (pointee.kind != CXType_Unexposed) {
 441                 CYParseType(pointee, typed);
 442                 typed = typed->Modify($ CYTypePointerTo());
 443             } else
 444                 // Clang seems to have internal typedefs for id and Class that are awkward
 445                 _assert(false);
 446         } break;
 447
 448         case CXType_ObjCSel:
 449             typed->specifier_ = $ CYTypeVariable("SEL");
 450         break;
 451
 452         case CXType_Pointer:
 453             CYParseType(clang_getPointeeType(type), typed);
 454             typed = typed->Modify($ CYTypePointerTo());
 455         break;
 456
 457         case CXType_Record:
 458             typed->specifier_ = $ CYTypeReference(CYTypeReferenceStruct, $I($pool.strdup(CYCXString(clang_getTypeSpelling(type)))));
 459         break;
 460
 461         case CXType_Typedef:
 462             // use the declaration in order to isolate the name of the typedef itself
 463             typed->specifier_ = $ CYTypeVariable($pool.strdup(CYCXString(clang_getTypeDeclaration(type))));
 464         break;
 465
 466         case CXType_Vector:
 467             _assert(false);
 468         break;
 469
 470         case CXType_Void:
 471             typed->specifier_ = $ CYTypeVoid();
 472         break;
 473
 474         default:
 475             std::cerr << "T:" << CYCXString(clang_getTypeKindSpelling(kind)) << std::endl;
 476             std::cerr << "_: " << CYCXString(clang_getTypeSpelling(type)) << std::endl;
 477             _assert(false);
 478     }
 479
 480     if (clang_isConstQualifiedType(type))
 481         typed = typed->Modify($ CYTypeConstant());
 482 }
 483
 484 static CYTypedIdentifier *CYDecodeType(CXType type) {
 485     CYTypedIdentifier *typed($ CYTypedIdentifier(NULL));
 486     CYParseType(type, typed);
 487     return typed;
 488 }
 489
 490 static CXChildVisitResult CYChildVisit(CXCursor cursor, CXCursor parent, CXClientData arg) {
 491     CYChildBaton &baton(*static_cast<CYChildBaton *>(arg));
 492     CXTranslationUnit &unit(baton.unit);
 493
 494     CXChildVisitResult result(CXChildVisit_Continue);
 495     CYCXString spelling(cursor);
 496     std::string name(spelling);
 497     std::ostringstream value;
 498     unsigned priority(2);
 499     unsigned flags(CYBridgeHold);
 500
 501     /*CXSourceLocation location(clang_getCursorLocation(cursor));
 502     CYCXPosition<> position(location);
 503     std::cerr << spelling << " " << position << std::endl;*/
 504
 505     try { switch (CXCursorKind kind = clang_getCursorKind(cursor)) {
 506         case CXCursor_EnumConstantDecl: {
 507             value << clang_getEnumConstantDeclValue(cursor);
 508         } break;
 509
 510         case CXCursor_EnumDecl: {
 511             if (spelling[0] == '\0')
 512                 goto skip;
 513             // XXX: this was blindly copied from StructDecl
 514             if (!clang_isCursorDefinition(cursor))
 515                 priority = 1;
 516
 517             CYLocalPool pool;
 518
 519             CYTypedIdentifier typed(NULL);
 520             CYParseEnumeration(cursor, &typed);
 521
 522             CYOptions options;
 523             CYOutput out(*value.rdbuf(), options);
 524             CYTypeExpression(&typed).Output(out, CYNoBFC);
 525
 526             value << ".withName(\"" << name << "\")";
 527             name = "$cye" + name;
 528             flags = CYBridgeType;
 529
 530             // the enum constants are implemented separately *also*
 531             // XXX: maybe move output logic to function we can call
 532             result = CXChildVisit_Recurse;
 533         } break;
 534
 535         case CXCursor_MacroDefinition: {
 536             CXSourceRange range(clang_getCursorExtent(cursor));
 537             CYTokens tokens(unit, range);
 538             _assert(tokens.size() != 0);
 539
 540             CXCursor cursors[tokens.size()];
 541             clang_annotateTokens(unit, tokens, tokens.size(), cursors);
 542
 543             CYLocalPool local;
 544             CYList<CYFunctionParameter> parameters;
 545             unsigned offset(1);
 546
 547             if (tokens.size() != 1) {
 548                 CYCXPosition<> start(clang_getRangeStart(range));
 549                 CYCXString first(unit, tokens[offset]);
 550                 if (first == "(") {
 551                     CYCXPosition<> paren(unit, tokens[offset]);
 552                     if (start.offset_ + strlen(spelling) == paren.offset_) {
 553                         for (;;) {
 554                             _assert(++offset != tokens.size());
 555                             CYCXString token(unit, tokens[offset]);
 556                             parameters->*$P($B($I(token.Pool($pool))));
 557                             _assert(++offset != tokens.size());
 558                             CYCXString comma(unit, tokens[offset]);
 559                             if (comma == ")")
 560                                 break;
 561                             _assert(comma == ",");
 562                         }
 563                         ++offset;
 564                     }
 565                 }
 566             }
 567
 568             std::ostringstream body;
 569             for (unsigned i(offset); i != tokens.size(); ++i) {
 570                 CYCXString token(unit, tokens[i]);
 571                 if (i != offset)
 572                     body << " ";
 573                 body << token;
 574             }
 575
 576             if (!parameters)
 577                 value << body.str();
 578             else {
 579                 CYOptions options;
 580                 CYOutput out(*value.rdbuf(), options);
 581                 out << '(' << "function" << '(';
 582                 out << parameters;
 583                 out << ')' << '{';
 584                 out << "return" << ' ';
 585                 value << body.str();
 586                 out << ';' << '}' << ')';
 587             }
 588         } break;
 589
 590         case CXCursor_StructDecl: {
 591             if (spelling[0] == '\0')
 592                 goto skip;
 593             if (!clang_isCursorDefinition(cursor))
 594                 priority = 1;
 595
 596             CYLocalPool pool;
 597
 598             CYTypedIdentifier typed(NULL);
 599             CYParseStructure(cursor, &typed);
 600
 601             CYOptions options;
 602             CYOutput out(*value.rdbuf(), options);
 603             CYTypeExpression(&typed).Output(out, CYNoBFC);
 604
 605             value << ".withName(\"" << name << "\")";
 606             name = "$cys" + name;
 607             flags = CYBridgeType;
 608         } break;
 609
 610         case CXCursor_TypedefDecl: {
 611             CYLocalPool local;
 612
 613             CYTypedIdentifier *typed(CYDecodeType(clang_getTypedefDeclUnderlyingType(cursor)));
 614             if (typed->specifier_ == NULL)
 615                 value << "(typedef " << CYCXString(clang_getTypeSpelling(clang_getTypedefDeclUnderlyingType(cursor))) << ")";
 616             else {
 617                 CYOptions options;
 618                 CYOutput out(*value.rdbuf(), options);
 619                 CYTypeExpression(typed).Output(out, CYNoBFC);
 620             }
 621         } break;
 622
 623         case CXCursor_FunctionDecl:
 624         case CXCursor_VarDecl: {
 625             std::string label;
 626
 627             CYList<CYFunctionParameter> parameters;
 628             CYStatement *code(NULL);
 629
 630             CYLocalPool local;
 631
 632             CYForChild(cursor, fun([&](CXCursor child) {
 633                 switch (CXCursorKind kind = clang_getCursorKind(child)) {
 634                     case CXCursor_AsmLabelAttr:
 635                         label = CYCXString(child);
 636                         break;
 637
 638                     case CXCursor_CompoundStmt:
 639                         code = CYTranslateBlock(unit, child);
 640                         break;
 641
 642                     case CXCursor_ParmDecl:
 643                         parameters->*$P($B($I(CYCXString(child).Pool($pool))));
 644                         break;
 645
 646                     case CXCursor_IntegerLiteral:
 647                     case CXCursor_ObjCClassRef:
 648                     case CXCursor_TypeRef:
 649                     case CXCursor_UnexposedAttr:
 650                         break;
 651
 652                     default:
 653                         //std::cerr << "A:" << CYCXString(child) << std::endl;
 654                         break;
 655                 }
 656             }));
 657
 658             if (label.empty()) {
 659                 label = spelling;
 660                 label = '_' + label;
 661             } else if (label[0] != '_')
 662                 goto skip;
 663
 664             if (code == NULL) {
 665                 CXType type(clang_getCursorType(cursor));
 666                 value << "*(typedef " << CYCXString(clang_getTypeSpelling(type)) << ").pointerTo()(dlsym(RTLD_DEFAULT,'" << label.substr(1) << "'))";
 667             } else {
 668                 CYOptions options;
 669                 CYOutput out(*value.rdbuf(), options);
 670                 CYFunctionExpression *function($ CYFunctionExpression(NULL, parameters, code));
 671                 function->Output(out, CYNoBFC);
 672                 //std::cerr << value.str() << std::endl;
 673             }
 674         } break;
 675
 676         default:
 677             result = CXChildVisit_Recurse;
 678             goto skip;
 679         break;
 680     } {
 681         CYKey &key(baton.keys[name]);
 682         if (key.priority_ <= priority) {
 683             key.priority_ = priority;
 684             key.code_ = value.str();
 685             key.flags_ = flags;
 686         }
 687     } } catch (const CYException &error) {
 688         CYPool pool;
 689         //std::cerr << error.PoolCString(pool) << std::endl;
 690     }
 691
 692   skip:
 693     return result;
 694 }
 695
 696 int main(int argc, const char *argv[]) {
 697     CXIndex index(clang_createIndex(0, 0));
 698
 699     const char *file(argv[1]);
 700
 701     unsigned offset(3);
 702 #if CY_OBJECTIVEC
 703     argv[--offset] = "-ObjC++";
 704 #endif
 705
 706     CXTranslationUnit unit(clang_parseTranslationUnit(index, file, argv + offset, argc - offset, NULL, 0, CXTranslationUnit_DetailedPreprocessingRecord));
 707
 708     for (unsigned i(0), e(clang_getNumDiagnostics(unit)); i != e; ++i) {
 709         CXDiagnostic diagnostic(clang_getDiagnostic(unit, i));
 710         CYCXString spelling(clang_getDiagnosticSpelling(diagnostic));
 711         std::cerr << spelling << std::endl;
 712     }
 713
 714     CYKeyMap keys;
 715     CYChildBaton baton(unit, keys);
 716     clang_visitChildren(clang_getTranslationUnitCursor(unit), &CYChildVisit, &baton);
 717
 718     for (CYKeyMap::const_iterator key(keys.begin()); key != keys.end(); ++key) {
 719         std::string code(key->second.code_);
 720         for (size_t i(0), e(code.size()); i != e; ++i)
 721             if (code[i] <= 0 || code[i] >= 0x7f || code[i] == '\n')
 722                 goto skip;
 723         std::cout << key->first << "|" << key->second.flags_ << "\"" << code << "\"" << std::endl;
 724     skip:; }
 725
 726     clang_disposeTranslationUnit(unit);
 727     clang_disposeIndex(index);
 728
 729     return 0;
 730 }