C[omp]ute

From: andrew cooke <andrew@...>

Date: Mon, 20 Jun 2011 10:29:38 -0400

I've been back coding in C for a while and want to record some simple rules
that make programs simpler:

1 - Always return a status.  Non-zero is an error.  Always check status on
    return.  On error, goto exit for cleanup.

    So functions should look like:

    int myfunction(blah blah) {
      char *text = NULL;
      void *point = NULL;
      int status = 0;
      ...
      if ((status = otherfunction(args here))) goto exit;
      if ((status = yetanother(...))) goto exit;
      ...
    exit:
      if (text) free(text);
      if (pointer) free(pointer)
      return status;
    }

2 - Write allocators and destructors for complex data (structs).  These should
    always take a pointer to a pointer and set the pointer to NULL.
    Similarly, use calloc to allocate data so that pointers are NULL from the
    start).  This follows on from the above - using NULL to indicate that data
    are already freed:

    int alloc_foo(foo **my_foo) {
      int status;
      *my_foo = calloc(1, sizeof(foo));
      if (! my_foo) return MEMORY_ERROR;
      (*my_foo)->counts = calloc(1, 20 * sizeof(int));
      if (! (*my_foo)->counts) return MEMORY_ERROR;
      if ((status = alloc_inner(&(*my_foo)->inner))) return status
      return 0;
    }

    int free_foo(foo **my_foo, status) {
      if (*my_foo) {
        if ((*my_foo)->counts) free((*my_foo)->counts);
        (*my_foo)->counts = NULL;
	status = free_inner(&(*my_foo)->inner, status)
        *my_foo = NULL;
      }
      return status;
    }

3 - Cleanup functions should take status an argument and "make it worse".  the
    the idea here is that you want to call cleanup functions even if there are
    errors, but you don't want to "reset" status to OK (zero) if it was bad.
    In the examples above it's not so clear, but consider, say, releasing a
    database:

    int release_db(cnxn *db, int status) {
      db_lib_release(db);
      if (db_lib_error() && ! status) status = DB_ERROR;
      return status;
    }

    This simplifies the "exit:" code and also allows one-liners when you want
    to do one thing with a database and then release it:

      if ((status = release_db(db, do_db_thing(db, ....)))) goto exit;

4 - Use typedefs for structs:

    typedef struct {
      int my_int;
    } my_struct;

5 - Either namespace with names (and use static functions to avoid clutter
    wherever possible) or namespace with "objects":

    typedef struct self {
      ...
      int (*free)(struct self **foo, int status);
    } foo;

Andrew