Declaration Order
-----------------
-Here is the order in which code should be laid out in a file:
+Here is the preferred order in which code should be laid out in a file:
- commented program name and one-line description
- commented author name and email address(es)
\s\s\s\sif (expr) {\n\tstmt; --ick.) The only exception to this rule is
multi-line comments that use an asterisk at the beginning of each line, i.e.:
- /t/*
- /t * This is a block comment.
- /t * Note that it has multiple lines
- /t * and that the beginning of each line has a tab plus a space
- /t * except for the opening '/*' line where the slash
- /t * is used instead of a space.
- /t */
+ \t/*
+ \t * This is a block comment.
+ \t * Note that it has multiple lines
+ \t * and that the beginning of each line has a tab plus a space
+ \t * except for the opening '/*' line where the slash
+ \t * is used instead of a space.
+ \t */
Furthermore, The preference is that tabs be set to display at four spaces
wide, but the beauty of using only tabs (and not spaces) at the beginning of
do {
+If you have long logic statements that need to be wrapped, then uncuddling
+the bracket to improve readability is allowed. Generally, this style makes
+it easier for reader to notice that 2nd and following lines are still
+inside 'if':
+
+ if (some_really_long_checks && some_other_really_long_checks
+ && some_more_really_long_checks
+ && even_more_of_long_checks
+ ) {
+ do_foo_now;
Spacing around Parentheses
~~~~~~~~~~~~~~~~~~~~~~~~~~
}
+Labels
+~~~~~~
+
+Labels should start at the beginning of the line, not indented to the block
+level (because they do not "belong" to block scope, only to whole function).
+
+ if (foo) {
+ stmt;
+ label:
+ stmt2;
+ stmt;
+ }
+
+(Putting label at position 1 prevents diff -p from confusing label for function
+name, but it's not a policy of busybox project to enforce such a minor detail).
+
+
Variable and Function Names
---------------------------
Exceptions:
- Enums, macros, and constant variables are occasionally written in all
- upper-case with words optionally seperatedy by underscores (i.e. FIFOTYPE,
+ upper-case with words optionally separated by underscores (i.e. FIFO_TYPE,
ISBLKDEV()).
- Nobody is going to get mad at you for using 'pvar' as the name of a
Don't do this:
- #define var 80
+ #define CONST 80
Do this instead, when the variable is in a header file and will be used in
several source files:
- const int var = 80;
-
- Or do this when the variable is used only in a single source file:
+ enum { CONST = 80 };
- static const int var = 80;
-
-Declaring variables as '[static] const' gives variables an actual type and
-makes the compiler do type checking for you; the preprocessor does _no_ type
-checking whatsoever, making it much more error prone. Declaring variables with
-'[static] const' also makes debugging programs much easier since the value of
-the variable can be easily queried and displayed.
+Although enum may look ugly to some people, it is better for code size.
+With "const int" compiler may fail to optimize it out and will reserve
+a real storage in rodata for it! (Hopefully, newer gcc will get better
+at it...). With "define", you have slight risk of polluting namespace
+(#define doesn't allow you to redefine the name in the inner scopes),
+and complex "define" are evaluated each time they used, not once
+at declarations like enums. Also, the preprocessor does _no_ type checking
+whatsoever, making it much more error prone.
The Folly of Macros
(in .h header file)
- #ifdef CONFIG_FEATURE_FUNKY
- static inline void maybe_do_funky_stuff (int bar, int baz)
+ #if ENABLE_FEATURE_FUNKY
+ static inline void maybe_do_funky_stuff(int bar, int baz)
{
/* lotsa code in here */
}
#else
- static inline void maybe_do_funky_stuff (int bar, int baz) {}
+ static inline void maybe_do_funky_stuff(int bar, int baz) {}
#endif
(in the .c source file)
Testing String Equivalence
~~~~~~~~~~~~~~~~~~~~~~~~~~
-There's a right way and a wrong way to test for sting equivalence with
+There's a right way and a wrong way to test for string equivalence with
strcmp():
The wrong way:
certain library functions are (mis)used. The following table offers a summary
of some of the more notorious troublemakers:
-function overflows preferred
-----------------------------------------
-strcpy dest string strncpy
-strcat dest string strncat
-gets string it gets fgets
-getwd buf string getcwd
-[v]sprintf str buffer [v]snprintf
-realpath path buffer use with pathconf
-[vf]scanf its arguments just avoid it
+function overflows preferred
+-------------------------------------------------
+strcpy dest string safe_strncpy
+strncpy may fail to 0-terminate dst safe_strncpy
+strcat dest string strncat
+gets string it gets fgets
+getwd buf string getcwd
+[v]sprintf str buffer [v]snprintf
+realpath path buffer use with pathconf
+[vf]scanf its arguments just avoid it
The above is by no means a complete list. Be careful out there.
Avoid Big Static Buffers
------------------------
-First, some background to put this discussion in context: Static buffers look
+First, some background to put this discussion in context: static buffers look
like this in code:
/* in a .c file outside any functions */
- static char *buffer[BUFSIZ]; /* happily used by any function in this file,
+ static char buffer[BUFSIZ]; /* happily used by any function in this file,
but ick! big! */
The problem with these is that any time any busybox app is run, you pay a
and the right thing will happen, based on your configuration.
+Another relatively new trick of similar nature is explained
+in keep_data_small.txt.
+
Miscellaneous Coding Guidelines
would be required, lots more memory would be used, etc.)
- The difference is minor or cosmetic
-A note on the 'cosmetic' case: Output differences might be considered
+A note on the 'cosmetic' case: output differences might be considered
cosmetic, but if the output is significant enough to break other scripts that
use the output, it should really be fixed.
if (foo)
stmt1;
new_line();
- stmt2
+ stmt2;
stmt3;
And the resulting behavior of your program would totally bewilder you. (Don't
Furthermore, you should put a single comment (not necessarily one line, just
one comment) before the block, rather than commenting each and every line.
-There is an optimal ammount of commenting that a program can have; you can
+There is an optimal amount of commenting that a program can have; you can
comment too much as well as too little.
A picture is really worth a thousand words here, the following example
illustrates how to emphasize logical blocks:
- while (line = get_line_from_file(fp)) {
+ while (line = xmalloc_fgets(fp)) {
/* eat the newline, if any */
chomp(line);
Processing Options with getopt
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-If your applet needs to process command-line switches, please use getopt() to
+If your applet needs to process command-line switches, please use getopt32() to
do so. Numerous examples can be seen in many of the existing applets, but
basically it boils down to two things: at the top of the .c file, have this
-line in the midst of your #includes:
+line in the midst of your #includes, if you need to parse long options:
#include <getopt.h>
+Then have long options defined:
+
+ static const char <applet>_longopts[] ALIGN1 =
+ "list\0" No_argument "t"
+ "extract\0" No_argument "x"
+ ;
+
And a code block similar to the following near the top of your applet_main()
routine:
- while ((opt = getopt(argc, argv, "abc")) > 0) {
- switch (opt) {
- case 'a':
- do_a_opt = 1;
- break;
- case 'b':
- do_b_opt = 1;
- break;
- case 'c':
- do_c_opt = 1;
- break;
- default:
- show_usage(); /* in utility.c */
- }
- }
+ char *str_b;
+
+ opt_complementary = "cryptic_string";
+ applet_long_options = <applet>_longopts; /* if you have them */
+ opt = getopt32(argc, argv, "ab:c", &str_b);
+ if (opt & 1) {
+ handle_option_a();
+ }
+ if (opt & 2) {
+ handle_option_b(str_b);
+ }
+ if (opt & 4) {
+ handle_option_c();
+ }
If your applet takes no options (such as 'init'), there should be a line
somewhere in the file reads:
That way, when people go grepping to see which applets need to be converted to
use getopt, they won't get false positives.
-Additional Note: Do not use the getopt_long library function and do not try to
-hand-roll your own long option parsing. Busybox applets should only support
-short options. Explanations and examples of the short options should be
-documented in usage.h.
+For more info and examples, examine getopt32.c, tar.c, wget.c etc.