39950 2010-05-31 04:52:12 -0700 Documentation on various assertion macros 2010-06-07 07:43:51 -0700 1 1 1 Unclassified WebKit WebKit Misc. 528+ (Nightly build) PC OS X 10.5 RESOLVED FIXED P2 Normal --- 1 playmobil playmobil commit-queue darin ggaren jorlow sam oldest_to_newest 232325 0 playmobil 2010-05-31 04:52:12 -0700 Per discussion in Bug 36527, it would be nice to have a page on the site detailing the various assertion macros and their use vs the crash macro. 232328 1 57455 playmobil 2010-05-31 05:11:43 -0700 Created attachment 57455 Documentation on assertion macros I tried to incorporate all the comments from the previous bug, hope I didn't miss anything. 232428 2 57455 darin 2010-05-31 09:52:19 -0700 Comment on attachment 57455 Documentation on assertion macros > + <li>ASSERT(expression) - if expression returns false then abort execution and break into the debugger. > + <li>ASSERT_UNREACHED() - For use when a certain branch of code should never be executed. > + <li>ASSERT_UNUSED(variable, expression) - In release builds this compiles down to > + <li>ASSERT_ARG(variable, expression - same as ASSERT() but this prints <span class="variable">variable</span> as a string as part of the assertion output. > + <li>ASSERT_WITH_MESSAGE(expression, ...) - Accepts a printf() style variable number of arguments after the expression which are printed out if the assertion fails. This is not a parallel construction. The description of ASSERT is a sentence that starts with a lowercase letter. The description of ASSERT_UNREACHED starts with "for use". The description of ASSER_UNUSED starts with "in release builds". The comments about each macro should use a parallel form so it's easy to understand. For ASSERT_UNUSED I would say something like: "For assertions that check the value of otherwise unused function arguments." This document does not make it clear when I should use ASSERT_ARG. For good reason. I don't know when we should use it instead of ASSERT. Maybe we should just not document it. > + THE CRASH() macro The word "THE" should not be capitalized here. > it's omission Typo: Should be "its omission". > + <li>The ideal is to recover from errors, possibly after ASSERT()ing if the condition might indicate a programming error. > + </li> I don't think this is quite right. I world use wording more like "When possible, the best design ..." or something like that. I'm not sure "The ideal is" will be understood by readers. I think the document even it its current form will do more good than harm, so I am tempted to say review+ I also noticed that some of the code does not match our coding style. Specifically the space after the "}" and before the ";" in the enum. Also, the code example shows a switch statement with a default case, which is something we normally don't do because we want the GCC compiler to catch missing enum cases. 232488 3 57488 playmobil 2010-05-31 12:00:41 -0700 Created attachment 57488 Documentation on assertion macros Thanks Darin, hopefully all comments addressed. I've gone with a simpler code example which hopefully illustrates the same point, let me know if you think there's one that would work better. 234657 4 playmobil 2010-06-06 06:17:51 -0700 Ping? Does the new patch look ok to everyone? 234681 5 57488 darin 2010-06-06 12:59:00 -0700 Comment on attachment 57488 Documentation on assertion macros Another round of comments: WebKitSite/coding/assertion-guidelines.html:35 + The ASSERT() macro and it's variants are compiled out of release builds. They are meant for use during the development process to catch programming mistakes. For those macros that accept an expression as an argument, the expression is also compiled out of release builds and thus incurs no overhead in shipping code. The "it's" here should be "its". WebKitSite/coding/assertion-guidelines.html:38 + <li>ASSERT(expression) - for use as a predicate that a condition defined by expression should not occur. If expression evaluates to false then abort execution and break into the debugger. The grammar here is nonstandard. I don't think "a predicate that a condition should not occur" is correct grammar, and I'm confused by the use of both predicate and condition, which mean almost the same thing, to mean different things here. It's the expression that is a predicate, not the ASSERT macro so the macro is not for use "as a predicate". I suggest saying "If the expression" rather than "If expression". WebKitSite/coding/assertion-guidelines.html:50 + <li>ASSERT_UNUSED(variable, expression) - for assertions that check the value of otherwise unused function arguments. "check the value of an otherwise unused variable", not function WebKitSite/coding/assertion-guidelines.html:54 + (void)variable I think the use of (void) to silence the unused variable warning is an implementation detail that should be left out of the documentation. WebKitSite/coding/assertion-guidelines.html:64 + ASSERT_UNUSED(exec, exec-&gt;hadException() &amp;&amp; exec-&gt;exception() == m_exception); It's considered bad style to use && in an assertion. We normally split such assertions in two, so you can see which half failed. WebKitSite/coding/assertion-guidelines.html:69 + <li>ASSERT_WITH_MESSAGE(expression, ...) - for use when you want to print extra information in the case of a failed assertion. Accepts a printf() style variable number of arguments after the expression which are printed out if the assertion fails. I'm not sure we should document ASSERT_WITH_MESSAGE. It's rarely used and we might want to phase it out. WebKitSite/coding/assertion-guidelines.html:82 + CRASH() raises a fatal error resulting in program termination and triggering either the debugger or the crash reporter. It is active in both debug &amp; release mode. CRASH() has a direct effect on end users and can be used in the field to gather information. I think "used in the field" is unclear here. We use it in the source code, although its effect is felt "in the field". Please find a clearer way to word this. WebKitSite/coding/assertion-guidelines.html:85 + Considerations when using ASSERT*() and CRASH() macros. I think the use of ASSERT* to refer to the family of assertion macros is inelegant. Maybe something more like "the ASSERT family of macros" would be better? Not sure. WebKitSite/coding/assertion-guidelines.html:91 + The expression inside the ASSERT(expression) macro is compiled out of release builds together with the macro itself. If the expression that's used has side effects, its omission in release build can lead to programming errors that don't manifest in debug builds. I suggest calling this the ASSERT macro, rather than the ASSERT(expression) macro. "inside the ASSERT or ASSERT_UNUSED macro". WebKitSite/coding/assertion-guidelines.html:94 + The benefits of a CRASH(): "The benefits of using CRASH:" WebKitSite/coding/assertion-guidelines.html:106 + <li>Turns an internal programming error into a crash. Blows away at least a tab, and in some cases the entire web browser, in cases that otherwise might be harmless. This is not grammatically consistent with the other list items. I think you should instead say "Use of the CRASH macro turns a programming error into a crash, blowing away a webpage or an entire web browser in cases that otherwise might be harmless." WebKitSite/coding/assertion-guidelines.html:108 + <li>The cost of evaluating the expression that determines whether the error condition has occurred is incurred in release builds rather than being compiled out like it is with the ASSERT() macro. The cost is not compiled out. The expression is compiled out. Please reword. I also think this does not state the cost clearly enough. Something like, "Checking for the error condition may slow the program down." WebKitSite/coding/assertion-guidelines.html:115 + <li>Use ASSERT() for things that should never happen, but if they do will cause incorrect results, not a crash or memory corruption. I would say "incorrect results rather than". WebKitSite/coding/assertion-guidelines.html:117 + <li>Use CRASH() for cases that shouldn't happen, but if they do would be unrecoverable. e.g. OOM errors. I suggest "out of memory" instead of "OOM". WebKitSite/coding/assertion-guidelines.html:119 + <li>When possible, the best design is to recover from errors, possibly after ASSERT()ing if the condition might indicate a programming error. I would say the "best practice is to include code that can recover from errors", but I am not sure this is the best practice. We don't always want code to recover from errors after ASSERT. Doing this everywhere would add many unneeded and untested code paths. This comment oversimplifies and does not make it clear what the best practice really is. We should rethink this point and figure out what to say. The WebKitSite/coding/assertion-guidelines.html:129 + Object* b = new Object; This example is wrong, because our operator new will never return a 0 because of memory exhaustion; new automatically calls CRASH for you. We need an example with a function that actually does return 0. Maybe tryFastMalloc or something else like that. 234739 6 58000 playmobil 2010-06-07 01:36:57 -0700 Created attachment 58000 Documentation on assertion macros Thanks Darin, all fixed. If you think I should rephrase other parts I'd be grateful for suggestions. 234837 7 58000 darin 2010-06-07 07:23:16 -0700 Comment on attachment 58000 Documentation on assertion macros I think there's one significant type of guideline missing here: Assertions should only be used for conditions that the programmer knows won't occur. We should never assert, for example, that a file system call has succeeded, because there is no way for a programmer to guarantee that. Assertions are claims that a programmer knows to be true, and they fire only when that programmer turns out to be wrong because there is some kind of programming mistake. There should be no "wishful thinking" assertions. The phrase "other bad behavior deserving attention" fuzzes this issue a bit. There are many types of bad behavior where an assertion is not an acceptable way to check. The section that talks about "recover from non-fatal errors" is also now vague enough that I think it's not as useful as it once was. I'd prefer that the examples include the best programming style as possible. I'm not all that fond of the idea of naming a local variable "mem" in the example. I think it's OK to land this now, and I think there is room for improvement too. 234847 8 58000 commit-queue 2010-06-07 07:43:44 -0700 Comment on attachment 58000 Documentation on assertion macros Clearing flags on attachment: 58000 Committed r60783: <http://trac.webkit.org/changeset/60783> 234848 9 commit-queue 2010-06-07 07:43:51 -0700 All reviewed patches have been landed. Closing bug. 57455 2010-05-31 05:11:43 -0700 2010-05-31 12:00:41 -0700 Documentation on assertion macros assert_docs.patch text/plain 7249 playmobil Y29tbWl0IDlkZjc2YjgwYWM4ZDExNzg3N2FmY2U4ZDUzYmZjZWIyMzAzM2FiNDQKQXV0aG9yOiBK ZXJlbXkgTW9za292aWNoIDxqZXJlbXlAY2hyb21pdW0ub3JnPgpEYXRlOiAgIE1vbiBNYXkgMzEg MTQ6NTc6MzEgMjAxMCArMDMwMAoKICAgIEFkZCBkb2N1bWVudGF0aW9uIG9uIHRoZSB2YXJpb3Vz IGFzc2VydGlvbiBtYWNyb3MgaW4gV2ViS2l0LgogICAgCiAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk5NTAKCmRpZmYgLS1naXQgYS9XZWJLaXRTaXRlL0NoYW5n ZUxvZyBiL1dlYktpdFNpdGUvQ2hhbmdlTG9nCmluZGV4IGI4ZDZmM2MuLjY0NGExOWUgMTAwNjQ0 Ci0tLSBhL1dlYktpdFNpdGUvQ2hhbmdlTG9nCisrKyBiL1dlYktpdFNpdGUvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTMgQEAKKzIwMTAtMDUtMzEgIEplcmVteSBNb3Nrb3ZpY2ggIDxqZXJlbXlAY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEFkZCBkb2N1bWVudGF0aW9uIG9uIHRoZSB2YXJpb3VzIGFzc2VydGlvbiBtYWNyb3MgaW4g V2ViS2l0LgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0zOTk1MAorCisgICAgICAgICogY29kaW5nL2Fzc2VydGlvbi1ndWlkZWxpbmVzLmh0bWw6IEFk ZGVkLgorCiAyMDEwLTA1LTI5ICBTdGVybGluZyBTd2lnYXJ0ICA8c3N3aWdhcnRAZ29vZ2xlLmNv bT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXZpZCBMZXZpbi4KZGlmZiAtLWdpdCBhL1dlYktp dFNpdGUvY29kaW5nL2Fzc2VydGlvbi1ndWlkZWxpbmVzLmh0bWwgYi9XZWJLaXRTaXRlL2NvZGlu Zy9hc3NlcnRpb24tZ3VpZGVsaW5lcy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLmMyZWZlYjAKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXRTaXRlL2NvZGluZy9hc3Nl cnRpb24tZ3VpZGVsaW5lcy5odG1sCkBAIC0wLDAgKzEsMTYwIEBACis8P3BocCAKKyAgICAkdGl0 bGU9IkEgZ3VpZGUgdG8gQXNzZXJ0aW9ucyBtYWNyb3MgaW4gV2ViS2l0IjsKKyAgICBpbmNsdWRl KCIuLi9oZWFkZXIuaW5jIik7IAorPz4KKworPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgICAu Y29kZSB7CisgICAgICAgIGJhY2tncm91bmQtY29sb3I6ICNlZWU7CisgICAgICAgIHBhZGRpbmc6 IDFlbTsKKyAgICAgICAgbWFyZ2luLWxlZnQ6IDJlbTsKKyAgICAgICAgbWFyZ2luLXJpZ2h0OiAy ZW07CisgICAgICAgIG92ZXJmbG93LXg6IGF1dG87CisgICAgfQorICAgIC5jb21tZW50IC5mdW5j dGlvbiwgLmNsYXNzLCAudmFyaWFibGUgeworICAgICAgICBmb250LXN0eWxlOiBpdGFsaWM7Cisg ICAgfQorPC9zdHlsZT4KKworPGgxPgorICBBIGd1aWRlIHRvIEFzc2VydGlvbnMgbWFjcm9zIGlu IFdlYktpdAorPC9oMT4KKzxkaXY+CisgIFZlcnNpb24gMSwgMjAxMC01LTI0Cis8L2Rpdj4KKzxo Mj4KKyAgQmFja2dyb3VuZAorPC9oMj4KKzxwPgorICBXZWJLaXQgcHJvdmlkZXMgYSBudW1iZXIg b2YgbWFjcm9zIHRvIGFzc2VydCB0aGF0IGNvbmRpdGlvbnMgaW4gdGhlIGNvZGUgYXJlIG1ldC4g VGhleSBhcmUgZGVmaW5lZCBpbiA8YSBocmVmPSJodHRwOi8vdHJhYy53ZWJraXQub3JnL2Jyb3dz ZXIvdHJ1bmsvSmF2YVNjcmlwdENvcmUvd3RmL0Fzc2VydGlvbnMuaCI+SmF2YVNjcmlwdENvcmUv d3RmL0Fzc2VydGlvbnMuaDwvYT4uIFRoaXMgZG9jdW1lbnQgcHJvdmlkZXMgYW4gb3ZlcnZpZXcg b2YgdGhlIHZhcmlvdXMgbWFjcm9zLCBpbmNsdWRpbmcgZ3VpZGVsaW5lcyBhbmQgYmVzdCBwcmFj dGljZXMgZm9yIHRoZWlyIHVzZS4KKzwvcD4KKzxoMj4KKyAgVHlwZXMgb2YgQVNTRVJUIG1hY3Jv cworPC9oMj4KKzxwPgorICBUaGUgQVNTRVJUKCkgbWFjcm8gYW5kIGl0J3MgdmFyaWFudHMgYXJl IGNvbXBpbGVkIG91dCBvZiByZWxlYXNlIGJ1aWxkcy4gVGhleSBhcmUgbWVhbnQgZm9yIHVzZSBk dXJpbmcgdGhlIGRldmVsb3BtZW50IHByb2Nlc3MgdG8gY2F0Y2ggcHJvZ3JhbW1pbmcgbWlzdGFr ZXMuIEZvciB0aG9zZSBtYWNyb3MgdGhhdCBhY2NlcHQgYW4gZXhwcmVzc2lvbiBhcyBhbiBhcmd1 bWVudCwgdGhlIGV4cHJlc3Npb24gaXMgYWxzbyBjb21waWxlZCBvdXQgb2YgcmVsZWFzZSBidWls ZHMgYW5kIHRodXMgaW5jdXJzIG5vIG92ZXJoZWFkIGluIHNoaXBwaW5nIGNvZGUuCis8L3A+Cis8 dWw+CisgIDxsaT5BU1NFUlQoZXhwcmVzc2lvbikgLSBpZiBleHByZXNzaW9uIHJldHVybnMgZmFs c2UgdGhlbiBhYm9ydCBleGVjdXRpb24gYW5kIGJyZWFrIGludG8gdGhlIGRlYnVnZ2VyLgorICA8 L2xpPgorICA8bGk+QVNTRVJUX1VOUkVBQ0hFRCgpIC0gRm9yIHVzZSB3aGVuIGEgY2VydGFpbiBi cmFuY2ggb2YgY29kZSBzaG91bGQgbmV2ZXIgYmUgZXhlY3V0ZWQuCisgICAgPHByZSBjbGFzcz0i Y29kZSI+CitpZiAoY29uZGl0aW9uKSB7CisgIC4uLgorfSBlbHNlIHsKKyAgICA8c3BhbiBjbGFz cz0iY29tbWVudCI+Ly8gVGhpcyBzaG91bGQgbmV2ZXIgaGFwcGVuLjwvc3Bhbj4KKyAgICBBU1NF UlRfVU5SRUFDSEVEKCk7Cit9Cis8L3ByZT4KKyAgPC9saT4KKyAgPGxpPkFTU0VSVF9VTlVTRUQo dmFyaWFibGUsIGV4cHJlc3Npb24pIC0gSW4gcmVsZWFzZSBidWlsZHMgdGhpcyBjb21waWxlcyBk b3duIHRvCisgICAgPHByZSBjbGFzcz0iY29kZSI+Cisodm9pZCl2YXJpYWJsZQorPC9wcmU+QW5k IGluIGRlYnVnIGJ1aWxkcyBpdCBpcyBpbnRlcnByZXRlZCBhcworICAgIDxwcmUgY2xhc3M9ImNv ZGUiPgorQVNTRVJUKGV4cHJlc3Npb24pCis8L3ByZT5UaGUgbmVlZCBmb3IgdGhpcyBiZWNvbWVz IGFwcGFyZW50IGlmIHlvdSBjb25zaWRlciB0aGUgY2FzZSB3aGVyZSB5b3Ugd2FudCB0byBhc3Nl cnQgYW4gZXhwcmVzc2lvbiB0aGF0IHVzZXMgYSB2YXJpYWJsZSB0aGF0IHdvdWxkbid0IG90aGVy d2lzZSBiZSB1c2VkIGluIHRoZSBlbmNsb3NpbmcgZnVuY3Rpb24uIEFTU0VSVCgpIGNhbid0IGJl IHVzZWQgaW4gdGhpcyBjYXNlIGJlY2F1c2UgaW4gYSByZWxlYXNlIGJ1aWxkIHRoZSBjb21waWxl ciB3b3VsZCB3YXJuIGFib3V0IHRoZSB1bnVzZWQgdmFyaWFibGUuIEFTU0VSVF9VTlVTRUQoKSBh dm9pZHMgdGhpcyB3YXJuaW5nLiBFeGFtcGxlIGZyb20gPGEgaHJlZj0iaHR0cDovL3RyYWMud2Vi a2l0Lm9yZy9icm93c2VyL3RydW5rL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNOb3RBbk9iamVj dC5jcHAiPkphdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNOb3RBbk9iamVjdC5jcHA8L2E+IDoKKyAg ICA8cHJlIGNsYXNzPSJjb2RlIj4KK0pTVmFsdWUgSlNOb3RBbk9iamVjdDo6dG9QcmltaXRpdmUo RXhlY1N0YXRlKiBleGVjLCBQcmVmZXJyZWRQcmltaXRpdmVUeXBlKSBjb25zdAoreworICAgIDxz cGFuIGNsYXNzPSJjb21tZW50Ij4vLyBleGVjIG5vdCB1c2VkIG91dHNpZGUgdGhlIEFTU0VSVCgp Ljwvc3Bhbj4KKyAgICBBU1NFUlRfVU5VU0VEKGV4ZWMsIGV4ZWMtJmd0O2hhZEV4Y2VwdGlvbigp ICZhbXA7JmFtcDsgZXhlYy0mZ3Q7ZXhjZXB0aW9uKCkgPT0gbV9leGNlcHRpb24pOworICAgIHJl dHVybiBtX2V4Y2VwdGlvbjsKK30KKzwvcHJlPgorICA8L2xpPgorICA8bGk+QVNTRVJUX0FSRyh2 YXJpYWJsZSwgZXhwcmVzc2lvbiAtIHNhbWUgYXMgQVNTRVJUKCkgYnV0IHRoaXMgcHJpbnRzIDxz cGFuIGNsYXNzPSJ2YXJpYWJsZSI+dmFyaWFibGU8L3NwYW4+IGFzIGEgc3RyaW5nIGFzIHBhcnQg b2YgdGhlIGFzc2VydGlvbiBvdXRwdXQuCisgICAgPHA+CisgICAgICBFeGFtcGxlIGZyb20gPGEg aHJlZj0iaHR0cDovL3RyYWMud2Via2l0Lm9yZy9icm93c2VyL3RydW5rL0phdmFTY3JpcHRDb3Jl L3Byb2ZpbGVyL1Byb2ZpbGVyLmNwcCI+SmF2YVNjcmlwdENvcmUvcHJvZmlsZXIvUHJvZmlsZXIu Y3BwPC9hPiA6CisgICAgPC9wPgorICAgIDxwcmUgY2xhc3M9ImNvZGUiPgordm9pZCBQcm9maWxl cjo6c3RhcnRQcm9maWxpbmcoRXhlY1N0YXRlKiBleGVjLCBjb25zdCBVU3RyaW5nJmFtcDsgdGl0 bGUpCit7CisgICAgQVNTRVJUX0FSRyh0aXRsZSwgIXRpdGxlLmlzTnVsbCgpKTsKKyAgICAuLi4K K30KKzwvcHJlPgorICA8L2xpPgorICA8bGk+QVNTRVJUX1dJVEhfTUVTU0FHRShleHByZXNzaW9u LCAuLi4pIC0gQWNjZXB0cyBhIHByaW50ZigpIHN0eWxlIHZhcmlhYmxlIG51bWJlciBvZiBhcmd1 bWVudHMgYWZ0ZXIgdGhlIGV4cHJlc3Npb24gd2hpY2ggYXJlIHByaW50ZWQgb3V0IGlmIHRoZSBh c3NlcnRpb24gZmFpbHMuCisgICAgPHA+CisgICAgICBFeGFtcGxlIGZyb20gPGEgaHJlZj0iaHR0 cDovL3RyYWMud2Via2l0Lm9yZy9icm93c2VyL3RydW5rL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUv VGltZW91dENoZWNrZXIuY3BwIj5KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1RpbWVvdXRDaGVja2Vy LmNwcDwvYT4KKyAgICA8L3A+CisgICAgPHByZSBjbGFzcz0iY29kZSI+CitBU1NFUlRfV0lUSF9N RVNTQUdFKGVyciA9PSBLRXJyTm9uZSwgIkdldENwdVRpbWUgZmFpbGVkIHdpdGggJWQiLCBlcnIp OworPC9wcmU+CisgIDwvbGk+Cis8L3VsPgorPGgyPgorICBUSEUgQ1JBU0goKSBtYWNybworPC9o Mj4KKzxwPgorICBDUkFTSCgpIHJhaXNlcyBhIGZhdGFsIGVycm9yIHJlc3VsdGluZyBpbiBwcm9n cmFtIHRlcm1pbmF0aW9uIGFuZCB0cmlnZ2VyaW5nIGVpdGhlciB0aGUgZGVidWdnZXIgb3IgdGhl IGNyYXNoIHJlcG9ydGVyLiBJdCBpcyBhY3RpdmUgaW4gYm90aCBkZWJ1ZyAmYW1wOyByZWxlYXNl IG1vZGUuIENSQVNIKCkgaGFzIGEgZGlyZWN0IGVmZmVjdCBvbiBlbmQgdXNlcnMgYW5kIGNhbiBi ZSB1c2VkIGluIHRoZSBmaWVsZCB0byBnYXRoZXIgaW5mb3JtYXRpb24uCis8L3A+Cis8aDI+Cisg IENvbnNpZGVyYXRpb25zIHdoZW4gdXNpbmcgQVNTRVJUKigpIGFuZCBDUkFTSCgpIG1hY3Jvcy4K KzwvaDI+Cis8aDM+CisgIEhhemFyZHMgb2YgdXNpbmcgQVNTRVJUKigpIG1hY3JvcworPC9oMz4K KzxwPgorICBUaGUgZXhwcmVzc2lvbiBpbnNpZGUgdGhlIEFTU0VSVChleHByZXNzaW9uKSBtYWNy byBpcyBjb21waWxlZCBvdXQgb2YgcmVsZWFzZSBidWlsZHMgdG9nZXRoZXIgd2l0aCB0aGUgbWFj cm8gaXRzZWxmLiBJZiB0aGUgZXhwcmVzc2lvbiB0aGF0J3MgdXNlZCBoYXMgc2lkZSBlZmZlY3Rz LCBpdCdzIG9taXNzaW9uIGluIHJlbGVhc2UgYnVpbGQgY2FuIGxlYWQgdG8gcHJvZ3JhbW1pbmcg ZXJyb3JzIHRoYXQgZG9uJ3QgbWFuaWZlc3QgaW4gZGVidWcgYnVpbGRzLgorPC9wPgorPGgzPgor ICBUaGUgYmVuZWZpdHMgb2YgYSBDUkFTSCgpOgorPC9oMz4KKzx1bD4KKyAgPGxpPklmIGEgYnJv d3NlciB2ZW5kb3IgdHJhY2VzIGNyYXNoZXMgaW4gdGhlaXIgc29mdHdhcmUsIENSQVNIKCkgY2Fu IHByb3ZpZGUgdml0YWwgaW5mb3JtYXRpb24gZnJvbSB0aGUgZmllbGQgdG8gYWxsb3cgYW4gaXNz dWUgdG8gYmUgcmVzb2x2ZWQuCisgIDwvbGk+CisgIDxsaT5Db2RlIGFmdGVyIENSQVNIKCkgaXMg Z3VhcmFudGVlZCB1bnJlYWNoYWJsZSwgd2hpY2ggY2FuIGhlbHAgcHJldmVudCBzb21lIGJ1Z3Mg ZnJvbSBiZWluZyBzZWN1cml0eSBsaWFiaWxpdGllcy4KKyAgPC9saT4KKzwvdWw+Cis8aDM+Cisg IFRoZSBjb3N0IG9mIHVzaW5nIENSQVNIOgorPC9oMz4KKzx1bD4KKyAgPGxpPlR1cm5zIGFuIGlu dGVybmFsIHByb2dyYW1taW5nIGVycm9yIGludG8gYSBjcmFzaC4gQmxvd3MgYXdheSBhdCBsZWFz dCBhIHRhYiwgYW5kIGluIHNvbWUgY2FzZXMgdGhlIGVudGlyZSB3ZWIgYnJvd3NlciwgaW4gY2Fz ZXMgdGhhdCBvdGhlcndpc2UgbWlnaHQgYmUgaGFybWxlc3MuCisgIDwvbGk+CisgIDxsaT5UaGUg Y29zdCBvZiBldmFsdWF0aW5nIHRoZSBleHByZXNzaW9uIHRoYXQgZGV0ZXJtaW5lcyB3aGV0aGVy IHRoZSBlcnJvciBjb25kaXRpb24gaGFzIG9jY3VycmVkIGlzIGluY3VycmVkIGluIHJlbGVhc2Ug YnVpbGRzIHJhdGhlciB0aGFuIGJlaW5nIGNvbXBpbGVkIG91dCBsaWtlIGl0IGlzIHdpdGggdGhl IEFTU0VSVCgpIG1hY3JvLgorICA8L2xpPgorPC91bD4KKzxoMj4KKyAgR3VpZGVsaW5lcyBmb3Ig dXNpbmcgQVNTRVJUKigpIGFuZCBDUkFTSCgpIG1hY3Jvcy4KKzwvaDI+Cis8dWw+CisgIDxsaT5V c2UgQVNTRVJUKCkgZm9yIHRoaW5ncyB0aGF0IHNob3VsZCBuZXZlciBoYXBwZW4sIGJ1dCBpZiB0 aGV5IGRvIHdpbGwgY2F1c2UgaW5jb3JyZWN0IHJlc3VsdHMsIG5vdCBhIGNyYXNoIG9yIG1lbW9y eSBjb3JydXB0aW9uLgorICA8L2xpPgorICA8bGk+VXNlIENSQVNIKCkgZm9yIGNhc2VzIHRoYXQg c2hvdWxkbid0IGhhcHBlbiwgYnV0IGlmIHRoZXkgZG8gd291bGQgYmUgdW5yZWNvdmVyYWJsZS4g ZS5nLiBPT00gZXJyb3JzLgorICA8L2xpPgorICA8bGk+VGhlIGlkZWFsIGlzIHRvIHJlY292ZXIg ZnJvbSBlcnJvcnMsIHBvc3NpYmx5IGFmdGVyIEFTU0VSVCgpaW5nIGlmIHRoZSBjb25kaXRpb24g bWlnaHQgaW5kaWNhdGUgYSBwcm9ncmFtbWluZyBlcnJvci4KKyAgPC9saT4KKzwvdWw+Cis8aDM+ CisgIEV4YW1wbGVzIG9mIHVzaW5nIENSQVNIKCkgdnMgQVNTRVJUKCkKKzwvaDM+Cis8cHJlIGNs YXNzPSJjb2RlIj4KK2VudW0gVHlwZSB7IEVudW1JdGVtIH0gOworCitUeXBlIGE7Citzd2l0Y2gg KGEpIHsKK2Nhc2UgRW51bUl0ZW06CisgICAgPHNwYW4gY2xhc3M9ImNvbW1lbnQiPi8vIERvIHNv bWV0aGluZy48L3NwYW4+CisgICAgYnJlYWs7CitkZWZhdWx0OgorICAgIDxzcGFuIGNsYXNzPSJj b21tZW50Ij4vLyBJZiB3ZSBnZXQgaGVyZSwgdGhhdCB3b3VsZCBpbmRpY2F0ZSBhIHByb2dyYW1t aW5nIGVycm9yLjwvc3Bhbj4KKyAgICBBU1NFUlRfVU5SRUFDSEVEKCk7CisgICAgYnJlYWs7Cit9 CisKK09iamVjdCogYiA9IG5ldyBPYmplY3Q7CitpZiAoIWIpIHsKKyAgICAvLyBOb3QgcG9zc2li bGUgdG8gcmVjb3ZlciBmcm9tIGFuIE9PTSBlcnJvci4KKyAgICBDUkFTSCgpOworfQorPC9wcmU+ Cis8cD4KKyAgSWYgeW91IGhhdmUgYW55IGNvbW1lbnRzIG9uIHRoZSBhYm92ZSBvciBvdGhlciBp ZGVhcyBhYm91dCBpbXByb3ZpbmcgdGhlIGNsYXJpdHksIHNjb3BlLCBvciBwcmVzZW50YXRpb24s IHBsZWFzZSBzZW5kIG1haWwgdG8gdGhlIDxhIGhyZWY9Ii9jb250YWN0Lmh0bWwiPldlYktpdCBt YWlsaW5nIGxpc3Q8L2E+LgorPC9wPgorCis8P3BocAorICAgIGluY2x1ZGUoIi4uL2Zvb3Rlci5p bmMiKTsKKz8+Cg== 57488 2010-05-31 12:00:41 -0700 2010-06-07 01:36:57 -0700 Documentation on assertion macros assert_docs.patch text/plain 6889 playmobil Y29tbWl0IGU1MDJhZTlmZjk3MGM2NDc1OTViODFjZDlmNzYyNjMzOTc5NTZkY2UKQXV0aG9yOiBK ZXJlbXkgTW9za292aWNoIDxqZXJlbXlAY2hyb21pdW0ub3JnPgpEYXRlOiAgIE1vbiBNYXkgMzEg MTQ6NTc6MzEgMjAxMCArMDMwMAoKICAgIEFkZCBkb2N1bWVudGF0aW9uIG9uIHRoZSB2YXJpb3Vz IGFzc2VydGlvbiBtYWNyb3MgaW4gV2ViS2l0LgogICAgCiAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk5NTAKCmRpZmYgLS1naXQgYS9XZWJLaXRTaXRlL0NoYW5n ZUxvZyBiL1dlYktpdFNpdGUvQ2hhbmdlTG9nCmluZGV4IGI4ZDZmM2MuLjY0NGExOWUgMTAwNjQ0 Ci0tLSBhL1dlYktpdFNpdGUvQ2hhbmdlTG9nCisrKyBiL1dlYktpdFNpdGUvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTMgQEAKKzIwMTAtMDUtMzEgIEplcmVteSBNb3Nrb3ZpY2ggIDxqZXJlbXlAY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEFkZCBkb2N1bWVudGF0aW9uIG9uIHRoZSB2YXJpb3VzIGFzc2VydGlvbiBtYWNyb3MgaW4g V2ViS2l0LgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0zOTk1MAorCisgICAgICAgICogY29kaW5nL2Fzc2VydGlvbi1ndWlkZWxpbmVzLmh0bWw6IEFk ZGVkLgorCiAyMDEwLTA1LTI5ICBTdGVybGluZyBTd2lnYXJ0ICA8c3N3aWdhcnRAZ29vZ2xlLmNv bT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXZpZCBMZXZpbi4KZGlmZiAtLWdpdCBhL1dlYktp dFNpdGUvY29kaW5nL2Fzc2VydGlvbi1ndWlkZWxpbmVzLmh0bWwgYi9XZWJLaXRTaXRlL2NvZGlu Zy9hc3NlcnRpb24tZ3VpZGVsaW5lcy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLmU1NmY5ZTgKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXRTaXRlL2NvZGluZy9hc3Nl cnRpb24tZ3VpZGVsaW5lcy5odG1sCkBAIC0wLDAgKzEsMTQxIEBACis8P3BocCAKKyAgICAkdGl0 bGU9IkEgZ3VpZGUgdG8gQXNzZXJ0aW9ucyBtYWNyb3MgaW4gV2ViS2l0IjsKKyAgICBpbmNsdWRl KCIuLi9oZWFkZXIuaW5jIik7IAorPz4KKworPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgICAu Y29kZSB7CisgICAgICAgIGJhY2tncm91bmQtY29sb3I6ICNlZWU7CisgICAgICAgIHBhZGRpbmc6 IDFlbTsKKyAgICAgICAgbWFyZ2luLWxlZnQ6IDJlbTsKKyAgICAgICAgbWFyZ2luLXJpZ2h0OiAy ZW07CisgICAgICAgIG92ZXJmbG93LXg6IGF1dG87CisgICAgfQorICAgIC5jb21tZW50IC5mdW5j dGlvbiwgLmNsYXNzLCAudmFyaWFibGUgeworICAgICAgICBmb250LXN0eWxlOiBpdGFsaWM7Cisg ICAgfQorPC9zdHlsZT4KKworPGgxPgorICBBIGd1aWRlIHRvIEFzc2VydGlvbnMgbWFjcm9zIGlu IFdlYktpdAorPC9oMT4KKzxkaXY+CisgIFZlcnNpb24gMSwgMjAxMC01LTI0Cis8L2Rpdj4KKzxo Mj4KKyAgQmFja2dyb3VuZAorPC9oMj4KKzxwPgorICBXZWJLaXQgcHJvdmlkZXMgYSBudW1iZXIg b2YgbWFjcm9zIHRvIGFzc2VydCB0aGF0IGNvbmRpdGlvbnMgaW4gdGhlIGNvZGUgYXJlIG1ldC4g VGhleSBhcmUgZGVmaW5lZCBpbiA8YSBocmVmPSJodHRwOi8vdHJhYy53ZWJraXQub3JnL2Jyb3dz ZXIvdHJ1bmsvSmF2YVNjcmlwdENvcmUvd3RmL0Fzc2VydGlvbnMuaCI+SmF2YVNjcmlwdENvcmUv d3RmL0Fzc2VydGlvbnMuaDwvYT4uIFRoaXMgZG9jdW1lbnQgcHJvdmlkZXMgYW4gb3ZlcnZpZXcg b2YgdGhlIHZhcmlvdXMgbWFjcm9zLCBpbmNsdWRpbmcgZ3VpZGVsaW5lcyBhbmQgYmVzdCBwcmFj dGljZXMgZm9yIHRoZWlyIHVzZS4KKzwvcD4KKzxoMj4KKyAgVHlwZXMgb2YgQVNTRVJUIG1hY3Jv cworPC9oMj4KKzxwPgorICBUaGUgQVNTRVJUKCkgbWFjcm8gYW5kIGl0J3MgdmFyaWFudHMgYXJl IGNvbXBpbGVkIG91dCBvZiByZWxlYXNlIGJ1aWxkcy4gVGhleSBhcmUgbWVhbnQgZm9yIHVzZSBk dXJpbmcgdGhlIGRldmVsb3BtZW50IHByb2Nlc3MgdG8gY2F0Y2ggcHJvZ3JhbW1pbmcgbWlzdGFr ZXMuIEZvciB0aG9zZSBtYWNyb3MgdGhhdCBhY2NlcHQgYW4gZXhwcmVzc2lvbiBhcyBhbiBhcmd1 bWVudCwgdGhlIGV4cHJlc3Npb24gaXMgYWxzbyBjb21waWxlZCBvdXQgb2YgcmVsZWFzZSBidWls ZHMgYW5kIHRodXMgaW5jdXJzIG5vIG92ZXJoZWFkIGluIHNoaXBwaW5nIGNvZGUuCis8L3A+Cis8 dWw+CisgIDxsaT5BU1NFUlQoZXhwcmVzc2lvbikgLSBmb3IgdXNlIGFzIGEgcHJlZGljYXRlIHRo YXQgYSBjb25kaXRpb24gZGVmaW5lZCBieSBleHByZXNzaW9uIHNob3VsZCBub3Qgb2NjdXIuIElm IGV4cHJlc3Npb24gZXZhbHVhdGVzIHRvIGZhbHNlIHRoZW4gYWJvcnQgZXhlY3V0aW9uIGFuZCBi cmVhayBpbnRvIHRoZSBkZWJ1Z2dlci4KKyAgPC9saT4KKyAgPGxpPkFTU0VSVF9VTlJFQUNIRUQo KSAtIGZvciB1c2Ugd2hlbiBhIGNlcnRhaW4gYnJhbmNoIG9mIGNvZGUgc2hvdWxkIG5ldmVyIGJl IGV4ZWN1dGVkLgorICAgIDxwcmUgY2xhc3M9ImNvZGUiPgoraWYgKGNvbmRpdGlvbikgeworICAu Li4KK30gZWxzZSB7CisgICAgPHNwYW4gY2xhc3M9ImNvbW1lbnQiPi8vIFRoaXMgc2hvdWxkIG5l dmVyIGhhcHBlbi48L3NwYW4+CisgICAgQVNTRVJUX1VOUkVBQ0hFRCgpOworfQorPC9wcmU+Cisg IDwvbGk+CisgIDxsaT5BU1NFUlRfVU5VU0VEKHZhcmlhYmxlLCBleHByZXNzaW9uKSAtIGZvciBh c3NlcnRpb25zIHRoYXQgY2hlY2sgdGhlIHZhbHVlIG9mIG90aGVyd2lzZSB1bnVzZWQgZnVuY3Rp b24gYXJndW1lbnRzLgorICAgIDxwPgorICAgIEluIHJlbGVhc2UgYnVpbGRzIHRoaXMgY29tcGls ZXMgZG93biB0bworICAgIDxwcmUgY2xhc3M9ImNvZGUiPgorKHZvaWQpdmFyaWFibGUKKzwvcHJl PkFuZCBpbiBkZWJ1ZyBidWlsZHMgaXQgaXMgaW50ZXJwcmV0ZWQgYXMKKyAgICA8cHJlIGNsYXNz PSJjb2RlIj4KK0FTU0VSVChleHByZXNzaW9uKQorPC9wcmU+Cis8L3A+VGhlIG5lZWQgZm9yIHRo aXMgYmVjb21lcyBhcHBhcmVudCBpZiB5b3UgY29uc2lkZXIgdGhlIGNhc2Ugd2hlcmUgeW91IHdh bnQgdG8gYXNzZXJ0IGFuIGV4cHJlc3Npb24gdGhhdCB1c2VzIGEgdmFyaWFibGUgdGhhdCB3b3Vs ZG4ndCBvdGhlcndpc2UgYmUgdXNlZCBpbiB0aGUgZW5jbG9zaW5nIGZ1bmN0aW9uLiBBU1NFUlQo KSBjYW4ndCBiZSB1c2VkIGluIHRoaXMgY2FzZSBiZWNhdXNlIGluIGEgcmVsZWFzZSBidWlsZCB0 aGUgY29tcGlsZXIgd291bGQgd2FybiBhYm91dCB0aGUgdW51c2VkIHZhcmlhYmxlLiBBU1NFUlRf VU5VU0VEKCkgYXZvaWRzIHRoaXMgd2FybmluZy4gRXhhbXBsZSBmcm9tIDxhIGhyZWY9Imh0dHA6 Ly90cmFjLndlYmtpdC5vcmcvYnJvd3Nlci90cnVuay9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pT Tm90QW5PYmplY3QuY3BwIj5KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTTm90QW5PYmplY3QuY3Bw PC9hPiA6CisgICAgPHByZSBjbGFzcz0iY29kZSI+CitKU1ZhbHVlIEpTTm90QW5PYmplY3Q6OnRv UHJpbWl0aXZlKEV4ZWNTdGF0ZSogZXhlYywgUHJlZmVycmVkUHJpbWl0aXZlVHlwZSkgY29uc3QK K3sKKyAgICA8c3BhbiBjbGFzcz0iY29tbWVudCI+Ly8gZXhlYyBub3QgdXNlZCBvdXRzaWRlIHRo ZSBBU1NFUlQoKS48L3NwYW4+CisgICAgQVNTRVJUX1VOVVNFRChleGVjLCBleGVjLSZndDtoYWRF eGNlcHRpb24oKSAmYW1wOyZhbXA7IGV4ZWMtJmd0O2V4Y2VwdGlvbigpID09IG1fZXhjZXB0aW9u KTsKKyAgICByZXR1cm4gbV9leGNlcHRpb247Cit9Cis8L3ByZT4KKyAgPC9saT4KKyAgPGxpPkFT U0VSVF9XSVRIX01FU1NBR0UoZXhwcmVzc2lvbiwgLi4uKSAtIGZvciB1c2Ugd2hlbiB5b3Ugd2Fu dCB0byBwcmludCBleHRyYSBpbmZvcm1hdGlvbiBpbiB0aGUgY2FzZSBvZiBhIGZhaWxlZCBhc3Nl cnRpb24uIEFjY2VwdHMgYSBwcmludGYoKSBzdHlsZSB2YXJpYWJsZSBudW1iZXIgb2YgYXJndW1l bnRzIGFmdGVyIHRoZSBleHByZXNzaW9uIHdoaWNoIGFyZSBwcmludGVkIG91dCBpZiB0aGUgYXNz ZXJ0aW9uIGZhaWxzLgorICAgIDxwPgorICAgICAgRXhhbXBsZSBmcm9tIDxhIGhyZWY9Imh0dHA6 Ly90cmFjLndlYmtpdC5vcmcvYnJvd3Nlci90cnVuay9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1Rp bWVvdXRDaGVja2VyLmNwcCI+SmF2YVNjcmlwdENvcmUvcnVudGltZS9UaW1lb3V0Q2hlY2tlci5j cHA8L2E+CisgICAgPC9wPgorICAgIDxwcmUgY2xhc3M9ImNvZGUiPgorQVNTRVJUX1dJVEhfTUVT U0FHRShlcnIgPT0gS0Vyck5vbmUsICJHZXRDcHVUaW1lIGZhaWxlZCB3aXRoICVkIiwgZXJyKTsK KzwvcHJlPgorICA8L2xpPgorPC91bD4KKzxoMj4KKyAgVGhlIENSQVNIKCkgbWFjcm8KKzwvaDI+ Cis8cD4KKyAgQ1JBU0goKSByYWlzZXMgYSBmYXRhbCBlcnJvciByZXN1bHRpbmcgaW4gcHJvZ3Jh bSB0ZXJtaW5hdGlvbiBhbmQgdHJpZ2dlcmluZyBlaXRoZXIgdGhlIGRlYnVnZ2VyIG9yIHRoZSBj cmFzaCByZXBvcnRlci4gSXQgaXMgYWN0aXZlIGluIGJvdGggZGVidWcgJmFtcDsgcmVsZWFzZSBt b2RlLiBDUkFTSCgpIGhhcyBhIGRpcmVjdCBlZmZlY3Qgb24gZW5kIHVzZXJzIGFuZCBjYW4gYmUg dXNlZCBpbiB0aGUgZmllbGQgdG8gZ2F0aGVyIGluZm9ybWF0aW9uLgorPC9wPgorPGgyPgorICBD b25zaWRlcmF0aW9ucyB3aGVuIHVzaW5nIEFTU0VSVCooKSBhbmQgQ1JBU0goKSBtYWNyb3MuCis8 L2gyPgorPGgzPgorICBIYXphcmRzIG9mIHVzaW5nIEFTU0VSVCooKSBtYWNyb3MKKzwvaDM+Cis8 cD4KKyAgVGhlIGV4cHJlc3Npb24gaW5zaWRlIHRoZSBBU1NFUlQoZXhwcmVzc2lvbikgbWFjcm8g aXMgY29tcGlsZWQgb3V0IG9mIHJlbGVhc2UgYnVpbGRzIHRvZ2V0aGVyIHdpdGggdGhlIG1hY3Jv IGl0c2VsZi4gSWYgdGhlIGV4cHJlc3Npb24gdGhhdCdzIHVzZWQgaGFzIHNpZGUgZWZmZWN0cywg aXRzIG9taXNzaW9uIGluIHJlbGVhc2UgYnVpbGQgY2FuIGxlYWQgdG8gcHJvZ3JhbW1pbmcgZXJy b3JzIHRoYXQgZG9uJ3QgbWFuaWZlc3QgaW4gZGVidWcgYnVpbGRzLgorPC9wPgorPGgzPgorICBU aGUgYmVuZWZpdHMgb2YgYSBDUkFTSCgpOgorPC9oMz4KKzx1bD4KKyAgPGxpPklmIGEgYnJvd3Nl ciB2ZW5kb3IgdHJhY2VzIGNyYXNoZXMgaW4gdGhlaXIgc29mdHdhcmUsIENSQVNIKCkgY2FuIHBy b3ZpZGUgdml0YWwgaW5mb3JtYXRpb24gZnJvbSB0aGUgZmllbGQgdG8gYWxsb3cgYW4gaXNzdWUg dG8gYmUgcmVzb2x2ZWQuCisgIDwvbGk+CisgIDxsaT5Db2RlIGFmdGVyIENSQVNIKCkgaXMgZ3Vh cmFudGVlZCB1bnJlYWNoYWJsZSwgd2hpY2ggY2FuIGhlbHAgcHJldmVudCBzb21lIGJ1Z3MgZnJv bSBiZWluZyBzZWN1cml0eSBsaWFiaWxpdGllcy4KKyAgPC9saT4KKzwvdWw+Cis8aDM+CisgIFRo ZSBjb3N0IG9mIHVzaW5nIENSQVNIOgorPC9oMz4KKzx1bD4KKyAgPGxpPlR1cm5zIGFuIGludGVy bmFsIHByb2dyYW1taW5nIGVycm9yIGludG8gYSBjcmFzaC4gQmxvd3MgYXdheSBhdCBsZWFzdCBh IHRhYiwgYW5kIGluIHNvbWUgY2FzZXMgdGhlIGVudGlyZSB3ZWIgYnJvd3NlciwgaW4gY2FzZXMg dGhhdCBvdGhlcndpc2UgbWlnaHQgYmUgaGFybWxlc3MuCisgIDwvbGk+CisgIDxsaT5UaGUgY29z dCBvZiBldmFsdWF0aW5nIHRoZSBleHByZXNzaW9uIHRoYXQgZGV0ZXJtaW5lcyB3aGV0aGVyIHRo ZSBlcnJvciBjb25kaXRpb24gaGFzIG9jY3VycmVkIGlzIGluY3VycmVkIGluIHJlbGVhc2UgYnVp bGRzIHJhdGhlciB0aGFuIGJlaW5nIGNvbXBpbGVkIG91dCBsaWtlIGl0IGlzIHdpdGggdGhlIEFT U0VSVCgpIG1hY3JvLgorICA8L2xpPgorPC91bD4KKzxoMj4KKyAgR3VpZGVsaW5lcyBmb3IgdXNp bmcgQVNTRVJUKigpIGFuZCBDUkFTSCgpIG1hY3Jvcy4KKzwvaDI+Cis8dWw+CisgIDxsaT5Vc2Ug QVNTRVJUKCkgZm9yIHRoaW5ncyB0aGF0IHNob3VsZCBuZXZlciBoYXBwZW4sIGJ1dCBpZiB0aGV5 IGRvIHdpbGwgY2F1c2UgaW5jb3JyZWN0IHJlc3VsdHMsIG5vdCBhIGNyYXNoIG9yIG1lbW9yeSBj b3JydXB0aW9uLgorICA8L2xpPgorICA8bGk+VXNlIENSQVNIKCkgZm9yIGNhc2VzIHRoYXQgc2hv dWxkbid0IGhhcHBlbiwgYnV0IGlmIHRoZXkgZG8gd291bGQgYmUgdW5yZWNvdmVyYWJsZS4gZS5n LiBPT00gZXJyb3JzLgorICA8L2xpPgorICA8bGk+V2hlbiBwb3NzaWJsZSwgdGhlIGJlc3QgZGVz aWduIGlzIHRvIHJlY292ZXIgZnJvbSBlcnJvcnMsIHBvc3NpYmx5IGFmdGVyIEFTU0VSVCgpaW5n IGlmIHRoZSBjb25kaXRpb24gbWlnaHQgaW5kaWNhdGUgYSBwcm9ncmFtbWluZyBlcnJvci4KKyAg PC9saT4KKzwvdWw+Cis8aDM+CisgIEV4YW1wbGVzIG9mIHVzaW5nIENSQVNIKCkgdnMgQVNTRVJU KCkKKzwvaDM+Cis8cHJlIGNsYXNzPSJjb2RlIj4KKzxzcGFuIGNsYXNzPSJjb21tZW50Ij4vLyBO b3QgaGF2aW5nIGFueSBjaGlsZHJlbiBpbmRpY2F0ZXMgYSBwcm9ncmFtbWluZyBlcnJvci48L3Nw YW4+CitBU1NFUlQob2JqZWN0LT5udW1DaGlsZHJlbigpID4gMCk7CisKK09iamVjdCogYiA9IG5l dyBPYmplY3Q7CitpZiAoIWIpIHsKKyAgICAvLyBOb3QgcG9zc2libGUgdG8gcmVjb3ZlciBmcm9t IGFuIE9PTSBlcnJvci4KKyAgICBDUkFTSCgpOworfQorPC9wcmU+Cis8cD4KKyAgSWYgeW91IGhh dmUgYW55IGNvbW1lbnRzIG9uIHRoZSBhYm92ZSBvciBvdGhlciBpZGVhcyBhYm91dCBpbXByb3Zp bmcgdGhlIGNsYXJpdHksIHNjb3BlLCBvciBwcmVzZW50YXRpb24sIHBsZWFzZSBzZW5kIG1haWwg dG8gdGhlIDxhIGhyZWY9Ii9jb250YWN0Lmh0bWwiPldlYktpdCBtYWlsaW5nIGxpc3Q8L2E+Lgor PC9wPgorCis8P3BocAorICAgIGluY2x1ZGUoIi4uL2Zvb3Rlci5pbmMiKTsKKz8+Cg== 58000 2010-06-07 01:36:57 -0700 2010-06-07 07:43:44 -0700 Documentation on assertion macros document.patch text/plain 6297 playmobil Y29tbWl0IDVkNzdlNjE4ZWFiY2JkMmM0MmJhY2Q4ZmVkYjExYTJkYjMwMTZkOWIKQXV0aG9yOiBK ZXJlbXkgTW9za292aWNoIDxqZXJlbXlAY2hyb21pdW0ub3JnPgpEYXRlOiAgIE1vbiBNYXkgMzEg MTQ6NTc6MzEgMjAxMCArMDMwMAoKICAgIEFkZCBkb2N1bWVudGF0aW9uIG9uIHRoZSB2YXJpb3Vz IGFzc2VydGlvbiBtYWNyb3MgaW4gV2ViS2l0LgogICAgCiAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzk5NTAKCmRpZmYgLS1naXQgYS9XZWJLaXRTaXRlL0NoYW5n ZUxvZyBiL1dlYktpdFNpdGUvQ2hhbmdlTG9nCmluZGV4IGI4ZDZmM2MuLjY0NGExOWUgMTAwNjQ0 Ci0tLSBhL1dlYktpdFNpdGUvQ2hhbmdlTG9nCisrKyBiL1dlYktpdFNpdGUvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTMgQEAKKzIwMTAtMDUtMzEgIEplcmVteSBNb3Nrb3ZpY2ggIDxqZXJlbXlAY2hy b21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIEFkZCBkb2N1bWVudGF0aW9uIG9uIHRoZSB2YXJpb3VzIGFzc2VydGlvbiBtYWNyb3MgaW4g V2ViS2l0LgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0zOTk1MAorCisgICAgICAgICogY29kaW5nL2Fzc2VydGlvbi1ndWlkZWxpbmVzLmh0bWw6IEFk ZGVkLgorCiAyMDEwLTA1LTI5ICBTdGVybGluZyBTd2lnYXJ0ICA8c3N3aWdhcnRAZ29vZ2xlLmNv bT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXZpZCBMZXZpbi4KZGlmZiAtLWdpdCBhL1dlYktp dFNpdGUvY29kaW5nL2Fzc2VydGlvbi1ndWlkZWxpbmVzLmh0bWwgYi9XZWJLaXRTaXRlL2NvZGlu Zy9hc3NlcnRpb24tZ3VpZGVsaW5lcy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLjRlODRiOTYKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXRTaXRlL2NvZGluZy9hc3Nl cnRpb24tZ3VpZGVsaW5lcy5odG1sCkBAIC0wLDAgKzEsMTIzIEBACis8P3BocCAKKyAgICAkdGl0 bGU9IkEgZ3VpZGUgdG8gQXNzZXJ0aW9uIG1hY3JvcyBpbiBXZWJLaXQiOworICAgIGluY2x1ZGUo Ii4uL2hlYWRlci5pbmMiKTsgCis/PgorCis8c3R5bGUgdHlwZT0idGV4dC9jc3MiPgorICAgIC5j b2RlIHsKKyAgICAgICAgYmFja2dyb3VuZC1jb2xvcjogI2VlZTsKKyAgICAgICAgcGFkZGluZzog MWVtOworICAgICAgICBtYXJnaW4tbGVmdDogMmVtOworICAgICAgICBtYXJnaW4tcmlnaHQ6IDJl bTsKKyAgICAgICAgb3ZlcmZsb3cteDogYXV0bzsKKyAgICB9CisgICAgLmNvbW1lbnQgLmZ1bmN0 aW9uLCAuY2xhc3MsIC52YXJpYWJsZSB7CisgICAgICAgIGZvbnQtc3R5bGU6IGl0YWxpYzsKKyAg ICB9Cis8L3N0eWxlPgorCis8aDE+CisgIEEgZ3VpZGUgdG8gQXNzZXJ0aW9uIG1hY3JvcyBpbiBX ZWJLaXQKKzwvaDE+Cis8ZGl2PgorICBWZXJzaW9uIDEsIDIwMTAtNS0yNAorPC9kaXY+Cis8aDI+ CisgIEJhY2tncm91bmQKKzwvaDI+Cis8cD4KKyAgV2ViS2l0IHByb3ZpZGVzIGEgbnVtYmVyIG9m IG1hY3JvcyB0byBhc3NlcnQgdGhhdCBjb25kaXRpb25zIGluIHRoZSBjb2RlIGFyZSBtZXQuIFRo ZXkgYXJlIGRlZmluZWQgaW4gPGEgaHJlZj0iaHR0cDovL3RyYWMud2Via2l0Lm9yZy9icm93c2Vy L3RydW5rL0phdmFTY3JpcHRDb3JlL3d0Zi9Bc3NlcnRpb25zLmgiPkphdmFTY3JpcHRDb3JlL3d0 Zi9Bc3NlcnRpb25zLmg8L2E+LiBUaGlzIGRvY3VtZW50IHByb3ZpZGVzIGFuIG92ZXJ2aWV3IG9m IHRoZSB2YXJpb3VzIG1hY3JvcywgaW5jbHVkaW5nIGd1aWRlbGluZXMgYW5kIGJlc3QgcHJhY3Rp Y2VzIGZvciB0aGVpciB1c2UuCis8L3A+Cis8aDI+CisgIFR5cGVzIG9mIEFTU0VSVCBtYWNyb3MK KzwvaDI+Cis8cD4KKyAgVGhlIEFTU0VSVCgpIG1hY3JvIGFuZCBpdHMgdmFyaWFudHMgYXJlIGNv bXBpbGVkIG91dCBvZiByZWxlYXNlIGJ1aWxkcy4gVGhleSBhcmUgbWVhbnQgZm9yIHVzZSBkdXJp bmcgdGhlIGRldmVsb3BtZW50IHByb2Nlc3MgdG8gY2F0Y2ggcHJvZ3JhbW1pbmcgbWlzdGFrZXMu IEZvciB0aG9zZSBtYWNyb3MgdGhhdCBhY2NlcHQgYW4gZXhwcmVzc2lvbiBhcyBhbiBhcmd1bWVu dCwgdGhlIGV4cHJlc3Npb24gaXMgYWxzbyBjb21waWxlZCBvdXQgb2YgcmVsZWFzZSBidWlsZHMg YW5kIHRodXMgaW5jdXJzIG5vIG92ZXJoZWFkIGluIHNoaXBwaW5nIGNvZGUuCis8L3A+Cis8dWw+ CisgIDxsaT5BU1NFUlQoZXhwcmVzc2lvbikgLSBmb3IgdXNlIGR1cmluZyBkZXZlbG9wbWVudCB0 byBlbnN1cmUgdGhhdCB1bmV4cGVjdGVkIGNvbmRpdGlvbnMgZG8gbm90IG9jY3VyLiBJZiB0aGUg ZXhwcmVzc2lvbiBldmFsdWF0ZXMgdG8gZmFsc2UgdGhlbiBhYm9ydCBleGVjdXRpb24gYW5kIGJy ZWFrIGludG8gdGhlIGRlYnVnZ2VyLgorICA8L2xpPgorICA8bGk+QVNTRVJUX1VOUkVBQ0hFRCgp IC0gZm9yIHVzZSB3aGVuIGEgY2VydGFpbiBicmFuY2ggb2YgY29kZSBzaG91bGQgbmV2ZXIgYmUg ZXhlY3V0ZWQuCisgICAgPHByZSBjbGFzcz0iY29kZSI+CitpZiAoY29uZGl0aW9uKSB7CisgIC4u LgorfSBlbHNlIHsKKyAgICA8c3BhbiBjbGFzcz0iY29tbWVudCI+Ly8gVGhpcyBzaG91bGQgbmV2 ZXIgaGFwcGVuLjwvc3Bhbj4KKyAgICBBU1NFUlRfVU5SRUFDSEVEKCk7Cit9Cis8L3ByZT4KKyAg PC9saT4KKyAgPGxpPkFTU0VSVF9VTlVTRUQodmFyaWFibGUsIGV4cHJlc3Npb24pIC0gZm9yIGFz c2VydGlvbnMgdGhhdCBjaGVjayB0aGUgdmFsdWUgb2Ygb3RoZXJ3aXNlIHVudXNlZCB2YXJpYWJs ZS4gVGhlIG5lZWQgZm9yIHRoaXMgYmVjb21lcyBhcHBhcmVudCBpZiB5b3UgY29uc2lkZXIgdGhl IGNhc2Ugd2hlcmUgeW91IHdhbnQgdG8gYXNzZXJ0IGFuIGV4cHJlc3Npb24gdGhhdCB1c2VzIGEg dmFyaWFibGUgdGhhdCB3b3VsZG4ndCBvdGhlcndpc2UgYmUgdXNlZCBpbiB0aGUgZW5jbG9zaW5n IGZ1bmN0aW9uLiBBU1NFUlQoKSBjYW4ndCBiZSB1c2VkIGluIHRoaXMgY2FzZSBiZWNhdXNlIGlu IGEgcmVsZWFzZSBidWlsZCB0aGUgY29tcGlsZXIgd291bGQgd2FybiBhYm91dCB0aGUgdW51c2Vk IHZhcmlhYmxlLiBBU1NFUlRfVU5VU0VEKCkgYXZvaWRzIHRoaXMgd2FybmluZy4gPGJyPgorRXhh bXBsZSBmcm9tIDxhIGhyZWY9Imh0dHA6Ly90cmFjLndlYmtpdC5vcmcvYnJvd3Nlci90cnVuay9K YXZhU2NyaXB0Q29yZS9qaXQvRXhlY3V0YWJsZUFsbG9jYXRvclBvc2l4LmNwcCI+SmF2YVNjcmlw dENvcmUvaml0L0V4ZWN1dGFibGVBbGxvY2F0b3JQb3NpeC5jcHA8L2E+IDoKKyAgICA8cHJlIGNs YXNzPSJjb2RlIj4KK3ZvaWQgRXhlY3V0YWJsZVBvb2w6OnN5c3RlbVJlbGVhc2UoY29uc3QgRXhl Y3V0YWJsZVBvb2w6OkFsbG9jYXRpb24mYW1wOyBhbGxvYykKK3sgCisgICAgaW50IHJlc3VsdCA9 IG11bm1hcChhbGxvYy5wYWdlcywgYWxsb2Muc2l6ZSk7CisgICAgPHNwYW4gY2xhc3M9ImNvbW1l bnQiPi8vIHJlc3VsdCBub3QgdXNlZCBvdXRzaWRlIHRoZSBBU1NFUlQoKS48L3NwYW4+CisgICAg QVNTRVJUX1VOVVNFRChyZXN1bHQsICFyZXN1bHQpOworfQorPC9wcmU+CisgIDwvbGk+Cis8L3Vs PgorPGgyPgorICBUaGUgQ1JBU0goKSBtYWNybworPC9oMj4KKzxwPgorICBDUkFTSCgpIHJhaXNl cyBhIGZhdGFsIGVycm9yIHJlc3VsdGluZyBpbiBwcm9ncmFtIHRlcm1pbmF0aW9uIGFuZCB0cmln Z2VyaW5nIGVpdGhlciB0aGUgZGVidWdnZXIgb3IgdGhlIGNyYXNoIHJlcG9ydGVyLiBJdCBpcyBh Y3RpdmUgaW4gYm90aCBkZWJ1ZyAmYW1wOyByZWxlYXNlIG1vZGUuIENSQVNIKCkgZGlyZWN0bHkg YWZmZWN0cyB1c2VycyBpbiB0aGF0IGl0IHdpbGwgZGlzcnVwdCBvciBlbmQgdGhlaXIgYnJvd3Np bmcgc2Vzc2lvbi4gSWYgYSBicm93c2VyIHZlbmRvciB0cmFjZXMgY3Jhc2hlcywgaXQgY2FuIGJl IGV4dHJlbWVseSBoZWxwZnVsIGluIGRpYWdub3NpbmcgaGFyZCB0byBmaW5kIGlzc3VlcyB0aGF0 IG1heSBvbmx5IG9jY3VyIG9uIHVzZXJzJyBtYWNoaW5lcy4KKzwvcD4KKzxoMj4KKyAgQ29uc2lk ZXJhdGlvbnMgd2hlbiB1c2luZyBBU1NFUlQoKSBhbmQgQ1JBU0goKSBtYWNyb3MuCis8L2gyPgor PGgzPgorICBIYXphcmRzIG9mIHVzaW5nIHRoZSBBU1NFUlQoKSBmYW1pbHkgb2YgbWFjcm9zCis8 L2gzPgorPHA+CisgIFRoZSBleHByZXNzaW9uIGluc2lkZSB0aGUgQVNTRVJUIGFuZCBBU1NFUlRf VU5VU0VEIG1hY3JvIGlzIGNvbXBpbGVkIG91dCBvZiByZWxlYXNlIGJ1aWxkcyB0b2dldGhlciB3 aXRoIHRoZSBtYWNybyBpdHNlbGYuIElmIHRoZSBleHByZXNzaW9uIHRoYXQncyB1c2VkIGhhcyBz aWRlIGVmZmVjdHMsIGl0cyBvbWlzc2lvbiBpbiByZWxlYXNlIGJ1aWxkIGNhbiBsZWFkIHRvIHBy b2dyYW1taW5nIGVycm9ycyB0aGF0IGRvbid0IG1hbmlmZXN0IGluIGRlYnVnIGJ1aWxkcy4KKzwv cD4KKzxoMz4KKyAgVGhlIGJlbmVmaXRzIG9mIHVzaW5nIENSQVNIOgorPC9oMz4KKzx1bD4KKyAg PGxpPklmIGEgYnJvd3NlciB2ZW5kb3IgdHJhY2VzIGNyYXNoZXMgaW4gdGhlaXIgc29mdHdhcmUs IENSQVNIKCkgY2FuIHByb3ZpZGUgdml0YWwgaW5mb3JtYXRpb24gZnJvbSBlbmQgdXNlcnMgdG8g YWxsb3cgYW4gaXNzdWUgdG8gYmUgcmVzb2x2ZWQuCisgIDwvbGk+CisgIDxsaT5Db2RlIGFmdGVy IENSQVNIKCkgaXMgZ3VhcmFudGVlZCB1bnJlYWNoYWJsZSwgd2hpY2ggY2FuIGhlbHAgcHJldmVu dCBzb21lIGJ1Z3MgZnJvbSBiZWluZyBzZWN1cml0eSBsaWFiaWxpdGllcy4KKyAgPC9saT4KKzwv dWw+Cis8aDM+CisgIFRoZSBjb3N0IG9mIHVzaW5nIENSQVNIOgorPC9oMz4KKzx1bD4KKyAgPGxp PlVzZSBvZiB0aGUgQ1JBU0ggbWFjcm8gdHVybnMgYSBwcm9ncmFtbWluZyBlcnJvciBpbnRvIGEg Y3Jhc2gsIGJsb3dpbmcgYXdheSBhIHdlYnBhZ2Ugb3IgYW4gZW50aXJlIHdlYiBicm93c2VyIGlu IGNhc2VzIHRoYXQgb3RoZXJ3aXNlIG1pZ2h0IGJlIGhhcm1sZXNzLgorICA8L2xpPgorICA8bGk+ Q2hlY2tpbmcgZm9yIHRoZSBlcnJvciBjb25kaXRpb24gaW4gcmVsZWFzZSBidWlsZHMgbWF5IHNs b3cgdGhlIHByb2dyYW0gZG93bi4KKyAgPC9saT4KKzwvdWw+Cis8aDI+CisgIEd1aWRlbGluZXMg Zm9yIHVzaW5nIEFTU0VSVCgpIGFuZCBDUkFTSCgpIG1hY3Jvcy4KKzwvaDI+Cis8dWw+CisgIDxs aT5Vc2UgQVNTRVJUKCkgZm9yIHRoaW5ncyB0aGF0IHNob3VsZCBuZXZlciBoYXBwZW4sIGJ1dCBp ZiB0aGV5IGRvIHdpbGwgY2F1c2UgaW5jb3JyZWN0IHJlc3VsdHMgcmF0aGVyIHRoYW4gYSBjcmFz aCBvciBtZW1vcnkgY29ycnVwdGlvbi4KKyAgPC9saT4KKyAgPGxpPlVzZSBDUkFTSCgpIGZvciBj YXNlcyB0aGF0IHNob3VsZG4ndCBoYXBwZW4sIGJ1dCBpZiB0aGV5IGRvIHdvdWxkIGJlIHVucmVj b3ZlcmFibGUuIGUuZy4gb3V0IG9mIG1lbW9yeSBlcnJvcnMuCisgIDwvbGk+CisgIDxsaT5XaGVu IHBvc3NpYmxlLCBpdCBpcyBvZnRlbiBwcmVmZXJhYmxlIHRvIHJlY292ZXIgZnJvbSBub24tZmF0 YWwgZXJyb3JzLiBUaGUgQVNTRVJUIG1hY3JvIGNhbiBiZSB1c2VkIGlmIHRoZSBlcnJvciBjb25k aXRpb24gY291bGQgaW5kaWNhdGUgYSBwcm9ncmFtbWluZyBtaXN0YWtlIG9yIG90aGVyIGJhZCBi ZWhhdmlvciBkZXNlcnZpbmcgYXR0ZW50aW9uLgorICA8L2xpPgorPC91bD4KKzxoMz4KKyAgRXhh bXBsZXMgb2YgdXNpbmcgQ1JBU0goKSB2cyBBU1NFUlQoKQorPC9oMz4KKzxwcmUgY2xhc3M9ImNv ZGUiPgorPHNwYW4gY2xhc3M9ImNvbW1lbnQiPi8vIE5vdCBoYXZpbmcgYW55IGNoaWxkcmVuIGlu ZGljYXRlcyBhIHByb2dyYW1taW5nIGVycm9yLjwvc3Bhbj4KK0FTU0VSVChvYmplY3QtJmd0O251 bUNoaWxkcmVuKCkgJmd0OyAwKTsKKworQWxsb2NhdGlvbiBtZW0gPSBzeXN0ZW1BbGxvYyhhbGxv Y1NpemUpOworaWYgKCFtZW0ucGFnZXMpCisgICAgQ1JBU0goKTsgPHNwYW4gY2xhc3M9ImNvbW1l bnQiPi8vIE5vdCBwb3NzaWJsZSB0byByZWNvdmVyIGZyb20gYW4gb3V0IG9mIG1lbW9yeSBlcnJv ci48L3NwYW4+Cis8L3ByZT4KKzxwPgorICBJZiB5b3UgaGF2ZSBhbnkgY29tbWVudHMgb24gdGhl IGFib3ZlIG9yIG90aGVyIGlkZWFzIGFib3V0IGltcHJvdmluZyB0aGUgY2xhcml0eSwgc2NvcGUs IG9yIHByZXNlbnRhdGlvbiwgcGxlYXNlIHNlbmQgbWFpbCB0byB0aGUgPGEgaHJlZj0iL2NvbnRh Y3QuaHRtbCI+V2ViS2l0IG1haWxpbmcgbGlzdDwvYT4uCis8L3A+CisKKzw/cGhwCisgICAgaW5j bHVkZSgiLi4vZm9vdGVyLmluYyIpOworPz4K