Life & hacking

While trying to add import and export of .po files in glom I try to understand how libgettext-po handles erros. In gettext-po.h:


/* Signal a problem of the given severity.
MESSAGE and/or FILENAME + LINENO indicate where the problem occurred.
If FILENAME is NULL, FILENAME and LINENO and COLUMN should be ignored.
If LINENO is (size_t)(-1), LINENO and COLUMN should be ignored.
If COLUMN is (size_t)(-1), it should be ignored.
MESSAGE_TEXT is the problem description (if MULTILINE_P is true,
multiple lines of text, each terminated with a newline, otherwise
usually a single line).
Must not return if SEVERITY is PO_SEVERITY_FATAL_ERROR. */
void (*xerror) (int severity,
po_message_t message,
const char *filename, size_t lineno, size_t column,
int multiline_p, const char *message_text);


This is a callback passed to po_write_file which is called on failure. Hmm, so this method is required not to return if “SEVERITY is PO_SEVERITY_FATAL_ERROR”. How could I do this? Of course I could call exit() but that not really good. An application should usually not die if an error occours. FATAL error occours for example, if the file is not writeable.

The only solution that came into my mind yet was to start another thread that would simply exit if something goes wrong but that is really ugly. Anyone here with better ideas? Maybe I just miss the point.

I am able to write that in the moment because I am hacking on the glom po import/export feature and g++ is just that damn slow that I takes ages to build glom on my Pentium M 1.73 (which is usually not really slow and has great beryl effects now).

Anyway, I have some api suggestions for libtpz (for ThreePointZero). There also is a Project at gna for it now:


Interface TpzIter
{
next();
prev();

I have some initial code here but it needs some polishment to be added to svn. I still would like to derive GInterfaces but I doubt that this is possible in C. The design is very close to what the C++ STL provides.

Some might say now, what the advantage over GList* is so here are two points:
– GList* is used for the whole list and for an individual item – that is confusing
– [Edit: Removed]*

So there is another more important point: You can hide your list implementation. In fact, you do not have to use a “list” at all, you could have a tree, an array or any other data structure that you can wrap on that interface. This way, you can also add optimations that are not possible with GList*.

Of course there is a perfomance impact but I think that is not that major that we should not try it. Maybe someone wants to create benchmarks later.

Another thing: Dear Lazyweb, how can I configure beryl to maximize a window like metacity when I double-click on the title bar?

*[EDIT]
This point was not very good but it is still here:
– Writing loops is more intuitive, instead of

/*GList* node = list;
while (node)
{
/* do something */
node = g_list_next(node);
}*/

[EDIT] Some pointed out (correctly) that it is better to write
GList* node;
for (node = list; node != NULL; node = node->next)
{
/* do something */
}

you can use
TpzIter* iter;
for (iter = tpz_list_begin(list); !tpz_iter_equal(iter, tpz_list_end(list)); tpz_iter_next(iter))
{
/* do something */
}