


  1. QEMU Coding Style
  3. Please use the script in the scripts directory to check
  4. patches before submitting.
  5. 1. Whitespace
  6. Of course, the most important aspect in any coding style is whitespace.
  7. Crusty old coders who have trouble spotting the glasses on their noses
  8. can tell the difference between a tab and eight spaces from a distance
  9. of approximately fifteen parsecs. Many a flamewar has been fought and
  10. lost on this issue.
  11. QEMU indents are four spaces. Tabs are never used, except in Makefiles
  12. where they have been irreversibly coded into the syntax.
  13. Spaces of course are superior to tabs because:
  14. - You have just one way to specify whitespace, not two. Ambiguity breeds
  15. mistakes.
  17. - Tab indents push your code to the right, making your screen seriously
  18. unbalanced.
  19. - Tabs will be rendered incorrectly on editors who are misconfigured not
  20. to use tab stops of eight positions.
  22. every line.
  23. - It is the QEMU coding style.
  24. Do not leave whitespace dangling off the ends of lines.
  25. 1.1 Multiline Indent
  26. There are several places where indent is necessary:
  27. - if/else
  28. - while/for
  29. - function definition & call
  30. When breaking up a long line to fit within line width, we need a proper indent
  31. for the following lines.
  32. In case of if/else, while/for, align the secondary lines just after the
  33. opening parenthesis of the first.
  34. For example:
  35. if (a == 1 &&
  36. b == 2) {
  37. while (a == 1 &&
  38. b == 2) {
  39. In case of function, there are several variants:
  40. * 4 spaces indent from the beginning
  41. * align the secondary lines just after the opening parenthesis of the
  42. first
  43. For example:
  44. do_something(x, y,
  45. z);
  46. do_something(x, y,
  47. z);
  48. do_something(x, do_another(y,
  49. z));
  50. 2. Line width
  51. Lines should be 80 characters; try not to make them longer.
  52. Sometimes it is hard to do, especially when dealing with QEMU subsystems
  53. that use long function or symbol names. Even in that case, do not make
  54. lines much longer than 80 characters.
  55. Rationale:
  56. - Some people like to tile their 24" screens with a 6x4 matrix of 80x24
  57. xterms and use vi in all of them. The best way to punish them is to
  58. let them keep doing it.
  59. - Code and especially patches is much more readable if limited to a sane
  60. line length. Eighty is traditional.
  61. - The four-space indentation makes the most common excuse ("But look
  62. at all that white space on the left!") moot.
  63. - It is the QEMU coding style.
  64. 3. Naming
  65. Variables are lower_case_with_underscores; easy to type and read. Structured
  66. type names are in CamelCase; harder to type but standing out. Enum type
  67. names and function type names should also be in CamelCase. Scalar type
  68. names are lower_case_with_underscores_ending_with_a_t, like the POSIX
  69. uint64_t and family. Note that this last convention contradicts POSIX
  70. and is therefore likely to be changed.
  71. When wrapping standard library functions, use the prefix qemu_ to alert
  72. readers that they are seeing a wrapped version; otherwise avoid this prefix.
  73. 4. Block structure
  74. Every indented statement is braced; even if the block contains just one
  75. statement. The opening brace is on the line that contains the control
  76. flow statement that introduces the new block; the closing brace is on the
  77. same line as the else keyword, or on a line by itself if there is no else
  78. keyword. Example:
  79. if (a == 5) {
  80. printf("a was 5.\n");
  81. } else if (a == 6) {
  82. printf("a was 6.\n");
  83. } else {
  84. printf("a was something else entirely.\n");
  85. }
  86. Note that 'else if' is considered a single statement; otherwise a long if/
  87. else if/else if/.../else sequence would need an indent for every else
  88. statement.
  89. An exception is the opening brace for a function; for reasons of tradition
  90. and clarity it comes on a line by itself:
  91. void a_function(void)
  92. {
  93. do_something();
  94. }
  95. Rationale: a consistent (except for functions...) bracing style reduces
  96. ambiguity and avoids needless churn when lines are added or removed.
  97. Furthermore, it is the QEMU coding style.
  98. 5. Declarations
  99. Mixed declarations (interleaving statements and declarations within
  100. blocks) are generally not allowed; declarations should be at the beginning
  101. of blocks.
  102. Every now and then, an exception is made for declarations inside a
  103. #ifdef or #ifndef block: if the code looks nicer, such declarations can
  104. be placed at the top of the block even if there are statements above.
  106. block to a separate function altogether.
  107. 6. Conditional statements
  108. When comparing a variable for (in)equality with a constant, list the
  109. constant on the right, as in:
  110. if (a == 1) {
  111. /* Reads like: "If a equals 1" */
  112. do_something();
  113. }
  116. even when the constant is on the right.
  117. 7. Comment style
  118. We use traditional C-style /* */ comments and avoid // comments.
  120. consistency of style. The checkpatch script will warn you about this.
  121. Multiline comment blocks should have a row of stars on the left,
  122. and the initial /* and terminating */ both on their own lines:
  123. /*
  124. * like
  125. * this
  126. */
  127. This is the same format required by the Linux kernel coding style.
  128. (Some of the existing comments in the codebase use the GNU Coding
  129. Standards form which does not have stars on the left, or other
  130. variations; avoid these when writing new comments, but don't worry
  131. about converting to the preferred form unless you're editing that
  132. comment anyway.)
  133. Rationale: Consistency, and ease of visually picking out a multiline
  134. comment from the surrounding code.
  135. 8. trace-events style
  136. 8.1 0x prefix
  137. In trace-events files, use a '0x' prefix to specify hex numbers, as in:
  138. some_trace(unsigned x, uint64_t y) "x 0x%x y 0x" PRIx64
  139. An exception is made for groups of numbers that are hexadecimal by
  141. PCI bus id):
  143. However, you can use '0x' for such groups if you want. Anyway, be sure that
  144. it is obvious that numbers are in hex, ex.:
  146. Rationale: hex numbers are hard to read in logs when there is no 0x prefix,
  147. especially when (occasionally) the representation doesn't contain any letters
  148. and especially in one line with other decimal numbers. Number groups are allowed
  150. only in Qemu. Also dumping raw data bytes with '0x' is less readable.
  151. 8.2 '#' printf flag
  152. Do not use printf flag '#', like '%#x'.
  155. '0x%' are:
  156. - it is more popular
  157. - '%#' omits the 0x for the value 0 which makes output inconsistent