1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" 2 "http://www.w3.org/TR/html4/strict.dtd"> 3 <!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ --> 4 <html> 5 <head> 6 <META http-equiv="Content-Type" content="text/html; charset=UTF8"> 7 <title>Objective-C Literals</title> 8 <link type="text/css" rel="stylesheet" href="../menu.css"> 9 <link type="text/css" rel="stylesheet" href="../content.css"> 10 <style type="text/css"> 11 td { 12 vertical-align: top; 13 } 14 th { background-color: #ffddaa; } 15 </style> 16 </head> 17 <body> 18 19 <!--#include virtual="../menu.html.incl"--> 20 21 <div id="content"> 22 23 <h1>Objective-C Literals</h1> 24 25 <h2>Introduction</h2> 26 27 Three new features were introduced into clang at the same time: <i>NSNumber Literals</i> provide a syntax for creating <code>NSNumber</code> from scalar literal expressions; <i>Collection Literals</i> provide a short-hand for creating arrays and dictionaries; <i>Object Subscripting</i> provides a way to use subscripting with Objective-C objects. Users of Apple compiler releases can use these features starting with the Apple LLVM Compiler 4.0. Users of open-source LLVM.org compiler releases can use these features starting with clang v3.1.<p> 28 29 These language additions simplify common Objective-C programming patterns, make programs more concise, and improve the safety of container creation.<p> 30 31 This document describes how the features are implemented in clang, and how to use them in your own programs.<p> 32 33 <h2>NSNumber Literals</h2> 34 35 The framework class <code>NSNumber</code> is used to wrap scalar values inside objects: signed and unsigned integers (<code>char</code>, <code>short</code>, <code>int</code>, <code>long</code>, <code>long long</code>), floating point numbers (<code>float</code>, <code>double</code>), and boolean values (<code>BOOL</code>, C++ <code>bool</code>). Scalar values wrapped in objects are also known as <i>boxed</i> values.<p> 36 37 In Objective-C, any character, numeric or boolean literal prefixed with the <code>'@'</code> character will evaluate to a pointer to an <code>NSNumber</code> object initialized with that value. C's type suffixes may be used to control the size of numeric literals. 38 39 <h3>Examples</h3> 40 41 The following program illustrates the rules for <code>NSNumber</code> literals:<p> 42 43 <pre> 44 void main(int argc, const char *argv[]) { 45 // character literals. 46 NSNumber *theLetterZ = @'Z'; // equivalent to [NSNumber numberWithChar:'Z'] 47 48 // integral literals. 49 NSNumber *fortyTwo = @42; // equivalent to [NSNumber numberWithInt:42] 50 NSNumber *fortyTwoUnsigned = @42U; // equivalent to [NSNumber numberWithUnsignedInt:42U] 51 NSNumber *fortyTwoLong = @42L; // equivalent to [NSNumber numberWithLong:42L] 52 NSNumber *fortyTwoLongLong = @42LL; // equivalent to [NSNumber numberWithLongLong:42LL] 53 54 // floating point literals. 55 NSNumber *piFloat = @3.141592654F; // equivalent to [NSNumber numberWithFloat:3.141592654F] 56 NSNumber *piDouble = @3.1415926535; // equivalent to [NSNumber numberWithDouble:3.1415926535] 57 58 // BOOL literals. 59 NSNumber *yesNumber = @YES; // equivalent to [NSNumber numberWithBool:YES] 60 NSNumber *noNumber = @NO; // equivalent to [NSNumber numberWithBool:NO] 61 62 #ifdef __cplusplus 63 NSNumber *trueNumber = @true; // equivalent to [NSNumber numberWithBool:(BOOL)true] 64 NSNumber *falseNumber = @false; // equivalent to [NSNumber numberWithBool:(BOOL)false] 65 #endif 66 } 67 </pre> 68 69 <h3>Discussion</h3> 70 71 NSNumber literals only support literal scalar values after the <code>'@'</code>. Consequently, <code>@INT_MAX</code> works, but <code>@INT_MIN</code> does not, because they are defined like this:<p> 72 73 <pre> 74 #define INT_MAX 2147483647 /* max value for an int */ 75 #define INT_MIN (-2147483647-1) /* min value for an int */ 76 </pre> 77 78 The definition of <code>INT_MIN</code> is not a simple literal, but a parenthesized expression. Parenthesized 79 expressions are supported using the <a href="#objc_boxed_expressions">boxed expression</a> syntax, which is described in the next section.<p> 80 81 Because <code>NSNumber</code> does not currently support wrapping <code>long double</code> values, the use of a <code>long double NSNumber</code> literal (e.g. <code>@123.23L</code>) will be rejected by the compiler.<p> 82 83 Previously, the <code>BOOL</code> type was simply a typedef for <code>signed char</code>, and <code>YES</code> and <code>NO</code> were macros that expand to <code>(BOOL)1</code> and <code>(BOOL)0</code> respectively. To support <code>@YES</code> and <code>@NO</code> expressions, these macros are now defined using new language keywords in <code><objc/objc.h></code>:<p> 84 85 <pre> 86 #if __has_feature(objc_bool) 87 #define YES __objc_yes 88 #define NO __objc_no 89 #else 90 #define YES ((BOOL)1) 91 #define NO ((BOOL)0) 92 #endif 93 </pre> 94 95 The compiler implicitly converts <code>__objc_yes</code> and <code>__objc_no</code> to <code>(BOOL)1</code> and <code>(BOOL)0</code>. The keywords are used to disambiguate <code>BOOL</code> and integer literals.<p> 96 97 Objective-C++ also supports <code>@true</code> and <code>@false</code> expressions, which are equivalent to <code>@YES</code> and <code>@NO</code>. 98 99 <!-- ======================================================================= --> 100 <h2 id="objc_boxed_expressions">Boxed Expressions</h2> 101 <!-- ======================================================================= --> 102 103 <p>Objective-C provides a new syntax for boxing C expressions:</p> 104 105 <pre> 106 <code>@( <em>expression</em> )</code> 107 </pre> 108 109 <p>Expressions of scalar (numeric, enumerated, BOOL) and C string pointer types 110 are supported:</p> 111 112 <pre> 113 // numbers. 114 NSNumber *smallestInt = @(-INT_MAX - 1); 115 NSNumber *piOverTwo = @(M_PI / 2); 116 117 // enumerated types. 118 typedef enum { Red, Green, Blue } Color; 119 NSNumber *favoriteColor = @(Green); 120 121 // strings. 122 NSString *path = @(getenv("PATH")); 123 NSArray *pathComponents = [path componentsSeparatedByString:@":"]; 124 </pre> 125 126 <h3>Boxed Enums</h3> 127 128 <p> 129 Cocoa frameworks frequently define constant values using <em>enums.</em> Although enum values are integral, they may not be used directly as boxed literals (this avoids conflicts with future <code>'@'</code>-prefixed Objective-C keywords). Instead, an enum value must be placed inside a boxed expression. The following example demonstrates configuring an <code>AVAudioRecorder</code> using a dictionary that contains a boxed enumeration value: 130 </p> 131 132 <pre> 133 enum { 134 AVAudioQualityMin = 0, 135 AVAudioQualityLow = 0x20, 136 AVAudioQualityMedium = 0x40, 137 AVAudioQualityHigh = 0x60, 138 AVAudioQualityMax = 0x7F 139 }; 140 141 - (AVAudioRecorder *)recordToFile:(NSURL *)fileURL { 142 NSDictionary *settings = @{ AVEncoderAudioQualityKey : @(AVAudioQualityMax) }; 143 return [[AVAudioRecorder alloc] initWithURL:fileURL settings:settings error:NULL]; 144 } 145 </pre> 146 147 <p> 148 The expression <code>@(AVAudioQualityMax)</code> converts <code>AVAudioQualityMax</code> to an integer type, and boxes the value accordingly. If the enum has a <a href="http://clang.llvm.org/docs/LanguageExtensions.html#objc_fixed_enum">fixed underlying type</a> as in: 149 </p> 150 151 <pre> 152 typedef enum : unsigned char { Red, Green, Blue } Color; 153 NSNumber *red = @(Red), *green = @(Green), *blue = @(Blue); // => [NSNumber numberWithUnsignedChar:] 154 </pre> 155 156 <p> 157 then the fixed underlying type will be used to select the correct <code>NSNumber</code> creation method. 158 </p> 159 160 <h3>Boxed C Strings</h3> 161 162 <p> 163 A C string literal prefixed by the <code>'@'</code> token denotes an <code>NSString</code> literal in the same way a numeric literal prefixed by the <code>'@'</code> token denotes an <code>NSNumber</code> literal. When the type of the parenthesized expression is <code>(char *)</code> or <code>(const char *)</code>, the result of the boxed expression is a pointer to an <code>NSString</code> object containing equivalent character data. The following example converts C-style command line arguments into <code>NSString</code> objects. 164 </p> 165 166 <pre> 167 // Partition command line arguments into positional and option arguments. 168 NSMutableArray *args = [NSMutableArray new]; 169 NSMutableDictionary *options = [NSMutableArray new]; 170 while (--argc) { 171 const char *arg = *++argv; 172 if (strncmp(arg, "--", 2) == 0) { 173 options[@(arg + 2)] = @(*++argv); // --key value 174 } else { 175 [args addObject:@(arg)]; // positional argument 176 } 177 } 178 </pre> 179 180 <p> 181 As with all C pointers, character pointer expressions can involve arbitrary pointer arithmetic, therefore programmers must ensure that the character data is valid. Passing <code>NULL</code> as the character pointer will raise an exception at runtime. When possible, the compiler will reject <code>NULL</code> character pointers used in boxed expressions. 182 </p> 183 184 <h3>Availability</h3> 185 186 <p>This feature will be available after clang 3.1. It is not currently available in any Apple compiler.</p> 187 188 <h2>Container Literals</h2> 189 190 Objective-C now supports a new expression syntax for creating immutable array and dictionary container objects. 191 192 <h3>Examples</h3> 193 194 Immutable array expression:<p> 195 196 <blockquote> 197 <pre> 198 NSArray *array = @[ @"Hello", NSApp, [NSNumber numberWithInt:42] ]; 199 </pre> 200 </blockquote> 201 202 This creates an <code>NSArray</code> with 3 elements. The comma-separated sub-expressions of an array literal can be any Objective-C object pointer typed expression.<p> 203 204 Immutable dictionary expression:<p> 205 206 <pre> 207 NSDictionary *dictionary = @{ 208 @"name" : NSUserName(), 209 @"date" : [NSDate date], 210 @"processInfo" : [NSProcessInfo processInfo] 211 }; 212 </pre> 213 214 This creates an <code>NSDictionary</code> with 3 key/value pairs. Value sub-expressions of a dictionary literal must be Objective-C object pointer typed, as in array literals. Key sub-expressions must be of an Objective-C object pointer type that implements the <code><NSCopying></code> protocol.<p> 215 216 <h3>Discussion</h3> 217 218 Neither keys nor values can have the value <code>nil</code> in containers. If the compiler can prove that a key or value is <code>nil</code> at compile time, then a warning will be emitted. Otherwise, a runtime error will occur.<p> 219 220 Using array and dictionary literals is safer than the variadic creation forms commonly in use today. Array literal expressions expand to calls to <code>+[NSArray arrayWithObjects:count:]</code>, which validates that all objects are non-<code>nil</code>. The variadic form, <code>+[NSArray arrayWithObjects:]</code> uses <code>nil</code> as an argument list terminator, which can lead to malformed array objects. Dictionary literals are similarly created with <code>+[NSDictionary dictionaryWithObjects:forKeys:count:]</code> which validates all objects and keys, unlike <code>+[NSDictionary dictionaryWithObjectsAndKeys:]</code> which also uses a <code>nil</code> parameter as an argument list terminator.<p> 221 222 <h2>Object Subscripting</h2> 223 224 Objective-C object pointer values can now be used with C's subscripting operator.<p> 225 226 <h3>Examples</h3> 227 228 The following code demonstrates the use of object subscripting syntax with <code>NSMutableArray</code> and <code>NSMutableDictionary</code> objects:<p> 229 230 <pre> 231 NSMutableArray *array = ...; 232 NSUInteger idx = ...; 233 id newObject = ...; 234 id oldObject = array[idx]; 235 array[idx] = newObject; // replace oldObject with newObject 236 237 NSMutableDictionary *dictionary = ...; 238 NSString *key = ...; 239 oldObject = dictionary[key]; 240 dictionary[key] = newObject; // replace oldObject with newObject 241 </pre> 242 243 The next section explains how subscripting expressions map to accessor methods.<p> 244 245 <h3>Subscripting Methods</h3> 246 247 Objective-C supports two kinds of subscript expressions: <i>array-style</i> subscript expressions use integer typed subscripts; <i>dictionary-style</i> subscript expressions use Objective-C object pointer typed subscripts. Each type of subscript expression is mapped to a message send using a predefined selector. The advantage of this design is flexibility: class designers are free to introduce subscripting by declaring methods or by adopting protocols. Moreover, because the method names are selected by the type of the subscript, an object can be subscripted using both array and dictionary styles. 248 249 <h4>Array-Style Subscripting</h4> 250 251 When the subscript operand has an integral type, the expression is rewritten to use one of two different selectors, depending on whether the element is being read or written. When an expression reads an element using an integral index, as in the following example:<p> 252 253 <pre> 254 NSUInteger idx = ...; 255 id value = object[idx]; 256 </pre> 257 258 it is translated into a call to <code>objectAtIndexedSubscript:</code><p> 259 260 <pre> 261 id value = [object objectAtIndexedSubscript:idx]; 262 </pre> 263 264 When an expression writes an element using an integral index:<p> 265 266 <pre> 267 object[idx] = newValue; 268 </pre> 269 270 it is translated to a call to <code>setObject:atIndexedSubscript:</code><p> 271 272 <pre> 273 [object setObject:newValue atIndexedSubscript:idx]; 274 </pre> 275 276 These message sends are then type-checked and performed just like explicit message sends. The method used for objectAtIndexedSubscript: must be declared with an argument of integral type and a return value of some Objective-C object pointer type. The method used for setObject:atIndexedSubscript: must be declared with its first argument having some Objective-C pointer type and its second argument having integral type.<p> 277 278 The meaning of indexes is left up to the declaring class. The compiler will coerce the index to the appropriate argument type of the method it uses for type-checking. For an instance of <code>NSArray</code>, reading an element using an index outside the range <code>[0, array.count)</code> will raise an exception. For an instance of <code>NSMutableArray</code>, assigning to an element using an index within this range will replace that element, but assigning to an element using an index outside this range will raise an exception; no syntax is provided for inserting, appending, or removing elements for mutable arrays.<p> 279 280 A class need not declare both methods in order to take advantage of this language feature. For example, the class <code>NSArray</code> declares only <code>objectAtIndexedSubscript:</code>, so that assignments to elements will fail to type-check; moreover, its subclass <code>NSMutableArray</code> declares <code>setObject:atIndexedSubscript:</code>. 281 282 <h4>Dictionary-Style Subscripting</h4> 283 284 When the subscript operand has an Objective-C object pointer type, the expression is rewritten to use one of two different selectors, depending on whether the element is being read from or written to. When an expression reads an element using an Objective-C object pointer subscript operand, as in the following example:<p> 285 286 <pre> 287 id key = ...; 288 id value = object[key]; 289 </pre> 290 291 it is translated into a call to the <code>objectForKeyedSubscript:</code> method:<p> 292 293 <pre> 294 id value = [object objectForKeyedSubscript:key]; 295 </pre> 296 297 When an expression writes an element using an Objective-C object pointer subscript:<p> 298 299 <pre> 300 object[key] = newValue; 301 </pre> 302 303 it is translated to a call to <code>setObject:forKeyedSubscript:</code> 304 305 <pre> 306 [object setObject:newValue forKeyedSubscript:key]; 307 </pre> 308 309 The behavior of <code>setObject:forKeyedSubscript:</code> is class-specific; but in general it should replace an existing value if one is already associated with a key, otherwise it should add a new value for the key. No syntax is provided for removing elements from mutable dictionaries.<p> 310 311 <h3>Discussion</h3> 312 313 An Objective-C subscript expression occurs when the base operand of the C subscript operator has an Objective-C object pointer type. Since this potentially collides with pointer arithmetic on the value, these expressions are only supported under the modern Objective-C runtime, which categorically forbids such arithmetic.<p> 314 315 Currently, only subscripts of integral or Objective-C object pointer type are supported. In C++, a class type can be used if it has a single conversion function to an integral or Objective-C pointer type, in which case that conversion is applied and analysis continues as appropriate. Otherwise, the expression is ill-formed.<p> 316 317 An Objective-C object subscript expression is always an l-value. If the expression appears on the left-hand side of a simple assignment operator (=), the element is written as described below. If the expression appears on the left-hand side of a compound assignment operator (e.g. +=), the program is ill-formed, because the result of reading an element is always an Objective-C object pointer and no binary operators are legal on such pointers. If the expression appears in any other position, the element is read as described below. It is an error to take the address of a subscript expression, or (in C++) to bind a reference to it.<p> 318 319 Programs can use object subscripting with Objective-C object pointers of type <code>id</code>. Normal dynamic message send rules apply; the compiler must see <i>some</i> declaration of the subscripting methods, and will pick the declaration seen first.<p> 320 321 <h2>Grammar Additions</h2> 322 323 To support the new syntax described above, the Objective-C <code>@</code>-expression grammar has the following new productions:<p> 324 325 <pre> 326 objc-at-expression : '@' (string-literal | encode-literal | selector-literal | protocol-literal | object-literal) 327 ; 328 329 object-literal : ('+' | '-')? numeric-constant 330 | character-constant 331 | boolean-constant 332 | array-literal 333 | dictionary-literal 334 ; 335 336 boolean-constant : '__objc_yes' | '__objc_no' | 'true' | 'false' /* boolean keywords. */ 337 ; 338 339 array-literal : '[' assignment-expression-list ']' 340 ; 341 342 assignment-expression-list : assignment-expression (',' assignment-expression-list)? 343 | /* empty */ 344 ; 345 346 dictionary-literal : '{' key-value-list '}' 347 ; 348 349 key-value-list : key-value-pair (',' key-value-list)? 350 | /* empty */ 351 ; 352 353 key-value-pair : assignment-expression ':' assignment-expression 354 ; 355 </pre> 356 357 Note: <code>@true</code> and <code>@false</code> are only supported in Objective-C++.<p> 358 359 <h2>Availability Checks</h2> 360 361 Programs test for the new features by using clang's __has_feature checks. Here are examples of their use:<p> 362 363 <pre> 364 #if __has_feature(objc_array_literals) 365 // new way. 366 NSArray *elements = @[ @"H", @"He", @"O", @"C" ]; 367 #else 368 // old way (equivalent). 369 id objects[] = { @"H", @"He", @"O", @"C" }; 370 NSArray *elements = [NSArray arrayWithObjects:objects count:4]; 371 #endif 372 373 #if __has_feature(objc_dictionary_literals) 374 // new way. 375 NSDictionary *masses = @{ @"H" : @1.0078, @"He" : @4.0026, @"O" : @15.9990, @"C" : @12.0096 }; 376 #else 377 // old way (equivalent). 378 id keys[] = { @"H", @"He", @"O", @"C" }; 379 id values[] = { [NSNumber numberWithDouble:1.0078], [NSNumber numberWithDouble:4.0026], 380 [NSNumber numberWithDouble:15.9990], [NSNumber numberWithDouble:12.0096] }; 381 NSDictionary *masses = [NSDictionary dictionaryWithObjects:objects forKeys:keys count:4]; 382 #endif 383 384 #if __has_feature(objc_subscripting) 385 NSUInteger i, count = elements.count; 386 for (i = 0; i < count; ++i) { 387 NSString *element = elements[i]; 388 NSNumber *mass = masses[element]; 389 NSLog(@"the mass of %@ is %@", element, mass); 390 } 391 #else 392 NSUInteger i, count = [elements count]; 393 for (i = 0; i < count; ++i) { 394 NSString *element = [elements objectAtIndex:i]; 395 NSNumber *mass = [masses objectForKey:element]; 396 NSLog(@"the mass of %@ is %@", element, mass); 397 } 398 #endif 399 </pre> 400 401 Code can use also <code>__has_feature(objc_bool)</code> to check for the availability of numeric literals support. This checks for the new <code>__objc_yes / __objc_no</code> keywords, which enable the use of <code>@YES / @NO</code> literals.<p> 402 403 <p>To check whether boxed expressions are supported, use 404 <code>__has_feature(objc_boxed_expressions)</code> feature macro.</p> 405 406 </div> 407 </body> 408 </html> 409