4 This document describes the coding style conventions used in Busybox. If you
5 add a new file to Busybox or are editing an existing file, please format your
6 code according to this style. If you are the maintainer of a file that does
7 not follow these guidelines, please -- at your own convenience -- modify the
8 file(s) you maintain to bring them into conformance with this style guide.
9 Please note that this is a low priority task.
11 To help you format the whitespace of your programs, an ".indent.pro" file is
12 included in the main Busybox source directory that contains option flags to
13 format code as per this style guide. This way you can run GNU indent on your
14 files by typing 'indent myfile.c myfile.h' and it will magically apply all the
15 right formatting rules to your file. Please _do_not_ run this on all the files
16 in the directory, just your own.
23 Here is the order in which code should be laid out in a file:
25 - commented program name and one-line description
26 - commented author name and email address(es)
27 - commented GPL boilerplate
28 - commented longer description / notes for the program (if needed)
29 - #includes and #defines
30 - const and global variables
31 - function declarations (if necessary)
32 - function implementations
36 Whitespace and Formatting
37 -------------------------
39 This is everybody's favorite flame topic so let's get it out of the way right
43 Tabs vs. Spaces in Line Indentation
44 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
46 The preference in Busybox is to indent lines with tabs. Do not indent lines
47 with spaces and do not indents lines using a mixture of tabs and spaces. (The
48 indentation style in the Apache and Postfix source does this sort of thing:
49 \s\s\s\sif (expr) {\n\tstmt; --ick.) The only exception to this rule is
50 multi-line comments that use an asterisk at the beginning of each line, i.e.:
53 /t * This is a block comment.
54 /t * Note that it has multiple lines
55 /t * and that the beginning of each line has a tab plus a space
56 /t * except for the opening '/*' line where the slash
57 /t * is used instead of a space.
60 Furthermore, The preference is that tabs be set to display at four spaces
61 wide, but the beauty of using only tabs (and not spaces) at the beginning of
62 lines is that you can set your editor to display tabs at *whatever* number of
63 spaces is desired and the code will still look fine.
69 Put spaces between terms and operators. Example:
73 for(i=0;i<num_items;i++){
77 for (i = 0; i < num_items; i++) {
79 While it extends the line a bit longer, the spaced version is more
80 readable. An allowable exception to this rule is the situation where
81 excluding the spacing makes it more obvious that we are dealing with a
82 single term (even if it is a compound term) such as:
84 if (str[idx] == '/' && str[idx-1] != '\\')
88 if ((argc-1) - (optind+1) > 0)
94 If an opening bracket starts a function, it should be on the
95 next line with no spacing before it. However, if a bracket follows an opening
96 control block, it should be on the same line with a single space (not a tab)
97 between it and the opening control block statement. Examples:
107 Don't do this either:
121 Put a space between C keywords and left parens, but not between
122 function names and the left paren that starts it's parameter list (whether it
123 is being declared or called). Examples:
128 for(i = 0; i < n; i++) {
133 for (i = 0; i < n; i++) {
135 But do functions like this:
137 static int my_func(int foo, char bar)
145 Also, please "cuddle" your else statements by putting the else keyword on the
146 same line after the right bracket that closes an 'if' statement.
165 The exception to this rule is if you want to include a comment before the else
171 /* otherwise, we're just kidding ourselves, so re-frob the input */
178 Variable and Function Names
179 ---------------------------
181 Use the K&R style with names in all lower-case and underscores occasionally
182 used to separate words (e.g., "variable_name" and "numchars" are both
183 acceptable). Using underscores makes variable and function names more readable
184 because it looks like whitespace; using lower-case is easy on the eyes.
186 Note: The Busybox codebase is very much a mixture of code gathered from a
187 variety of sources. This explains why the current codebase contains such a
188 hodge-podge of different naming styles (Java, Pascal, K&R, just-plain-weird,
189 etc.). The K&R guideline explained above should therefore be used on new files
190 that are added to the repository. Furthermore, the maintainer of an existing
191 file that uses alternate naming conventions should -- at his own convenience --
192 convert those names over to K&R style; converting variable names is a very low
193 priority task. Perhaps in the future we will include some magical Perl script
194 that can go through and convert files -- left as an exercise to the reader for
199 Avoid The Preprocessor
200 ----------------------
202 At best, the preprocessor is a necessary evil, helping us account for platform
203 and architecture differences. Using the preprocessor unnecessarily is just
210 Use 'const <type> var' for declaring constants.
216 Do this instead, when the variable is in a header file and will be used in
217 several source files:
221 Or do this when the variable is used only in a single source file:
223 static const int var = 80;
225 Declaring variables as '[static] const' gives variables an actual type and
226 makes the compiler do type checking for you; the preprocessor does _no_ type
227 checking whatsoever, making it much more error prone. Declaring variables with
228 '[static] const' also makes debugging programs much easier since the value of
229 the variable can be easily queried and displayed.
235 Use 'static inline' instead of a macro.
239 #define mini_func(param1, param2) (param1 << param2)
243 static inline int mini_func(int param1, param2)
245 return (param1 << param2);
248 Static inline functions are greatly preferred over macros. They provide type
249 safety, have no length limitations, no formatting limitations, and under gcc
250 they are as cheap as macros. Besides, really long macros with backslashes at
251 the end of each line are ugly as sin.
257 Code cluttered with ifdefs is difficult to read and maintain. Don't do it.
258 Instead, put your ifdefs in a header, and conditionally define 'static inline'
259 functions, (or *maybe* macros), which are used in the code.
263 ret = my_func(bar, baz);
266 #ifdef BB_FEATURE_FUNKY
267 maybe_do_funky_stuff(bar, baz);
274 #ifndef BB_FEATURE_FUNKY
275 static inline void maybe_do_funky_stuff (int bar, int baz) {}
278 (in the .c source file)
280 ret = my_func(bar, baz);
283 maybe_do_funky_stuff(bar, baz);
285 The great thing about this approach is that the compiler will optimize away
286 the "no-op" case when the feature is turned off.
288 Note also the use of the word 'maybe' in the function name to indicate
289 conditional execution.
296 Strings in C can get a little thorny. Here's some guidelines for dealing with
297 strings in Busybox. (There is surely more that could be added to this
304 Put all help/usage messages in usage.c. Put other strings in messages.c.
305 Putting these strings into their own file is a calculated decision designed to
306 confine spelling errors to a single place and aid internationalization
307 efforts, if needed. (Side Note: we might want to use a single file - maybe
308 called 'strings.c' - instead of two, food for thought).
311 Testing String Equivalence
312 ~~~~~~~~~~~~~~~~~~~~~~~~~~
314 There's a right way and a wrong way to test for sting equivalence with
319 if (!strcmp(string, "foo")) {
324 if (strcmp(string, "foo") == 0){
327 The use of the "equals" (==) operator in the latter example makes it much more
328 obvious that you are testing for equivalence. The former example with the
329 "not" (!) operator makes it look like you are testing for an error. In a more
330 perfect world, we would have a streq() function in the string library, but
331 that ain't the world we're living in.
335 Miscellaneous Coding Guidelines
336 -------------------------------
338 The following are important items that don't fit into any of the above
342 Model Busybox Applets After GNU Counterparts
343 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
345 When in doubt about the proper behavior of a Busybox program (output,
346 formatting, options, etc.), model it after the equivalent GNU program.
347 Doesn't matter how that program behaves on some other flavor of *NIX; doesn't
348 matter what the POSIX standard says or doesn't say, just model Busybox
349 programs after their GNU counterparts and nobody has to get hurt.
351 The only time we deviate from emulating the GNU behavior is when:
353 - We are deliberately not supporting a feature (such as a command line
355 - Emulating the GNU behavior is prohibitively expensive (lots more code
356 would be required, lots more memory would be used, etc.)
357 - The differce is minor or cosmetic
359 A note on the 'cosmetic' case: Output differences might be considered
360 cosmetic, but if the output is significant enough to break other scripts that
361 use the output, it should really be fixed.
367 If a const variable is used only in a single source file, put it in the source
368 file and not in a header file. Likewise, if a const variable is used in only
369 one function, do not make it global to the file. Instead, declare it inside
370 the function body. Bottom line: Make a concious effort to limit declarations
371 to the smallest scope possible.
373 Inside applet files, all functions should be declared static so as to keep the
374 global name space clean. The only exception to this rule is the "applet_main"
375 function which must be declared extern.
377 If you write a function that performs a task that could be useful outside the
378 immediate file, turn it into a general-purpose function with no ties to any
379 applet and put it in the utility.c file instead.
382 Brackets Are Your Friends
383 ~~~~~~~~~~~~~~~~~~~~~~~~~
385 Please use brackets on all if and else statements, even if it is only one
403 The "bracketless" approach is error prone because someday you might add a line
412 And the resulting behavior of your program would totally bewilder you. (Don't
413 laugh, it happens to us all.) Remember folks, this is C, not Python.
416 Function Declarations
417 ~~~~~~~~~~~~~~~~~~~~~
419 Do not use old-style function declarations that declare variable types between
420 the parameter list and opening bracket. Example:
424 int foo(parm1, parm2)
432 int foo(char parm1, float parm2)
436 The only time you would ever need to use the old declaration syntax is to
437 support ancient, antedeluvian compilers. To our good fortune, we have access
438 to more modern compilers and the old declaration syntax is neither necessary