Revision as of 21:10, 29 October 2022

This page describes the standard coding style throughout the gnucash source code.

C Format

Gnucash is fairly relaxed about code format, but we will periodically run a reformatter called Artistic Style (astyle) over the code to clean it up. To reduce the need for this (it messes up VCS history, particularly "blame"), please format your code as follows.

In general, follow the GNU format except use four spaces instead of two for the indents, and don't indent the braces. To summarize, a properly formatted function will look like this:

  guint
  gnc_account_foo (Account *account, gpointer bar)
  {
       Split *baz;
       guint salt;
       if (gnc_split_waldo (baz) > 0)
       {
            salt = gnc_split_pepper (baz);
       }
       return salt;
  }

Please keep lines under 80 characters. If you need to wrap, line up the function arguments like this:

  gnc_account_function_with_a_lot_of_paramters (LongTypeName foo, LongerTypeName *bar,
                                                TypeName baz)
  {
  }

We don't do the wide separation of names and aligned parameters, so don't do this:

  void gnc_account_foo               (Account     *bar,
                                      Split       *baz,
                                      gpointer     waldo);
  Split *gnc_account_pepper          (Account     *salt,
                                      Transaction *sausage);

Instead, do it this way:

  void gnc_account_foo (Account *bar, Split *baz, gpointer waldo);
  Split *gnc_account_pepper (Account *salt, Transaction *sausage);

Break up long if statements like this:

if (gtk_tree_path_get_depth ((GtkTreePath *) selected->data) == 1 &&
    get_action_for_path (selected->data, model) == GNCImport_ADD)

Astyle Commandline

The astyle commandline we use is

astyle 3.1

astyle --indent=spaces=4 --style=break --pad-oper  *.[hc]

astyle 1.24

  astyle --indent=spaces=4 --brackets=break --pad-oper  *.[hc]

Other versions might result in slightly different formatting.

The rationale for the arguments is contained in this email.

C++ Format

C++ follows the C format guidelines above, with the following modifications:

• Namespaces shall be all lower case, and the outermost one shall be named gnc.
• Identifier formats:
  • Typenames (i.e. class, struct, enum, and POD type-aliases) shall be camel-cased.
  • Function and object names shall be lower-case and shall have words separated by underscores.
  • Preprocessor Macros and enumeration names shall be upper-case with words separated by underscores.

In addition, certain types of variables shall have prefixes denoting their roles:

• Member variables: m_.
• Static member variables (a.k.a class variables): c_.
• Static constants: k_.
• Free static variables: s_. Free static variables means statics which are not local and not members of a class or struct, regardless of scope.

Other Formatting:

• Single-line standalone comments can use either C++ style or C style. End-of-line comments should always use C++ style. The preferred style for multi-line comments is currently under discussion.
• Headers and implementation files should be named for the class they declare or implement. In general any file should declare or implement only one class.

Coding Guidance

• Write modern, idiomatic C++ using the new features of C++11; check the CMAKE_CXX_STANDARD setting in CMakeLists.txt to see what features you may use (currently C++17). In particular:
  • Prefer curly braces for initializers and auto for variable declarations.
  • Declare and initialize variables in one statement at the point that they're first used.
  • Use templates instead of copying code and especially instead of preprocessor macros.
  • Prefer passing references to pointers.
  • Do not ever pass void* (aka gpointer) in C++ code. Use templates or class hierarchies to enforce type safety.

Framework

Gnucash is a Gtk+ project. It's design is object-oriented. The current object orientation is implemented mostly with Gnome's GObject C-language framework and makes heavy use of GLib. While this is a rich eco-system, it brings with it a huge number of dependencies which makes GnuCash difficult to port to other operating systems. Consequently the developers have decided to migrate all of GnuCash except the GUI to C++. No new GObject or GLib-dependent code should be written; instead use C++, the C++ standard library, and Boost libraries.

Guile and Scheme

Gnucash is partly implemented in a Scheme dialect called Guile. (It was originally written mostly in Guile, but that implementation was largely replaced with C several years ago.) In particular, the reports system and part of the business system are written in Guile. To support that, most of the core "engine" API is wrapped and accessible from Guile.

Ideally reports and infrastructure code will be coded using a lisp-specific editor such as Emacs. This will facilitate the indenting of parentheses, which will greatly ease readability and maintenance. Emacs coding style is very useful.

Rules for infrastructure code and reports:

• most reports should be self-contained;
• a function designed for multiple reports may be added into infrastructure code e.g. report-utilities.scm but must be documented properly;
• aim to create adequate tests using srfi-64;
• aim for a maximum line width of 78.

Graphical User Interface

See GUI Guidelines‎‎.

Python

The standard is PEP 8 -- Style Guide for Python Code.