C

Update: 2022-04-26: Overhauling to be simplier and bsd/clang friendly.

• Rules of engagement
  • Style
• The language
  • Basic Types
    • Integer Types
    • Real and Complex Floating Types
    • void
  • Memory Access Operators
  • Strings
• The Pre Processor
  • Macros
• Patterns
  • vtables
    • person_s.h
    • print_vtable.h
    • print_vtable.c
    • main.c
  • Libraries
    • C standard library
    • C POSIX library
    • Unit Testing
  • Sample C code

Rules of engagement⌗

• How I program C by Eskil Steenberg
• Notes on Programming in C by Rob Pike
• The Ten Commandments for C Programmers by Henry Spencer

Style⌗

• suckless
• FreeBSD man 9 style

The language⌗

Basic Types⌗

Integer Types⌗

C99 with stdbool.h introduced boolean type _Bool (1 byte), and macros true (1) and false (0).

Interestingly the specific storage size for int is not defined. A compilers given implementation bit widths are defined in limits.h.

Real and Complex Floating Types⌗

Most compilers honour the IEEE 754-1985 standard.

void⌗

Represents no value, and is widely used in three scenarios:

1. Functions that do not return a value, e.g. void exit (int status), or where the return value is to be explicitly discarded e.g. (void)printf("mt tennent");
2. Prototypes of functions that have no parameters, e.g. int rand(void)
3. Pointers to void i.e. void * (typeless pointers)

Memory Access Operators⌗

The address of operator, &, yields the address of its subject, thus &foo is a pointer to foo.

The indirection operator, *, is used to access an object or function through a pointer.

{% highlight c %} int32_t num, *pnum; pnum = # *pnum = 123; {% endhighlight %}

The subscript operator, [], can be used to address elements within an array. In reality this is sugar for offsetting into chunk of memory, or in other words x[i] is equivalent to (*(x+(i)))

{% highlight c %} float arr[10] = { 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7 }, *parr; parr = arr; parr = parr + 3; {% endhighlight %}

Member of a struct or union operators, ., and its pointer friendly version ->. The arrow operator -> is a convenient pointer dereference. That is, p->x is equivalent to (*p).x

{% highlight c %} struct { wchar_t *name; float amount; } label, *plabel; label.amount = 49.95; plabel = &label; plabel->name = “Bill Joy”; {% endhighlight %}

Strings⌗

The Pre Processor⌗

Macros⌗

This following macro is called variadic. When the macro is invoked, all the tokens in its argument list after the last named argument, including any commas, become the variable argument. This sequence of tokens replaces the identifier __VA_ARGS__ in the macro body wherever it appears.

#define stopif(assertion, action, ...) {
    if (assertion) {
        fprintf(error_log ? error_log : stderr, **VA_ARGS**);
        fprintf(error_log ? error_log : stderr, "\n");
        action;
    }
}

//usage
stopif(!isnan(inv_total), goto nanval, "Invoice amount was NaN");
stopif(!foo, return -1, "wtf dude, foo must not be NULL");

nanval:
free(fooheap);
return NAN;

Another one. The macro print_log acts as the public API, encapsulating internal grunt function _print_log:

#define print_log(level, ...) do {
    time_t \_clk = time(NULL);
    \_print_log(level, **FILE**, **func**, ctime(&\_clk), **LINE**, **VA_ARGS**);
} while (0)

extern void \_print*log(int, char *, const char \_, char*, int, char *, ...);

//usage
print_log(LOG_WARNING, "where be a wookie when you need one");

Patterns⌗

vtables⌗

Virtual tables are a technique for adding functions outside of an objects struct. Using a hash table as the vtable data structure, the key, something unique to the object and the specific function (in case you want to store multiple functions in the vtable for the same object), and the value, the actual function.

person_s.h⌗

typedef struct person_s {
    char *name;
    char **books;
    int len;
    void (*print)(struct person_s*);
};

The object, a person. The print function pointer here is souly used as the hash key. It’s unique to both the object, and the specific operation of printing. It never points to an actual function.

print_vtable.h⌗

extern HashTable *funcs_hash;

typedef void (_print_fn_type)(struct person_s_);

void check_print_fn(print_fn_type pf);

##define printfn_vtable_add(object, fn) { \
 check_print_fn(fn); \
 hash_table_insert(funcs_hash, (object)->print, fn); \
}

void print_person_frontend(struct person_s *in);

Declares hash table, a macro to add functions to the hash table (this exists only to add static type checking on the function passed, by first trying to pass it into check_print_fn), and the “frontend” function signature (for consumers of the API) that takes in a person and will query the vtable for the function to invoke.

print_vtable.c⌗

HashTable *funcs_hash;

void check_print_fn(print_fn_type pf) { }

void print_person_frontend(struct person_s *in) {
    if (!funcs_hash) {
        funcs_hash = hash_table_new(g_direct_hash, g_direct_equal);
    }

    print_fn_type printfn = hash_table_lookup(funcs_hash, in->print);

    if (printfn) {
        printfn(in);
        return;
    }

    printf("No print implementation found in vtable...panic!\n");
}

main.c⌗

static void print_person_backend(struct person_s *in) {
    printf("\nName: %s\n", in->name);
    for (int i=0; i < in->len; i++)
    printf("- Book author for: %s\n", in->books[i]);
}

int main() {
    struct person_s dennis = {
        .name="Dennis Ritchie",
        .books = (char\*[]) { "The C Programming Language - 1978" },
        .len = 1
    };

    print_person_frontend(&dennis);
    printfn_vtable_add(&dennis, print_person_backend);
    print_person_frontend(&dennis);

    struct person_s rob = {
         .name = "Rob Pike",
        .books = (char*[]) { "The Unix Programming Environment - 1982", "The Practice of Programming - 1999" },
        .len = 2
    };
    print_person_frontend(&rob);

    return 0;

}

Output:

No print implementation found in vtable...panic!

Name: Dennis Ritchie
-  Book author for: The C Programming Language - 1978

Name: Rob Pike
-  Book author for: The Unix Programming Environment - 1982
-  Book author for: The Practice of Programming - 1999

Libraries⌗

The C standard library and the C POSIX library both offer a standardised, resuable slabs of macros, type definitions and functions for tasks such as string handling, mathematical computations, input/output processing, memory management, and several common operating system services. A set of common building blocks.

POSIX being a superset of the C standard library. If C and POSIX is ever in conflict, C wins.

The GNU C Library

C standard library⌗

C POSIX library⌗

Unit Testing⌗

• Unity Project - Unity is most obviously about assertions. Assertions are statements of what we expect to be true about our embedded system.
• GLib Testing

Sample C code⌗

• Trending C GitHub Repos
• GitHub C repos
• C binding for ØMQ
• The C Code Archive Network
• systemd