• Use ANSI C style; not K&R
• Do not decorate types (i.e. use char ∗s, not char∗ s).
• put else if on a single line
• use sizeof(variable) instead of sizeof(typeofvariable) so that a change in the type of variable doesn't require a change in the use of sizeof
• when allocating space for an object, use sizeof(*pointer_to_object) rather than sizeof(object_type) to allow type change flexibility
• match a program's usage statement to its man page's SYNOPSIS
• if a variable can take on a limited number of values, or a function can return a limited number of values, choose enum rather than #define for that limited set
• use strtok_r() rather than strtok() (even on Windows -- PBS's win.h header file redefines strtok_r to use strtok_s on Windows platforms)
• when you discover non-ANSI-compliant code, fix it
• use const whenever appropriate
• You don't need braces for single statements

Macros

• Make macro names all upper-case
• Always parenthesize macro arguments in definitions
• If a macro's definition could affect code flow (for example, it expands to either multiple statements or none), surround its use with braces
• Use #define and macros constructively
• Some naming guidelines may lead to long names, and crazily long lines of code. You can shorten unions within structures via #define constructs.
• You can improve code readability with macros.  Compare these

and

Comments

• Use correct grammar, punctuation, and spelling
• Don't use C++ style comments (i.e. / /)
• indent the opening / of a comment to the same level as the code to which it applies

Multiline Comments

• start a multiline comment with /*, indented to the same level as the code to which it applies
• continue each line with a * aligned with the initial *
• end with a */ on a line by itself

Doxygen Comments

• Write a doxygen block comment just before the definition of a function describing:
  • what the function does
  • function parameters
  • function return values

• use helpful function and variable naming, e.g. "can_run_job(pjob)" instead of "check_job(pjob)"
• use lower case and _ in symbol names rather than "camelCase"
  
• if it makes sense, use a similar naming convention for related enum and #define
• Put items after "enum" and "#define" in uppercase
• Use a distinctive prefix for enum and #define
• avoid the Windows (i.e. Hungarian) style of naming variables; do not encode length or type information in the name

Prefixes and Suffixes in Names

• use the pbs_ prefix for public interfaces
• use an _t suffix when defining a typedef
• use an _g suffix when defining a global
• when sensible, start names of pointers with p
• denote temporary variables with a tmp suffix or prefix

Naming Typedefs

• Right:

  struct foo {         ... }; typedef struct foo foo_t;

Naming Structure and Union Members 

• Right:

  struct a {         unsigned int    a_flags;         unsigned int    a_type; };

  Wrong:

  struct a {         unsigned int    flags;         unsigned int    type; };

Looping

• Do not disguise for loops as while loops; write infinite loops using for (;;) rather than while (1).
  

  Right:

  for (ptask = (struct work_task *)GET_NEXT(task_list_event);ptask;      ptask = (struct work_task *)GET_NEXT(ptask->wt_linkall))

  Wrong:

  ptask = (struct work_task *)GET_NEXT(task_list_event); while (ptask) {         ...         ptask = (struct work_task *)GET_NEXT(ptask->wt_linkall); }

• In the following, the while statement is a red herring.  This is really a for loop and should be written that way

  
  

  i = 1; while (i < 10) {         printf("hello, world\n");         i += 1; }

Indentation

• Use leading tabs, not spaces, for indentation (it's easier to customize tabs to your personal style)

Braces and Parentheses

• make sure braces, parentheses, etc. match, even in the presence of preprocessor directives
• Use parentheses anywhere it makes it easier for the reader

• end text files with a newline
• use UNIX-style (\n) line termination rather than DOS-style (\r\n). Check this yourself; do not rely on tools of a source code management system to do this for you.

White Space

• put spaces after keywords (e.g. do, for, while, return, switch) but not after function names, sizeof, casts, or parentheses. 
• place one space on either side of the ‘=’ when assigning variable values, and for operations including '&&', ‘+’, ‘*’, ‘<’, ‘>’, etc.
• do not end lines with white space
• do not use white space between function names and arguments or around references and dereferences (&, ., *, ->) or parentheses
• do not try to align variable names or types with whitespace when declaring multiple variables. Use a single space between variable names and types.
• do not use spaces between increment/decrement operators or pointer operations such as ‘*’, ‘&’ and ‘->’.

Examples of Braces and White Spaces

• Right:

  do {         ... } while (<conditional>);

  
  

  for (;;) {         ... }

  
  

  switch (<expression>) { case 1:         ...         break; case 2:         ...         break; }

Balance Braces and Parentheses

• Use parentheses anywhere it makes it easier for the reader
• Make sure braces, parentheses, etc. match, even in the presence of preprocessor directives: put opening curly brace after #endif so that your editor won't see more opening braces than closing.

• Right (braces are balanced):

  #ifdef WIN32         for (i = 0; i <= max_connection && n; i++)/*  for select() in WIN32 */ #else         for (i = 0; i <= maxfdx && n; i++)/* for poll() in Unix */ #endif                  {                 if (selpoll_fd_isset(i)) { /* this socket has data */                                            n--; /* decrement the no. of events */                                            ...                 }         }

  Wrong (braces are unbalanced -- note one in each for loop):

  #ifdef WIN32         for (i = 0; i <= max_connection && n; i++) { /*  for select() in WIN32 */ #else         for (i = 0; i <= maxfdx && n; i++) { /* for poll() in Unix */ #endif                 if (selpoll_fd_isset(i)) { /* this socket has data */                                            n--; /* decrement the no. of events */                                            ...                 }         }

• Balance your parentheses inside your #ifdefs.  Don't close parentheses inside an #ifdef if it was opened outside of the #ifdef.
• Right:

  static void reap_child(void) { struct work_task *ptask;         for (ptask = (struct work_task *)GET_NEXT(task_list_event);ptask;              ptask = (struct work_task *)GET_NEXT(ptask->wt_linkall)) {                 if ((ptask->wt_type == WORK_Deferred_Child) && #ifdef WIN32                    ((HANDLE)ptask->wt_event == pid) #else                    (ptask->wt_event == pid) #endif                                         )                         {                         ...                         }                 }         } }

  Wrong:

  static void reap_child(void) { struct work_task *ptask;         for (ptask = (struct work_task *)GET_NEXT(task_list_event);ptask;              ptask = (struct work_task *)GET_NEXT(ptask->wt_linkall)) {                 if ((ptask->wt_type == WORK_Deferred_Child) && #ifdef WIN32                     ((HANDLE)ptask->wt_event == pid)) #else                     (ptask->wt_event == pid)) #endif                         {                         ...                         }                 }         } }