vurtun

static float
scalbnf(float x, int n)
{
	union {float f; unsigned i;} u;
	float y = x;
	if (n > 127) {
		y *= 0x1p127f;
		n -= 127;
		if (n > 127) {
			y *= 0x1p127f;

vurtun

static char*
sys_clip_get(struct sys *s, Atom selection, Atom target)
{
    assert(s);
    struct sys_x11 *x11 = s->platform;

    /* blocking wait for clipboard data */
    XEvent notify;
    XConvertSelection(x11->dpy, selection, target, selection, x11->helper, CurrentTime);
    while (!XCheckTypedWindowEvent(x11->dpy, x11->helper, SelectionNotify, &notify)) {

vurtun

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
#include <string.h>
#include <stdarg.h>
#include <limits.h>

#define cast(t,p) ((t)(p))
#define szof(a) ((int)sizeof(a))

vurtun

struct lzw {
    int bitcnt;
    int bits, off;
};
static int
lzw_compressed_size(int size)
{
    return size*2;
}
static unsigned char*

vurtun

// --- Library --------------------------------------------------------------------------
#include <string.h>
#include <assert.h>

struct ui_box {int x,y,w,h;};
typedef unsigned long long ui_id;
struct ui_node {
    int parent;
    int lst, end, nxt;
    int siz[2];

vurtun

This is a short post related to Opaque object representations from Our Machinery. I have to begin that my understanding of how Our Machineries tech is somewhat limit and it is currently rather late in the day, so please bear with me. As far as I understood how modules work is similar to how Quake 2 did their modules. A module has both a struct for export and one for import containing a number of function pointer. At load time the module gets a filled out import struct and fills out its own export struct with its own functions and returns it.

As for the allocators. I would have guessed tha

vurtun

#define HL_HASH32_COUNT 4
#define HL_SPACE(NUM_REG_BITS) ((1 << NUM_REG_BITS) + 1)

static int
ilog2(int n) {
  // clang-format off
  #define lt(n) n,n,n,n, n,n,n,n, n,n,n,n ,n,n,n,n
  static const char tbl[256] = {0,0,1,1,2,2,2,2,3,3,3,3,
      3,3,3,3,lt(4),lt(5),lt(5),lt(6),lt(6),lt(6),lt(6),
      lt(7),lt(7),lt(7),lt(7),lt(7),lt(7),lt(7),lt(7)

vurtun

#include <stdio.h>
#include <stdlib.h>

#if defined(__clang__) || defined(__GNUC__)
  #define sort qsort_r
  #define SORT_COMPARE(name) int name(const void *a, const void *b, void *arg)
  typedef SORT_COMPARE(sort_cmp_f);
#elif defined(_MSC_VER)
  #define sort qsort_s
  #define SORT_COMPARE(name) int name(void *arg, const void *a, const void *b)

vurtun

#if 0
#include <stdio.h>

int main(void)
{
    int n, t[3] = {0};
    for (n = 0; n < 100; ++n) {
        pytriples(t);
        printf("(%d,%d,%d)\n", t[0], t[1], t[2]);
    } return 0;

vurtun

struct path_iter {
    const char *begin;
    const char *end;
    /* internal */
    const char *next;
    const char *eof;
};
static void
path_begin(struct path_iter *it, const char *str, const char *end)
{