I have spent a large chunk of my free time over the last several months replacing OpenVRML’s ANTLR parsers with ones using Spirit. This was my first attempt to do something nontrivial with Spirit. So this comment from the author of Spirit absolutely made my day.

After nearly a year since pushing this project to Google’s project hosting, I’ve finally made a release tarball of my Autoconf macros for OpenGL. This was motivated mostly by significant changes that were precipitated by requirements for building on Mac OS X 10.5.

10.5 is a bit of a mixed bag relative to its predecessor as far as building with OpenGL is concerned. The good: they finally fixed the longstanding bug with the GLU tesselator callback function type being interpreted incorrectly. The bad: linking with X11 now requires some extremely goofy linker flags.

One nice thing, though, is that I was finally able to get rid of the annoying ‑‑with‑apple‑opengl‑framework option.

I have begun to wonder just what it would take to create an ActiveX control for OpenVRML.
It has been about a decade since I touched COM. At the time, I had just (barely) learned C++. And I was struck then that just about every Good Practice for C++ I was learning about was being flagrantly [...]

I’ve used Motorola mobile phones since I’ve had a mobile phone, starting with the V60i back in 2002 (as a customer of the original AT&T Wireless), followed with a V551 (with Cingular), which was in turn replaced with a RAZR V3 (upon its untimely demise).
The latter two phones had nearly identical software; but I was [...]

I discovered Consolas a couple of weeks ago; and I’ve been using it heavily since then. It renders nicely on the Mac (where it has supplanted Andale Mono) as well as with Xft (where it has supplanted DejaVu Sans Mono).
Something about Consolas makes Emacs behave just a little bit goofy: for some reason windows sometimes [...]

I didn’t want to like Python. I’m still not sure that I do. But I have to admit that it is starting to grow on me. I’m beginning to get used to its goofy ideas about whitespace. And its double-underscore-emblazoned special identifiers are starting to hurt my eyes less.
I have been learning to use Blender. [...]

I guess I shouldn’t be so surprised; I was immediately taken with Spirit upon discovering it. Though back in 2001 Spirit still had a good deal of growing up to do; it’s come a long way since then. And given that Joel de Guzman and his cohorts are hard at work on Spirit 2, I get the idea that it will yet go a good deal farther. But I digress.

It’s the middle of 2007 and I’ve gotten serious about writing a VRML parser for OpenVRML using Spirit. Why now? Well, ANTLR certainly hasn’t gotten to be any less of an annoying dependency over the years. But another factor is that a new major version of ANTLR has been released (3.0). I think my efforts are better spent moving away from ANTLR entirely than on upgrading to the new version (which I understand to include nontrivial changes to the grammar format).

Now, I don’t want to come across as disliking ANTLR. It’s a really nice tool. In fact, it’s the nicest parser generator I’ve ever used. Functionality is very discoverable and I found, for the most part, the general behavior of ANTLR parsers to be very intuitive. But it has its downsides:

It’s a code generator, and thus it has the caveats that go with any code generation.

It’s a Java program, and thus it has the caveats that go with any Java program.

Even though it can generate code for a number of languages that are Not Java, the Not Java language backends are maintained by persons other than the primary author of ANTLR; thus, these languages wind up being second class citizens. (For example, ANTLR 3.0 has been released without C++ support since the maintainer of the C++ backend for ANTLR 2.x didn’t have time to port it to the new version.)

I actually started in earnest on this project at the end of last summer. I made a good deal of headway, getting as far as developing a good understanding of how to use Spirit’s stored_rule to create a grammar with productions that get modified as part of the parse. This solved the somewhat tricky issue of parsing node field values. But then I got side-tracked with getting the stand-alone viewer (openvrml-player) working reliably; that took much, much longer than I’d anticipated. But now I’ve picked up pretty much where I left off. As of this writing, I can parse nodes, EXTERNPROTOs, and PROTOs, except for IS mappings. I still have to do ROUTEs; though they will be pretty easy now that I’ve got DEF working.

As with the ANTLR-based parser, I’m doing a good deal of semantic checking; this parser will be just as aggressive about rejecting code that’s Not Quite Right as OpenVRML’s current parser. But unlike OpenVRML’s current parser, I’m using very little of OpenVRML’s runtime machinery to accomplish this checking. The idea is to make this parser much more reusable than OpenVRML’s current parser. The current parser isn’t really exposed; users can read the file into the runtime and then inspect the node tree created for the runtime. It turns out, though, that a good deal of OpenVRML’s users (and prospective users) don’t care one bit about a VRML/X3D runtime—they just want to read a VRML or X3D file and do something with the data. So, the new parser will have

Pluggable semantic actions

Minimal dependencies on the rest of libopenvrml—ideally, linking with libopenvrml won’t be required at all for someone just using the parser

This will all be possible through the magic of Spirit and C++ templates.

After years of sitting on the sidelines, I’ve taken the plunge and gotten a digital audio player.

iPods don’t interest me. While I appreciate their slick interface, I’m not the least bit interested in iTunes (or other online music services). And the fact that they don’t play Ogg is a deal-breaker for me. I use a Linux desktop (GNOME) and Ogg is easy for me to use, high quality, and completely unencumbered.

The requirement for Ogg narrows the field quite a bit. Narrowing it further, I’m interested in a flash-based device. So for some weeks I’ve been considering the Cowon D2 or the iRiver Clix. But ultimately the iRiver S10 won me over. The multimedia capabilities of the D2 and Clix don’t interest me; and the S10’s form factor is quite attractive.

I received my S10 yesterday. The functionality and quality are top-notch. And Nautilus makes it easy for me to convert selections from my library of FLACs to Oggs on the S10.

I am very happy with it. But here are the few things I don’t like:

Unless you’re using a playlist, files play in the order of their FAT entries. I’d have preferred/expected alphanumeric order. The included software includes the facility to reorder the entries (and thus play order) however you like; however…

The included software only works on Windows. I realize that providing software that works on Linux is probably expecting too much; but I was expecting a Mac version. This software isn’t absolutely vital; but the FAT entry reordering is very useful and the software is the most convenient means I’ve found of creating playlists. (Though so far I haven’t found myself messing with playlists.)

The included software seems not to work at all unless it’s run by a user with Administrator privileges. Lame. Really lame.

No case was included; nor does anyone appear to make one. Hopefully that will change. An armband would be especially handy.

The “D-click” navigation is a pleasure to use; but it means that the player can’t really be operated while stored somewhere that’s at all a tight fit—like, for instance, pockets in jeans. If there is some way to lock the interface, I haven’t discovered it yet.

My primary development box, hinge, has seen a bit of an overhaul lately. Most significantly, I snagged some Opteron 285s that were refurbished units (i.e., system pulls) from HP servers for $325 each. These replaced the 242s that I originally built hinge with. Twice the cores and a full 1 GHz faster—quite an improvement.
hinge is housed [...]