{"id":670,"date":"2010-08-19T05:01:01","date_gmt":"2010-08-19T10:01:01","guid":{"rendered":"http:\/\/vgable.com\/blog\/?p=670"},"modified":"2010-09-17T15:22:43","modified_gmt":"2010-09-17T20:22:43","slug":"the-most-useful-objective-c-code-ive-ever-written","status":"publish","type":"post","link":"https:\/\/vgable.com\/blog\/2010\/08\/19\/the-most-useful-objective-c-code-ive-ever-written\/","title":{"rendered":"The Most Useful Objective-C Code I’ve Ever Written"},"content":{"rendered":"

Actually, it’s the most useful code I’ve extended<\/em>; credit for the core idea goes to Dave Dribin<\/a> with his Handy NSString Conversion Macro<\/cite><\/a>.<\/p>\n

LOG_EXPR<\/a>(x)<\/code> is a macro that prints out x<\/code>, no matter what type x<\/code> is<\/strong>, without having to worry about format-strings (and related crashes from eg. printing a C-string the same way as an NSString<\/code>). It works on Mac OS X and iOS. Here are some examples,<\/p>\n

LOG_EXPR(self.window.screen);<\/code><\/p>\n

self.window.screen = <UIScreen: 0x6d20780; bounds = {{0, 0}, {320, 480}}; mode = <UIScreenMode: 0x6d20c50; size = 320.000000 x 480.000000>>\n<\/p><\/blockquote>\n

LOG_EXPR(self.tabBarController.viewControllers);<\/code><\/p>\n

self.tabBarController.viewControllers = (
\n “<UINavigationController: 0xcd02e00>”,
\n “<SavingsViewController: 0xcd05c40>”,
\n “<SettingsViewController: 0xcd05e90>”
\n)<\/p><\/blockquote>\n

Pretty straightforward, really. The biggest convenience so far is having the expression printed out, so you don’t have to write out a name redundantly in the format string (eg. NSLog(@\"actionURL = %@\", actionURL)<\/code>). But LOG_EXPR<\/code> really shows it’s worth when you start using scalar or struct<\/code> expressions:<\/p>\n

LOG_EXPR(self.window.windowLevel);<\/code><\/p>\n

self.window.windowLevel = 0.000000<\/p><\/blockquote>\n

LOG_EXPR(self.window.frame.size);<\/code><\/p>\n

self.window.frame.size = {320, 480}<\/p><\/blockquote>\n

Yes, there are expressions that won’t work, but they’re pretty rare for me. I use LOG_EXPR<\/code> every day. Several times. It’s not quite as good as having a REPL for Cocoa<\/a>, but it’s handy.<\/p>\n

Give it a try<\/a>.<\/p>\n

How It Works<\/h3>\n

The problem is how to pick a function or format string to print x<\/code>, based on the type of x<\/code>. C++’s type-based dispatch would be a good fit here, but it’s verbose (a full function-definition per type) and I wanted to use pure Objective-C if possible. Fortunately, Objective-C has an @encode()<\/code><\/a> compiler directive that returns a string describing any type it’s given.<\/strong> Unfortunately it works on types<\/em>, not variables, but with C99 the typeof()<\/a><\/code> compiler directive lets us get the type of any variable<\/strong>, which we can pass to @encode()<\/code>. The final bit of compiler magic is using stringification (#<\/code>)<\/a> to print out the literal string inside LOG_EXPR()<\/code>‘s parenthesis.<\/p>\n

The Macro, Line By Line<\/h3>\n
\n
\n1 #define LOG_EXPR(_X_) do{\\\n2 \t__typeof__(_X_) _Y_ = (_X_);\\\n3 \tconst char * _TYPE_CODE_ = @encode(__typeof__(_X_));\\\n4 \tNSString *_STR_ = VTPG_DDToStringFromTypeAndValue(_TYPE_CODE_, &_Y_);\\\n5 \tif(_STR_)\\\n6 \t\tNSLog(@\"%s = %@\", #_X_, _STR_);\\\n7 \telse\\\n8 \t\tNSLog(@\"Unknown _TYPE_CODE_: %s for expression %s in function %s, file %s, line %d\", _TYPE_CODE_, #_X_, __func__, __FILE__, __LINE__);\\\n9 }while(0)\n<\/pre>\n<\/div>\n
    \n
  1. The first and last lines are a way to put {}<\/code>‘s around the macro to prevent unintended effects<\/a>. The do{}while(0);<\/code> “loop” does nothing else.<\/li>\n
  2. First evaluate the expression, _X_<\/code>, given to LOG_EXPR<\/code> once<\/em>, and store the result in a _Y_<\/code>. We need to use typeof()<\/a><\/code> (which had to be written __typeof__()<\/code> to appease some versions of GCC) to figure out the type of _Y_<\/code>.<\/li>\n
  3. _TYPE_CODE_<\/code> is c-string that describes the type<\/a> of the expression we want to print out.<\/li>\n
  4. Now we have enough information to call a function, VTPG_DDToStringFromTypeAndValue()<\/code> to convert the expression’s value to a string. We pass it the _TYPE_CODE_<\/code> string, and the address of <\/em> _Y_<\/code>, which is a pointer, and has a known size. We can’t pass _Y_<\/code> directly, because depending on what _X_<\/code> is, it will have different types and could be of any size.<\/li>\n
  5. VTPG_DDToStringFromTypeAndValue()<\/code> returns nil<\/code> if it can’t figure out how to convert a value to a string.<\/li>\n
  6. Everything went well, print the stringified<\/a> expression, #_X_<\/code>, and  the string representing it’s value, _STR_<\/code>.<\/li>\n
  7. otherwise\u2026<\/li>\n
  8. The expression had a type we can’t handle, print out a verbose diagnostic message.<\/li>\n
  9. See line 1.<\/li>\n<\/ol>\n
    The VTPG_DDToStringFromTypeAndValue()<\/code> Function<\/h3>\n
    See the source in VTPG_Common.m<\/a>:<\/p>\n