| # Coding standard | |
| I guess I should document this, it might not be obvious. | |
| libcody is implemented in C++11. Because it's used in compiler | |
| development, we can't use the latest and greatest. | |
| The formatting is close to GNU, but with a few differences. | |
| ## Extensions to C++11 | |
| It uses __VA_OPT__ when available, falling back on GNU's variadic | |
| macro `,#` extension. This is in the `Assert` macro, so one can have | |
| multi-argument template instantiations there. Not that libcody does | |
| that, but this is code I used elsewhere. | |
| ## GNU | |
| The underlying formatting is GNU style. Here are a few notes about | |
| things that commonly catches programmers unfamiliar with it is: | |
| * Spaces between binary operators. Particularly in a function call, | |
| between the name and the open paren: | |
| ```c++ | |
| Fn (a + b, ary[4], *ptr); | |
| ``` | |
| In general GNU style uses a lot more whitespace than Clang-style. | |
| We're not trying to cram as much code as possible onto a page! | |
| * Scope braces are always on a line of their own, indented by 2 | |
| spaces, if they're a sub-statement of an `if`, `for` or whatever: | |
| ```c++ | |
| if (bob) | |
| { | |
| Frob (); | |
| Quux (); | |
| } | |
| ``` | |
| Conditions and loops containing a single statement should not use `{}`. | |
| FWIW this was my personal indentation scheme, before I even met GNU code! | |
| * The same is true for a function definition body, except the | |
| indentation is zero: | |
| ```c++ | |
| int Foo () | |
| noexcept // indented | |
| { | |
| return 0; | |
| } | |
| ``` | |
| * Initialization bracing is not like scope bracing. There tends to be | |
| more flexibility. | |
| * Break lines at 80 chars, this should be /before/ the operator, not after: | |
| ```c++ | |
| a = (b | |
| + c); | |
| ptr | |
| ->MemberFn (stuff); | |
| Func | |
| (arg); | |
| ``` | |
| Thus you can tell what lines are continued from the previous by | |
| looking at their start. Use parens to control indentation. | |
| If you find yourself wanting to break a line at `.`, don't. | |
| Refactor your code to avoid needing that. | |
| * Template instantiations and C++ casts should have no space before the `<`: | |
| ```c++ | |
| std::vector<int> k; | |
| static_cast<T> (arg); // space before the ( though | |
| ``` | |
| * Pointer and reference types need a space before the `*` or `&`, if | |
| the preceding token is ascii text (a cpp-identifier): | |
| ``` | |
| int *ptr; | |
| int **ptr_ptr; | |
| int *&pref = ptr; | |
| ``` | |
| See below a difference in qualifier placement. | |
| * Code should compile without warnings. | |
| ## Not GNU | |
| ### Names | |
| Unlike GNU code, variants of Camel Case are used. use `PascalCase` | |
| for function, type and global variable names. Use `dromedaryCase` for | |
| member variables. Block-scope vars can be `dromedaryCase` or | |
| `snake_case`, your choice. | |
| ### Type qualifiers | |
| Type qualifiers go after the thing they qualify. You have to do this | |
| for pointers anyway, and read them inside-out, because, C Just being | |
| consistent: | |
| ```c++ | |
| int const foo = 5; // constant int | |
| int *const pfoo = nullptr; // constant pointer to int | |
| ``` |