# 📎 C Until It Is No Longer C
By Artyom Bologov <aartaka.me>

We have to admit that C is
inherently/potentially ugly <making-c-uglier.txt>.
One can try
making it prettier <making-c-prettier.txt>,
but there's only so much one can do to C without compromizing its nature.
That's what I'm going to do here—stretching the limits of what C is, introducing some prettier things.
If you're a C programmer (like me), you might end up horrified by what I'm doing.
Otherwise, sit back and watch how readable C can become!

## Standard Headers: Booleans and Nicer Logic (#standard-headers)

C23 made booleans part of the language.
Which is a good direction.
But what if I don't want to wait for C23 to be rolled out in GCC or Clang?
Well, I can always define some booleans myself!

===================================  ===================================
#if (__STDC_VERSION__ >= 199901L && __STDC_VERSION__ < 202000L)
#include <stdbool.h>
#elif __STDC_VERSION__ < 199901L
#define true  1
#define false 0
typedef int _Bool;
#define bool _Bool
#endif
==================== Making booleans accessible on every version of the standard ====================

Et voilá!
Now we can do proper booleans:

===================================  ===================================
// Check whether the char is a control one
// Yes, I know of iscntrl, bear with me
bool
iscontrol (unsigned int c)
{
        return (127 == c || c < 32);
}
==================== Using booleans ====================

Yes, implicit conversion to booleans.
Because booleans are nothing but unsigned integers 1 and 0.
Now what doesn't work for me is this ugly double vertical bar.
I want some Pythonesque boolean logic!

It turns out I can have this nicer boolean logic, just one `#include` away!

===================================  ===================================
#include <iso646.h>
#define eq ==
#define bitnot ~
#define bitxor ^
==================== iso646 and some more aliases ====================

I'm also defining some missing bits and fixing the inconsistently named
`xor` and `compl`.
With these, `iscontrol` becomes even more readable!

===================================  ===================================
bool
iscontrol (unsigned int c)
{
        return (127 eq c or c < 32);
}
==================== iso646 macro use ====================

`eq` feels sligtly off here.
Why not define another macro for it?
A couple of macros, actually.

===================================  ===================================
#define is ==
#define isnt !=
==================== Defining (in)equality ====================

And use it like:

===================================  ===================================
return c is 127 or c < 32;
==================== iso646 macro use ====================

Notice that I switched the order of arguments to a more intuitive one.
Putting a constant before the equality operator is no longer necessary.
(C programmers do that to avoid typos like `c = 127`,
relying on compiler to scream when it sees `127 = c`.)
After all, the spelled-out operator cannot end up as assignment.
Readability and reliability win.

## Nicer Types: Fixed Width and Custom Shortcuts (#nicer-types)

I already mentioned these before <"making-c-prettier#types-and-constants">.
But it never hurts to use these more:

===================================  ===================================
#include <stdint.h>
==================== Including fixed-width types like int32_t ====================

And then, we can go even further, inspired by brevity of `uint8_t`:

===================================  ===================================
typedef unsigned char  uchar;
typedef unsigned char  ubyte;
typedef unsigned short ushort;
typedef unsigned int   uint;
typedef unsigned long  ulong;
==================== Defining shorter aliases for standard types ====================

Going even further, here are some more Go-inspired types:

===================================  ===================================
typedef char*          string;
typedef char           byte;
typedef char*          bytes;
typedef void*          any;
==================== More shortcut/convenience types ====================

===================================  ===================================
bool
iscontrol (byte c) // Or uchar, or uint
{
        return c is 127 or c < 32;
}
==================== Using new "byte" type ====================

## Type Inference (#type-inference)

Another nice-but-not-quite-C thing C23 added is... type inference!
You may disagree with this decision, but it certainly is nice to have.
So let's add it:

===================================  ===================================
#if defined(__GNUC__) || defined(__GNUG__)
#define var   __auto_type
#define let   __auto_type
#define local __auto_type
#elif __STDC_VERSION__ > 201710L || defined(__cplusplus)
#define var   auto
#define let   auto
#define local auto
#endif
==================== Defining auto-inferred variable definition macros ====================

And use it too!

===================================  ===================================
bool
iscontrol (byte c)
{
        var delete = 127,
             space = ' ';
        return c is delete or c < space;
}
==================== Using type-inferred vars ====================

Okay, I should probably stop here.
Both because the example is no longer improvable.
And because most of the readers are already hemorrhaging.
Sorry!
I could've promised I won't do it again, but alas.
Have a good rest of the day with this newly acquired phobia.

Oh and check out
Pretty.C <https://github.com/aartaka/pretty.c>,
my project making C even further from God!

Copyright 2022-2025 Artyom Bologov (aartaka).
Any and all opinions listed here are my own and not representative of my employers; future, past and present.