Busybox Style Guide===================This document describes the coding style conventions used in Busybox. If youadd a new file to Busybox or are editing an existing file, please format yourcode according to this style. If you are the maintainer of a file that doesnot follow these guidelines, please -- at your own convenience -- modify thefile(s) you maintain to bring them into conformance with this style guide.Please note that this is a low priority task.To help you format the whitespace of your programs, an ".indent.pro" file isincluded in the main Busybox source directory that contains option flags toformat code as per this style guide. This way you can run GNU indent on yourfiles by typing 'indent myfile.c myfile.h' and it will magically apply all theright formatting rules to your file. Please _do_not_ run this on all the filesin the directory, just your own.Declaration Order-----------------Here is the 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) - commented GPL boilerplate - commented longer description / notes for the program (if needed) - #includes of .h files with angle brackets (<>) around them - #includes of .h files with quotes ("") around them - #defines (if any, note the section below titled "Avoid the Preprocessor") - const and global variables - function declarations (if necessary) - function implementationsWhitespace and Formatting-------------------------This is everybody's favorite flame topic so let's get it out of the way rightup front.Tabs vs. Spaces in Line Indentation~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~The preference in Busybox is to indent lines with tabs. Do not indent lineswith spaces and do not indents lines using a mixture of tabs and spaces. (Theindentation style in the Apache and Postfix source does this sort of thing:\s\s\s\sif (expr) {\n\tstmt; --ick.) The only exception to this rule ismulti-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 */Furthermore, The preference is that tabs be set to display at four spaceswide, but the beauty of using only tabs (and not spaces) at the beginning oflines is that you can set your editor to display tabs at *whatever* number ofspaces is desired and the code will still look fine.Operator Spacing~~~~~~~~~~~~~~~~Put spaces between terms and operators. Example:	Don't do this:		for(i=0;i<num_items;i++){	Do this instead:		for (i = 0; i < num_items; i++) {	While it extends the line a bit longer, the spaced version is more	readable. An allowable exception to this rule is the situation where	excluding the spacing makes it more obvious that we are dealing with a	single term (even if it is a compound term) such as:		if (str[idx] == '/' && str[idx-1] != '\\')	or		if ((argc-1) - (optind+1) > 0)Bracket Spacing~~~~~~~~~~~~~~~If an opening bracket starts a function, it should be on thenext line with no spacing before it. However, if a bracket follows an openingcontrol block, it should be on the same line with a single space (not a tab)between it and the opening control block statement. Examples:	Don't do this:		while (!done)		{		do		{	Don't do this either:		while (!done){		do{	And for heaven's sake, don't do this:		while (!done)		  {		do		  {	Do this instead:		while (!done) {		do {Spacing around Parentheses~~~~~~~~~~~~~~~~~~~~~~~~~~Put a space between C keywords and left parens, but not between function namesand the left paren that starts it's parameter list (whether it is beingdeclared or called). Examples:	Don't do this:		while(foo) {		for(i = 0; i < n; i++) {	Do this instead:		while (foo) {		for (i = 0; i < n; i++) {	But do functions like this:		static int my_func(int foo, char bar)		...		baz = my_func(1, 2);Also, don't put a space between the left paren and the first term, nor betweenthe last arg and the right paren.	Don't do this:		if ( x < 1 )		strcmp( thisstr, thatstr )	Do this instead:		if (x < 1)		strcmp(thisstr, thatstr)Cuddled Elses~~~~~~~~~~~~~Also, please "cuddle" your else statements by putting the else keyword on thesame line after the right bracket that closes an 'if' statement.	Don't do this:	if (foo) {		stmt;	}	else {		stmt;	}	Do this instead:	if (foo) {		stmt;	} else {		stmt;	}The exception to this rule is if you want to include a comment before the elseblock. Example:	if (foo) {		stmts...	}	/* otherwise, we're just kidding ourselves, so re-frob the input */	else {		other_stmts...	}Variable and Function Names---------------------------Use the K&R style with names in all lower-case and underscores occasionallyused to separate words (e.g., "variable_name" and "numchars" are bothacceptable). Using underscores makes variable and function names more readablebecause it looks like whitespace; using lower-case is easy on the eyes.	Frowned upon:		hitList		TotalChars		szFileName		pf_Nfol_TriState	Preferred:		hit_list		total_chars		file_name		sensible_nameExceptions: - Enums, macros, and constant variables are occasionally written in all   upper-case with words optionally seperatedy by underscores (i.e. FIFOTYPE,   ISBLKDEV()). - Nobody is going to get mad at you for using 'pvar' as the name of a   variable that is a pointer to 'var'.Converting to K&R~~~~~~~~~~~~~~~~~The Busybox codebase is very much a mixture of code gathered from a variety ofsources. This explains why the current codebase contains such a hodge-podge ofdifferent naming styles (Java, Pascal, K&R, just-plain-weird, etc.). The K&Rguideline explained above should therefore be used on new files that are addedto the repository. Furthermore, the maintainer of an existing file that usesalternate naming conventions should, at his own convenience, convert thosenames over to K&R style. Converting variable names is a very low prioritytask.If you want to do a search-and-replace of a single variable name in differentfiles, you can do the following in the busybox directory:	$ perl -pi -e 's/\bOldVar\b/new_var/g' *.[ch]If you want to convert all the non-K&R vars in your file all at once, followthese steps: - In the busybox directory type 'scripts/mk2knr.pl files-to-convert'. This   does not do the actual conversion, rather, it generates a script called   'convertme.pl' that shows what will be converted, giving you a chance to   review the changes beforehand. - Review the 'convertme.pl' script that gets generated in the busybox   directory and remove / edit any of the substitutions in there. Please   especially check for false positives (strings that should not be   converted). - Type './convertme.pl same-files-as-before' to perform the actual   conversion. - Compile and see if everything still works. Please be aware of changes that have cascading effects into other files. Forexample, if you're changing the name of something in, say utility.c, youshould probably run 'scripts/mk2knr.pl utility.c' at first, but when you runthe 'convertme.pl' script you should run it on _all_ files like so:'./convertme.pl *.[ch]'.Avoid The Preprocessor----------------------At best, the preprocessor is a necessary evil, helping us account for platformand architecture differences. Using the preprocessor unnecessarily is justplain evil.The Folly of #define~~~~~~~~~~~~~~~~~~~~Use 'const <type> var' for declaring constants.	Don't do this:		#define var 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:		static const int var = 80; Declaring variables as '[static] const' gives variables an actual type andmakes the compiler do type checking for you; the preprocessor does _no_ typechecking whatsoever, making it much more error prone. Declaring variables with'[static] const' also makes debugging programs much easier since the value ofthe variable can be easily queried and displayed.The Folly of Macros~~~~~~~~~~~~~~~~~~~Use 'static inline' instead of a macro.	Don't do this:		#define mini_func(param1, param2) (param1 << param2)	Do this instead:		static inline int mini_func(int param1, param2)		{			return (param1 << param2);		}Static inline functions are greatly preferred over macros. They provide typesafety, have no length limitations, no formatting limitations, have an actualreturn value, and under gcc they are as cheap as macros. Besides, really longmacros with backslashes at the end of each line are ugly as sin.The Folly of #ifdef~~~~~~~~~~~~~~~~~~~Code cluttered with ifdefs is difficult to read and maintain. Don't do it.Instead, put your ifdefs at the top of your .c file (or in a header), andconditionally define 'static inline' functions, (or *maybe* macros), which areused in the code.  	Don't do this: