HACKING

Hacking cve-check-tool
----------------------

Indentation is strictly 8 spaces (set tab stops to 8 spaces) - No tabs
No spaces between function name and parentheses. Only use space after
"if (", etc.

Curly braces must be on the same line (i.e. expressions) unless it
is the function declaration:

Acceptable:
        int main(int argc, char **argv)
        {
                if (someThingOrOther) {
                        // Do something
                }
                return 0;
        }

Unacceptable:
        int main(int argc, char **argv) {

                if(someThingOrOther)
                {
                        // Do something
                }
                return 0;
        }

When appropriate remember to declare your function first! It helps when
looking back through the file.

Use consistent pointers! "*" should prefix your variable name. Also ensure
your pointers (where appropriate) are not left uninitialized, resulting
in broken g_free() calls.

Acceptable:
        char *something = NULL;
        doFunc(&something);

Unacceptable:
        char* something;
        doFunc(&someThing);

Minimise your use of "goto"'s, and test every code path is reached. Also
ensure *every* if/else, etc, even if single line, is wrapped in curly braces.

Memory management:
------------------
cve-check-tool prefers a scope-based approach to memory management,
employing a RAII-like system for allocations. Where possible, avoid
explicit free's and reuse of unrelated variables.

util.h defines a number of autofree()-ready types. These are implemented
using __attribute__ ((cleanup(x))), available in GCC and Clang. Thus,
MSVC (and potentially other compilers) are not supported.

An autofree variable is declared using the autofree() macro, which is
primarily provided for syntatical sugar. Here is an example of a
variable that is automatically reaped/freed when it goes out of scope:

        autofree(GError) *error = NULL;

Remember that these *are* scope sensitive, so the following would result
in undefined behaviour:

        gchar *somestr = NULL;
        {
                autofree(gchar) *str = g_strdup_printf("Scoped string\n");
                somestr = str;
        }
        printf("%s: %d\n", somestr, strlen(somestr));

At this point, 'str' has been freed, and somestr still points to the
memory that has now been freed.

As a rule of thumb, if you find yourself in an instance where you have
used an explicit free/unref in a fashion that could be automated, you
should define the cleanup function in util.h (see DEF_AUTOFREE)

Pull Requests/commiting:
------------------------
Commits should clearly define the purpose in less than 80 columns in
the first line. Futher expansion, if needed, should be provided in a
following paragraph, separated by one blank line.

N.B This hacking document is a port of Solus Project C Coding Style.
For futher details (including *non-glib*) functions, see:

 * https://solus-project.com/wiki/Development/CodingStyleC