Newer Older
QEMU Coding Style
2 3

4 5 6
Please use the script in the scripts directory to check
patches before submitting.

7 8 9 10 11
1. Whitespace

Of course, the most important aspect in any coding style is whitespace.
Crusty old coders who have trouble spotting the glasses on their noses
can tell the difference between a tab and eight spaces from a distance
of approximately fifteen parsecs.  Many a flamewar has been fought and
13 14 15
lost on this issue.

QEMU indents are four spaces.  Tabs are never used, except in Makefiles
where they have been irreversibly coded into the syntax.
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
Spaces of course are superior to tabs because:

 - You have just one way to specify whitespace, not two.  Ambiguity breeds
 - The confusion surrounding 'use tabs to indent, spaces to justify' is gone.
 - Tab indents push your code to the right, making your screen seriously
 - Tabs will be rendered incorrectly on editors who are misconfigured not
   to use tab stops of eight positions.
 - Tabs are rendered badly in patches, causing off-by-one errors in almost
   every line.
 - It is the QEMU coding style.

Do not leave whitespace dangling off the ends of lines.

2. Line width

34 35 36 37 38
Lines should be 80 characters; try not to make them longer.

Sometimes it is hard to do, especially when dealing with QEMU subsystems
that use long function or symbol names.  Even in that case, do not make
lines much longer than 80 characters.
39 40 41 42 43 44 45

 - Some people like to tile their 24" screens with a 6x4 matrix of 80x24
   xterms and use vi in all of them.  The best way to punish them is to
   let them keep doing it.
 - Code and especially patches is much more readable if limited to a sane
   line length.  Eighty is traditional.
46 47
 - The four-space indentation makes the most common excuse ("But look
   at all that white space on the left!") moot.
48 49 50 51
 - It is the QEMU coding style.

3. Naming

Variables are lower_case_with_underscores; easy to type and read.  Structured
53 54
type names are in CamelCase; harder to type but standing out.  Enum type
names and function type names should also be in CamelCase.  Scalar type
55 56 57 58
names are lower_case_with_underscores_ending_with_a_t, like the POSIX
uint64_t and family.  Note that this last convention contradicts POSIX
and is therefore likely to be changed.

59 60 61
When wrapping standard library functions, use the prefix qemu_ to alert
readers that they are seeing a wrapped version; otherwise avoid this prefix.

62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
4. Block structure

Every indented statement is braced; even if the block contains just one
statement.  The opening brace is on the line that contains the control
flow statement that introduces the new block; the closing brace is on the
same line as the else keyword, or on a line by itself if there is no else
keyword.  Example:

    if (a == 5) {
        printf("a was 5.\n");
    } else if (a == 6) {
        printf("a was 6.\n");
    } else {
        printf("a was something else entirely.\n");

78 79 80 81
Note that 'else if' is considered a single statement; otherwise a long if/
else if/else if/.../else sequence would need an indent for every else

82 83 84 85 86 87 88 89 90 91 92
An exception is the opening brace for a function; for reasons of tradition
and clarity it comes on a line by itself:

    void a_function(void)

Rationale: a consistent (except for functions...) bracing style reduces
ambiguity and avoids needless churn when lines are added or removed.
Furthermore, it is the QEMU coding style.
93 94 95

5. Declarations

96 97 98 99 100 101 102 103 104
Mixed declarations (interleaving statements and declarations within
blocks) are generally not allowed; declarations should be at the beginning
of blocks.

Every now and then, an exception is made for declarations inside a
#ifdef or #ifndef block: if the code looks nicer, such declarations can
be placed at the top of the block even if there are statements above.
On the other hand, however, it's often best to move that #ifdef/#ifndef
block to a separate function altogether.
105 106 107 108 109 110 111 112 113 114 115 116 117 118

6. Conditional statements

When comparing a variable for (in)equality with a constant, list the
constant on the right, as in:

if (a == 1) {
    /* Reads like: "If a equals 1" */

Rationale: Yoda conditions (as in 'if (1 == a)') are awkward to read.
Besides, good compilers already warn users when '==' is mis-typed as '=',
even when the constant is on the right.
119 120 121 122 123 124 125

7. Comment style

We use traditional C-style /* */ comments and avoid // comments.

Rationale: The // form is valid in C99, so this is purely a matter of
consistency of style. The checkpatch script will warn you about this.

127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
Multiline comment blocks should have a row of stars on the left,
and the initial /* and terminating */ both on their own lines:
     * like
     * this
This is the same format required by the Linux kernel coding style.

(Some of the existing comments in the codebase use the GNU Coding
Standards form which does not have stars on the left, or other
variations; avoid these when writing new comments, but don't worry
about converting to the preferred form unless you're editing that
comment anyway.)

Rationale: Consistency, and ease of visually picking out a multiline
comment from the surrounding code.

144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
8. trace-events style

8.1 0x prefix

In trace-events files, use a '0x' prefix to specify hex numbers, as in:

some_trace(unsigned x, uint64_t y) "x 0x%x y 0x" PRIx64

An exception is made for groups of numbers that are hexadecimal by
convention and separated by the symbols '.', '/', ':', or ' ' (such as
PCI bus id):

another_trace(int cssid, int ssid, int dev_num) "bus id: %x.%x.%04x"

However, you can use '0x' for such groups if you want. Anyway, be sure that
it is obvious that numbers are in hex, ex.:

data_dump(uint8_t c1, uint8_t c2, uint8_t c3) "bytes (in hex): %02x %02x %02x"

Rationale: hex numbers are hard to read in logs when there is no 0x prefix,
especially when (occasionally) the representation doesn't contain any letters
and especially in one line with other decimal numbers. Number groups are allowed
to not use '0x' because for some things notations like %x.%x.%x are used not
only in Qemu. Also dumping raw data bytes with '0x' is less readable.

8.2 '#' printf flag

Do not use printf flag '#', like '%#x'.

Rationale: there are two ways to add a '0x' prefix to printed number: '0x%...'
and '%#...'. For consistency the only one way should be used. Arguments for
'0x%' are:
 - it is more popular
 - '%#' omits the 0x for the value 0 which makes output inconsistent