Background

Header Files dev-style-header

#ifndef NVIM_FOO_BAR_H
#define NVIM_FOO_BAR_H
…
#endif  // NVIM_FOO_BAR_H

Scoping dev-style-scope

int i;
i = f();      // BAD: initialization separate from declaration.
int j = g();  // GOOD: declaration has initialization.

Nvim-Specific Magic

Other C Features dev-style-features

for (int i = 0; i < 3; i++) { }
int j = ++i;  // OK: ++i is used as an expression.
for (int i = 0; i < 3; ++i) { }
++i;  // BAD: ++i is used as a statement.

void foo(const char *p, int i);
}
int foo(const int a, const bool b) {
}
int foo(int *const p) {
}

int loaded = 1;  // BAD: loaded should have type bool.

if (1 == x) {
if (x == 1) {  //use this order
if ((x = f()) && (y = g())) {

static void f(void);
static void f(void)
{
…
}

<HEADER>
<PUBLIC FUNCTION DEFINITIONS>
<STATIC FUNCTION DEFINITIONS>

// src/nvim/foo.c file
#include <stddef.h>
typedef int FooType;
#ifdef INCLUDE_GENERATED_DECLARATIONS
include “foo.c.generated.h”
#endif
…
// src/nvim/foo.h file
#ifndef NVIM_FOO_H
#define NVIM_FOO_H
…
#ifdef INCLUDE_GENERATED_DECLARATIONS
include “foo.h.generated.h”
#endif
#endif  // NVIM_FOO_H

Struct data;
memset(&data, 0, sizeof(data));
memset(&data, 0, sizeof(Struct));
if (raw_size < sizeof(int)) {
fprintf(stderr, “compressed record not big enough for count: %ju”, raw_size);
return false;
}

Naming dev-style-naming

int price_count_reader;    // No abbreviation.
int num_errors;            // "num" is a widespread convention.
int num_dns_connections;   // Most people know what "DNS" stands for.
int n;                     // Meaningless.
int nerr;                  // Ambiguous abbreviation.
int n_comp_conns;          // Ambiguous abbreviation.
int wgc_connections;       // Only your group knows what this stands for.
int pc_reader;             // Lots of things can be abbreviated “pc”.
int cstmr_id;              // Deletes internal letters.

my_useful_file.c
getline_fix.c  // OK: getline refers to the glibc function.

struct my_struct {
  ...
};
typedef struct my_struct MyAwesomeStruct;

string table_name;  // OK: uses underscore.
string tablename;   // OK: all lowercase.
string tableName;   // BAD: mixed case.

struct url_table_properties {
  string name;
  int num_entries;
}

const int kDaysInAWeek = 7;

void unix_open(const char *path);
void unix_user_id(void);

enum url_table_errors {
  kOK = 0,
  kErrorOutOfMemory,
  kErrorMalformedInput,
};

#define ROUND(x) ...
#define PI_ROUNDED 5.0

Comments dev-style-comments

// This is a comment spanning
// multiple lines
f();

/// A brief description of this file.
///
/// A longer description of this file.
/// Be very generous here.

/// Window info stored with a buffer.
///
/// Two types of info are kept for a buffer which are associated with a
/// specific window:
/// 1. Each window can have a different line number associated with a
/// buffer.
/// 2. The window-local options for a buffer work in a similar way.
/// The window-info is kept in a list at g_wininfo.  It is kept in
/// most-recently-used order.
struct win_info {
  /// Next entry or NULL for last entry.
  WinInfo *wi_next;
  /// Previous entry or NULL for first entry.
  WinInfo *wi_prev;
  /// Pointer to window that did the wi_fpos.
  Win *wi_win;
  ...
};

struct wininfo_S {
  WinInfo *wi_next;  ///< Next entry or NULL for last entry.
  WinInfo *wi_prev;  ///< Previous entry or NULL for first entry.
  Win *wi_win;       ///< Pointer to window that did the wi_fpos.
  ...
};

// Note that we don't use Doxygen comments here.
Iterator *get_iterator(void *arg1, void *arg2)
{
  ...
}

/// The total number of tests cases that we run
/// through in this regression test.
const int kNumTestCases = 6;

// If we have enough memory, mmap the data portion too.
mmap_budget = max<int64>(0, mmap_budget - index_->length());
if (mmap_budget >= data_size_ && !MmapData(mmap_chunk_bytes, mlock)) {
  return;  // Error already logged.
}

do_something();                      // Comment here so the comments line up.
do_something_else_that_is_longer();  // Comment here so there are two spaces between
                                     // the code and the comment.
{ // One space before comment when opening a new scope is allowed,
  // thus the comment lines up with the following comments and code.
  do_something_else();  // Two spaces before line comments normally.
}

bool success = calculate_something(interesting_value,
                                   10,
                                   false,
                                   NULL);  // What are these arguments??

bool success = calculate_something(interesting_value,
                                   10,     // Default base value.
                                   false,  // Not the first time we're calling this.
                                   NULL);  // No callback.

const int kDefaultBaseValue = 10;
const bool kFirstTimeCalling = false;
Callback *null_callback = NULL;
bool success = calculate_something(interesting_value,
                                   kDefaultBaseValue,
                                   kFirstTimeCalling,
                                   null_callback);

// Now go through the b array and make sure that if i occurs,
// the next element is i+1.
...        // Geez.  What a useless comment.

// TODO(kl@gmail.com): Use a "*" here for concatenation operator.
// TODO(Zeke): change this to use relations.

Formatting dev-style-format

bool retval = do_something(argument1, argument2, argument3);

bool retval = do_something(averyveryveryverylongargument1,
                           argument2, argument3);

bool retval = do_something(argument1,
                           argument2,
                           argument3,
                           argument4);

if (...) {
  ...
  ...
  if (...) {
    do_something(
        argument1,  // 4 space indent
        argument2,
        argument3,
        argument4);
  }

struct my_struct m = {  // Here, you could also break before {.
    superlongvariablename1,
    superlongvariablename2,
    { short, interior, list },
    { interiorwrappinglist,
      interiorwrappinglist2 } };

switch (var) {
  case 0:
    ...
    break;
  case 1:
    ...
    break;
  default:
    assert(false);
}

return result;
return (some_long_condition && another_condition);
return (value);  // You wouldn’t write var = (value);
return(result);  // return is not a function!

int x[] = { 0 };  // Spaces inside braces for braced-init-list.

int long_variable = 0;  // Don't align assignments.
int i             = 1;
struct my_struct {  // Exception: struct arrays.
const char *boy;
const char *girl;
int pos;
} my_variable[] = {
{ “Mia”,       “Michael”, 8  },
{ “Elizabeth”, “Aiden”,   10 },
{ “Emma”,      “Mason”,   2  },
};

x = 0;            // Assignment operators always have spaces around
                  // them.
x = -5;           // No spaces separating unary operators and their
x++;              // arguments.
if (x && !y)

Parting Words