because a person can read code does not mean they will understand why
or what is being done. A reader may spend a lot more time figuring
out what is going on when a simple comment or explanation would have
- prevented the extra research. Please help your brother IJB'ers
- out!</p>
+ prevented the extra research. Please help your fellow Privoxy
+ developers out!</p>
<p>The comments will also help justify the intent of the code. If the
comment describes something different than what the code is doing
<td>
<pre class="PROGRAMLISTING">
/* if page size greater than 1k ... */
-if ( page_length() > 1024 )
+if (page_length() > 1024)
{
... "block" the page up ...
}
/* if page size is small, send it in blocks */
-if ( page_length() > 1024 )
+if (page_length() > 1024)
{
... "block" the page up ...
}
/*********************************************************************
* This will stand out clearly in your code!
*********************************************************************/
-if ( this_variable == that_variable )
+if (this_variable == that_variable)
{
do_something_very_important();
}
/* unfortunately, this may not */
-if ( this_variable == that_variable )
+if (this_variable == that_variable)
{
do_something_very_important();
}
-if ( this_variable == that_variable ) /* this may not either */
+if (this_variable == that_variable) /* this may not either */
{
do_something_very_important();
}
* This will stand out clearly in your code,
* But the second example won't.
*********************************************************************/
-if ( this_variable == this_variable )
+if (this_variable == this_variable)
{
do_something_very_important();
}
-if ( this_variable == this_variable ) /*can you see me?*/
+if (this_variable == this_variable) /*can you see me?*/
{
do_something_very_important(); /*not easily*/
}
int urls_read = 0; /* # of urls read + rejected */
int urls_rejected = 0; /* # of urls rejected */
-if ( 1 == X )
+if (1 == X)
{
do_something_very_important();
}
<tr>
<td>
<pre class="PROGRAMLISTING">
-if ( 1 == X )
+if (1 == X)
{
do_something_very_important();
...some long list of commands...
or:
-if ( 1 == X )
+if (1 == X)
{
do_something_very_important();
...some long list of commands...
-} /* -END- if ( 1 == X ) */
+} /* -END- if (1 == X) */
</pre>
</td>
</tr>
<tr>
<td>
<pre class="PROGRAMLISTING">
-int load_some_file( struct client_state *csp )
+int load_some_file(struct client_state *csp)
</pre>
</td>
</tr>
<tr>
<td>
<pre class="PROGRAMLISTING">
-int loadsomefile( struct client_state *csp )
-int loadSomeFile( struct client_state *csp )
+int loadsomefile(struct client_state *csp)
+int loadSomeFile(struct client_state *csp)
</pre>
</td>
</tr>
<tr>
<td>
<pre class="PROGRAMLISTING">
-(.h) extern int load_aclfile( struct client_state *csp );
-(.c) int load_aclfile( struct client_state *csp )
+(.h) extern int load_aclfile(struct client_state *csp);
+(.c) int load_aclfile(struct client_state *csp)
</pre>
</td>
</tr>
<tr>
<td>
<pre class="PROGRAMLISTING">
-(.h) extern int load_aclfile( struct client_state * ); or
+(.h) extern int load_aclfile(struct client_state *); or
(.h) extern int load_aclfile();
-(.c) int load_aclfile( struct client_state *csp )
+(.c) int load_aclfile(struct client_state *csp)
</pre>
</td>
</tr>
<tr>
<td>
<pre class="PROGRAMLISTING">
-(enumeration) : enum Boolean { FALSE, TRUE };
+(enumeration) : enum Boolean {FALSE, TRUE};
(#define) : #define DEFAULT_SIZE 100;
</pre>
</td>
<tr>
<td>
<pre class="PROGRAMLISTING">
-if ( this == that )
+if (this == that)
{
...
}
<p><span class="emphasis"><i class="EMPHASIS">Instead
of:</i></span></p>
- <p>if ( this == that ) { ... }</p>
+ <p>if (this == that) { ... }</p>
<p>or</p>
- <p>if ( this == that ) { ... }</p>
+ <p>if (this == that) { ... }</p>
<p><span class="emphasis"><i class="EMPHASIS">Note:</i></span> In the
special case that the if-statement is inside a loop, and it is
<tr>
<td>
<pre class="PROGRAMLISTING">
-while ( more lines are read )
+while (more lines are read)
{
/* Please document what is/is not a comment line here */
- if ( it's a comment ) continue;
+ if (it's a comment) continue;
- do_something( line );
+ do_something(line);
}
</pre>
</td>
<tr>
<td>
<pre class="PROGRAMLISTING">
-if ( this == that )
+if (this == that)
{
do_something();
do_something_else();
<p><span class="emphasis"><i class="EMPHASIS">Instead
of:</i></span></p>
- <p>if ( this == that ) do_something(); do_something_else();</p>
+ <p>if (this == that) do_something(); do_something_else();</p>
<p>or</p>
- <p>if ( this == that ) do_something();</p>
+ <p>if (this == that) do_something();</p>
<p><span class="emphasis"><i class="EMPHASIS">Note:</i></span> The
first example in "Instead of" will execute in a manner other than
<tr>
<td>
<pre class="PROGRAMLISTING">
-structure->flag = ( condition );
+structure->flag = (condition);
</pre>
</td>
</tr>
<p><span class="emphasis"><i class="EMPHASIS">Instead
of:</i></span></p>
- <p>if ( condition ) { structure->flag = 1; } else {
+ <p>if (condition) { structure->flag = 1; } else {
structure->flag = 0; }</p>
<p><span class="emphasis"><i class="EMPHASIS">Note:</i></span> The
int some_value = 0;
int another_value = 0;
int this_variable = 0;
-
-if ( this_variable == this_variable )
-
-first_value = old_value + ( ( some_value - another_value ) - whatever )
</pre>
</td>
</tr>
int function1( ... )
{
...code...
- return( ret_code );
+ return(ret_code);
-} /* -END- function1 */
+} /* -END- function1 */
int function2( ... )
{
-} /* -END- function2 */
+} /* -END- function2 */
</pre>
</td>
</tr>
<p><span class="emphasis"><i class="EMPHASIS">Instead
of:</i></span></p>
- <p>int function1( ... ) { ...code... return( ret_code ); } int
+ <p>int function1( ... ) { ...code... return(ret_code); } int
function2( ... ) { }</p>
<p><span class="emphasis"><i class="EMPHASIS">Note:</i></span> Use 1
int function1( ... )
{
- if ( 1 )
+ if (1)
{
- return( ALWAYS_TRUE );
+ return ALWAYS_TRUE;
}
else
{
- return( HOW_DID_YOU_GET_HERE );
+ return HOW_DID_YOU_GET_HERE;
}
- return( NEVER_GETS_HERE );
+ return NEVER_GETS_HERE;
}
</pre>
<tr>
<td>
<pre class="PROGRAMLISTING">
-for ( size_t cnt = 0; cnt < block_list_length(); cnt++ )
+for (size_t cnt = 0; cnt < block_list_length(); cnt++)
{
....
}
<pre class="PROGRAMLISTING">
size_t len = block_list_length();
-for ( size_t cnt = 0; cnt < len; cnt++ )
+for (size_t cnt = 0; cnt < len; cnt++)
{
....
}
<p>This allows a developer to define a const pointer and call your
function. If your function does not have the const keyword, we may
not be able to use your function. Consider strcmp, if it were defined
- as: extern int strcmp( char *s1, char *s2 );</p>
+ as: extern int strcmp(char *s1, char *s2);</p>
- <p>I could then not use it to compare argv's in main: int main( int
- argc, const char *argv[] ) { strcmp( argv[0], "privoxy" ); }</p>
+ <p>I could then not use it to compare argv's in main: int main(int
+ argc, const char *argv[]) { strcmp(argv[0], "privoxy"); }</p>
<p>Both these pointers are *const*! If the c runtime library
maintainers do it, we should too.</p>
<p>Most structures cannot fit onto a normal stack entry (i.e. they
are not 4 bytes or less). Aka, a function declaration like: int
- load_aclfile( struct client_state csp )</p>
+ load_aclfile(struct client_state csp)</p>
<p>would not work. So, to be consistent, we should declare all
- prototypes with "pass by value": int load_aclfile( struct
- client_state *csp )</p>
+ prototypes with "pass by value": int load_aclfile(struct client_state
+ *csp)</p>
</div>
<div class="SECT3">
<tr>
<td>
<pre class="PROGRAMLISTING">
-switch( hash_string( cmd ) )
+switch (hash_string(cmd))
{
- case hash_actions_file :
+ case hash_actions_file:
... code ...
break;
- case hash_confdir :
+ case hash_confdir:
... code ...
break;
- default :
+ default:
log_error( ... );
... anomaly code goes here ...
continue; / break; / exit( 1 ); / etc ...
-} /* end switch( hash_string( cmd ) ) */
+} /* end switch (hash_string(cmd)) */
</pre>
</td>
</tr>
</div>
<div class="SECT3">
- <h3 class="SECT3"><a name="S39" id="S39">4.7.4. Use 'long' or 'short'
- Instead of 'int'</a></h3>
-
- <p><span class="emphasis"><i class=
- "EMPHASIS">Explanation:</i></span></p>
-
- <p>On 32-bit platforms, int usually has the range of long. On 16-bit
- platforms, int has the range of short.</p>
-
- <p><span class="emphasis"><i class="EMPHASIS">Status:</i></span>
- open-to-debate. In the case of most FSF projects (including
- X/GNU-Emacs), there are typedefs to int4, int8, int16, (or
- equivalence ... I forget the exact typedefs now). Should we add these
- to IJB now that we have a "configure" script?</p>
- </div>
-
- <div class="SECT3">
- <h3 class="SECT3"><a name="S40" id="S40">4.7.5. Don't mix size_t and
+ <h3 class="SECT3"><a name="S40" id="S40">4.7.4. Don't mix size_t and
other types</a></h3>
<p><span class="emphasis"><i class=
</div>
<div class="SECT3">
- <h3 class="SECT3"><a name="S41" id="S41">4.7.6. Declare each variable
+ <h3 class="SECT3"><a name="S41" id="S41">4.7.5. Declare each variable
and struct on its own line.</a></h3>
<p><span class="emphasis"><i class=
</div>
<div class="SECT3">
- <h3 class="SECT3"><a name="S42" id="S42">4.7.7. Use malloc/zalloc
+ <h3 class="SECT3"><a name="S42" id="S42">4.7.6. Use malloc/zalloc
sparingly</a></h3>
<p><span class="emphasis"><i class=
</div>
<div class="SECT3">
- <h3 class="SECT3"><a name="S43" id="S43">4.7.8. The Programmer Who
+ <h3 class="SECT3"><a name="S43" id="S43">4.7.7. The Programmer Who
Uses 'malloc' is Responsible for Ensuring 'free'</a></h3>
<p><span class="emphasis"><i class=
<tr>
<td>
<pre class="PROGRAMLISTING">
-int load_re_filterfile( struct client_state *csp ) { ... }
-static void unload_re_filterfile( void *f ) { ... }
+int load_re_filterfile(struct client_state *csp) { ... }
+static void unload_re_filterfile(void *f) { ... }
</pre>
</td>
</tr>
</div>
<div class="SECT3">
- <h3 class="SECT3"><a name="S44" id="S44">4.7.9. Add loaders to the
+ <h3 class="SECT3"><a name="S44" id="S44">4.7.8. Add loaders to the
`file_list' structure and in order</a></h3>
<p><span class="emphasis"><i class=
</div>
<div class="SECT3">
- <h3 class="SECT3"><a name="S45" id="S45">4.7.10. "Uncertain" new code
- and/or changes to existing code, use FIXME or XXX</a></h3>
+ <h3 class="SECT3"><a name="S45" id="S45">4.7.9. "Uncertain" new code
+ and/or changes to existing code, use XXX</a></h3>
<p><span class="emphasis"><i class=
"EMPHASIS">Explanation:</i></span></p>
<p>If you have enough confidence in new code or confidence in your
changes, but are not *quite* sure of the repercussions, add this:</p>
- <p>/* FIXME: this code has a logic error on platform XYZ, *
- attempting to fix */ #ifdef PLATFORM ...changed code here...
- #endif</p>
+ <p>/* XXX: this code has a logic error on platform XYZ, * attempting
+ to fix */ #ifdef PLATFORM ...changed code here... #endif</p>
<p>or:</p>
- <p>/* FIXME: I think the original author really meant this... */
+ <p>/* XXX: I think the original author really meant this... */
...changed code here...</p>
<p>or:</p>
- <p>/* FIXME: new code that *may* break something else... */ ...new
- code here...</p>
+ <p>/* XXX: new code that *may* break something else... */ ...new code
+ here...</p>
<p><span class="emphasis"><i class="EMPHASIS">Note:</i></span> If you
make it clear that this may or may not be a "good thing (tm)", it
<tr>
<td>
<pre class="PROGRAMLISTING">
-const char FILENAME_rcs[] = "$Id$";
+const char FILENAME_rcs[] = "$I<!-- Break CVS Substitution -->d$";
/*********************************************************************
*
- * File : $Source$
+ * File : $S<!-- Break CVS Substitution -->ource$
*
* Purpose : (Fill me in with a good description!)
*
<pre class="PROGRAMLISTING">
#ifndef _FILENAME_H
#define _FILENAME_H
-#define FILENAME_H_VERSION "$Id$"
+#define FILENAME_H_VERSION "$I<!-- Break CVS Substitution -->d$"
/*********************************************************************
*
- * File : $Source$
+ * File : $S<!-- Break CVS Substitution -->ource$
*
* Purpose : (Fill me in with a good description!)
*
* Returns : 0 => Ok, everything else is an error.
*
*********************************************************************/
-int FUNCTION_NAME( void *param1, const char *x )
+int FUNCTION_NAME(void *param1, const char *x)
{
...
- return( 0 );
+ return 0;
}
</pre>
projects / privoxy.git / blobdiff