standards-compliance

I was thinking about Registering an Application to a URL Protocol and I'd like to know, what characters are allowed in a scheme? Some examples: h323 (has numbers) h323:[<user>@]<host>[:<port>][;<parameters>] z39.50r (has a . as well) z39.50r://<host>[:<port>]/<database>?<docid>[;esn=<elementset>][;rs=<recordsyntax>] paparazzi:http (has a : ) paparazzi:http:[//<host>[:[<port>][<transport>]]/ So, what characters can I fancy using? Can we have... @:TwitterUser #:HashTag $:CapitalStock ?:ID-10T ...etc., as desired, or characters in the scheme are restricted by standard? According to RFC 2396 ,

Some dynamically-typed languages use pointer tagging as a quick way to identify or narrow down the runtime type of the value being represented. A classic way to do this is to convert pointers to a suitably sized integer, and add a tag value over the least significant bits which are assumed to be zero for aligned objects. When the object needs to be accessed, the tag bits are masked away, the integer is converted to a pointer, and the pointer is dereferenced as normal. This by itself is all in order, except it all hinges on one colossal assumption: that the aligned pointer will convert to an

This is a follow-up question. In the previous question , @JohannesSchaub-litb said that the following code is not fully standard-conformant: class { int i; }; //unnamed-class definition. § 9/1 allows this! and then he added, while it is grammatically valid, it breaks the rule that such a class must declare at least one name into its enclosing scope. I couldn't really understand this. What name is he talking about? Could anyone elaborate on this further (preferably quoting the Standard)? Clause 9 of the standard allows class {public: int i;} (note the lack of a final semicolon) because this

Assume I have guarantees that float is IEEE 754 binary32. Given a bit pattern that corresponds to a valid float, stored in std::uint32_t , how does one reinterpret it as a float in a most efficient standard compliant way? float reinterpret_as_float(std::uint32_t ui) { return /* apply sorcery to ui */; } I've got a few ways that I know/suspect/assume have some issues: Via reinterpret_cast , float reinterpret_as_float(std::uint32_t ui) { return reinterpret_cast<float&>(ui); } or equivalently float reinterpret_as_float(std::uint32_t ui) { return *reinterpret_cast<float*>(&ui); } which suffers

How universally is the C99 standard supported in today's compilers? I understand that not even GCC fully supports it. Is this right? Which features of C99 are supported more than others, i.e. which can I use to be quite sure that most compilers will understand me? If you want to write portable C code, then I'd suggest you to write in C89 (old ANSI C standard). This standard is supported by most compilers. The Intel C Compiler has very good C99 support and it produces fast binaries. (Thanks 0x69 !) MSVC supports some new features and Microsoft plan to broaden support in future versions. GCC

I'm currently reading John Papa's AngularJS style guide and saw the code : function dataService() { var someValue = ''; var service = { save: save, someValue: someValue, validate: validate }; return service; //////////// function save() { /* */ }; function validate() { /* */ }; } You can see that the functions save and validate are defined after the function returned a value. How does this work? Is it standard-compliant and works in all browsers (say, from IE 6)? You can see that the functions save and validate are defined after the function returned a value. That's what it looks like from

Which of the two (semantically equivalent) ways is preferable to test for inequality? 'foo' != 'bar' (exclamation mark and equals sign) 'foo' <> 'bar' (less than and greater than chevron symbols together) The MySQL documentation clearly indicates that there is no difference between them and yet some people seem to be attached to only doing it one way or the other. Maybe this is just another pointless vi vs. emacs debate but when other people are reading your code (and therefore your queries), it's useful to maintain some consistency. <> looks a lot like <=> which is a very underused operator

Does <!DOCTYPE html> trigger standards mode for older browsers as well? Saying "in all modern browsers" isn't very precise. I am especially interested in IE6. Thank you. This is how the HTML5 doctype came into existance (in layman's terms): The guys who make the standards wanted a simpler doctype. They found out that <!DOCTYPE html> (which is as simple as it gets) does trigger standards mode in browsers. They decided to standardize it in HTML5. True story. Yes, it does trigger (Almost) Standards Mode in older browsers (such as IE6). See: http://hsivonen.iki.fi/doctype/ Standards mode, cutting

Coderbyte is an online coding challenge site (I found it just 2 minutes ago). The first C++ challenge you are greeted with has a C++ skeleton you need to modify: #include <iostream> #include <string> using namespace std; int FirstFactorial(int num) { // Code goes here return num; } int main() { // Keep this function call here cout << FirstFactorial(gets(stdin)); return 0; } If you are little familiar with C++ the first thing * that pops in your eyes is: int FirstFactorial(int num); cout << FirstFactorial(gets(stdin)); So, ok, the code calls gets which is deprecated since C++11 and removed