lighty's life

So, what has been done so far:

• buffer.c and buffer.h are gone and are replaced by GString
• array.c is gone and is replace by GHashTable or GPtrArray
• array.h will vanish when the data_…c goes away
• log.c is now a wrapper around g_log_…

As you see this is ripping out the basic data-structures and replaces them by a glib look-alike.

This isn’t just a drop-in replacement as the structures use other field-names and sometimes have a slightly different meaning.

One example is GString vs. buffer:

buffer {
  char *ptr;
  size_t used;
  size_t size;
};

GString {
  char *str;
  size_t len;
  size_t allocated_len;
};

While str and ptr, and allocated_len and size match, used and len differ by one byte (used includes the NUL-byte, len doesn’t).

One side-effect of this boring work is seeing the code-size shrinking, piece by piece.

Seeing old, sometimes dirty code vanish is another nice side-effect. Like the log_error_write() call … man …

This always happens if you rip a thing apart: you see more things that should be cleaned up. My first experiments are a bit done:

server = {
        name = "my.example.org",
        modules = {
                "mod_indexfile" 
        },
        ["errorfile-prefix"] = "foobar",
}

sockets = {
        [":80"] = {
                server = { name = "foo.example.org" },
                HTTP = { url = function(url)
                        if url == "foo" then
                                server.name = "baz.example.org" 
                        end
                end },
        }
}

sockets[":80"].HTTP.url("foo")
print(server.name)

This is a first idea. It shows how the LUA syntax isn’t sooo different from our current config syntax.

• The global variables, stay global as now.
• socket conditionals is now a simple array of sockets
• conditionals are functions, now you can do what you want with it

I hope that I can handle the full config syntax into this structure. For now it is looks more appealing that ripping the old config-parser code apart and turn it into glib-notation. With all the conditionals and types we basicly have implemented our own scripting language.

Let’s see where this leads too.