coding-style.txt

These coding styles are derived from the GNOME coding styles and have been
adapted to better fit with C++.
So, please read
http://developer.gnome.org/doc/guides/programming-guidelines/code-style.html
as an introduction.

Be consistent

    As a rule of thumb, please try to use the style that was there before you,
    otherwise the code will be non consistent.

Lines and functions length

    1. Lines should be 80 characters long, at most.
        Lots of people out there divide their screen in 2 vertical rectangles,
        each vertical rectangle being itself divided in two horizontal rectangles.
        So don't assume everybody looks at only one file at a time, full screen.
        Or don't assume everybody has huge screens.
        Generally speaking, be consitent. Do not make your lines longer than the
        lines already written in other parts of the code.
    2. Similar things applies to functions length. Be consistent with the other parts of the code.
    3. No function should contain more than 4 levels of indentation.

Indenting

    1.  Use spaces to indent. Tabs should not appear in code files
        (with the exception of files that require tabs, e.g. Makefiles).
    2.  The indent size is 4 spaces.
    3.  Code editors should be configured to expand tabs that you type to 4 spaces.

Naming conventions

    1. function names are lowercase with underscores to separate words,
       like this : do_something_good () .
    2. Macros and constants are uppercase, with underscore to separate
       words like: DO_SOMETHING () for a macro or NUMBER_OF_CHARS for a constant.
    3. user defined types (classes, struct, enum names) are mixed upper and lowercase,
       like class ConfManager ;
    4. don't pollute the global namespace. Every symbol should at least be in the 'nemiver' namespace
       (or in namespaces that are themselves in the nemiver namespace).
    5. To help our fellow emacs users, don't use the keyword 'namespace'
       to define namespace, like "namespace foo { //blah}", otherwise, emacs indents
       //blah.  Use the macro NEMIVER_BEGIN_NAMESPACE (foo) and NEMIVER_END_NAMESPACE (foo), instead.
       This helps emacs not to endent the content of the namespace.
    6. Generaly, C++ data members should be prefixed by m_.

Functions

    1. in function definitions, function name should start on column one.

        Right:

        void
        foo ()
        {
        }

        Wrong:

        void foo ()
        {
        }

    2. rule 1/ does not apply in function declarations.

        Right:

        void foo () ;

    3. function arguments (parameters) should be prefixed by a "a_" or a "an_".

        Right:

        void foo (int a_param) ;
        void bar (int a_param, char an_other_param) ;

        Wrong:

        void foo (int param) ;

Braces

   1. Function definitions — open and close braces should be on lines by
      themselves. Do not put the open brace on the same line as the function
      signature. For example:

      Right:

      void
      foo ()
      {
          // do stuff
      }

      Wrong:

      void foo () {
          // do stuff
      }

      Wrong:

      void
      foo () {
          // do stuff
      }

   2. Other braces, including for, while, do, switch statements and class
      definitions — the open brace should go on the same line as the as the control structure.
      Right:

      for (int i = 0; i < 10; i++) {
          // do stuff
      }

      Wrong:

      for (int i = 0; i < 10; i++)
      {
          // do stuff
      }

   3. If/else statements — as above, but if there is an else clause,
      the close brace should go on the same line as the else.

      Right:

      if (time_to_go_buy_something) {
          go_buy (&something);
      } else if (time_to_go_home) {
          // comment on else case
          gone = true;
      }

      Wrong:

      if (time_to_go_buy_something)
      {
          go_buy (&something);
      // comment on else case
      } else if (timeToGoHome)
          gone = true;

      if (time_to_go_buy_something) {
      }
      else

      // comment on else case
      if (time_to_go_buy_something)
          gone = true;

Parentheses

   1. Function declarations and calls — use one space between the name and
      the open parenthese, no space inside the parentheses, nor before commas
      that separate arguments. Do use a single space after commas that
      separate arguments.

      Right:

      int my_function (int arg1, float arg2);

      void no_arg_function ();

      Wrong:

      int my_function(int arg1, float arg2);

      int my_function ( int arg1 , float arg2 );


   2. Control structures, such as if, while, do and switch — use a single
      space before the open paren, but no spaces inside the parentheses.


Null, false

   1. The null pointer value should be written as 0.
   2. True and false values of type bool, or just generic true/false values,
      should be written as true and false.
   3. Tests for null pointers, false values and 0 values should all be done directly,
      not through an inequality or equality comparison.

      Right:

      // test for true
      if (foo->is_something ()) {
          // code
      }

      // test for false
      if (!foo->is_something ()) {
          // code
      }

      // test for non-null
      if (ptr) {
         // code
      }

      // test for null
      if (!ptr) {
         // code
      }

      // test for nonzero
      if (count) {
          // code
      }

      // test for zero
      if (!count) {
          // code
      }

      Wrong:

      if (foo->isSomething () == true) {
          // code
      }

      if (foo->isSomething () != false) {
          // code
      }

      if (p == NULL) {
          // code
      }

      if (nil != p) {
          // code
      }

      if (count == 0) {
          // code
      }

Generic stuff

    1. variables of builtin types must always be initialized at
       declaration time.

        Right:

        int foo = 0 ;

        Wrong:

        int foo ;

    2. always provide default constructors for user defined types (classes).
       If you don't want to be used with the default constructor, declare
       the default constructor private.