65 files changed, 26718 insertions, 0 deletions

diff --git a/pathologist/src/Makefile.am b/pathologist/src/Makefile.am
new file mode 100644
index 0000000..d2b35f4
--- /dev/null
+++ b/pathologist/src/Makefile.am
@@ -0,0 +1,2 @@
+SUBDIRS = include mi util minixml pathologist .
+
diff --git a/pathologist/src/include/Makefile.am b/pathologist/src/include/Makefile.am
new file mode 100644
index 0000000..b301e48
--- /dev/null
+++ b/pathologist/src/include/Makefile.am
@@ -0,0 +1,9 @@
+SUBDIRS = .
+
+monkeyincludedir = $(includedir)/monkey
+
+monkeyinclude_HEADERS = \
+  monkey_common.h \
+  plibc.h \
+  gdbmi.h \
+  mxml.h
diff --git a/pathologist/src/include/gdbmi.h b/pathologist/src/include/gdbmi.h
new file mode 100644
index 0000000..588c50b
--- /dev/null
+++ b/pathologist/src/include/gdbmi.h
@@ -0,0 +1,730 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004-2009 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Comments:
+  Main header for libmigdb.
+  
+***************************************************************************/
+
+#ifndef GDBMI_H
+#define GDBMI_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h> /* pid_t */
+
+#define MI_OK                      0
+#define MI_OUT_OF_MEMORY           1
+#define MI_PIPE_CREATE             2
+#define MI_FORK                    3
+#define MI_DEBUGGER_RUN            4
+#define MI_PARSER                  5
+#define MI_UNKNOWN_ASYNC           6
+#define MI_UNKNOWN_RESULT          7
+#define MI_FROM_GDB                8
+#define MI_GDB_TIME_OUT            9
+#define MI_GDB_DIED               10
+#define MI_MISSING_XTERM          11
+#define MI_CREATE_TEMPORAL        12
+#define MI_MISSING_GDB            13
+#define MI_LAST_ERROR             13
+
+#define MI_R_NONE                  0 /* We are no waiting any response. */
+#define MI_R_SKIP                  1 /* We want to discard it. */
+#define MI_R_FE_AND_S              2 /* Wait for done. */
+#define MI_R_E_ARGS                3
+
+enum mi_val_type { t_const, t_tuple, t_list };
+
+/* Types and subtypes. */
+/* Type. */
+#define MI_T_OUT_OF_BAND   0
+#define MI_T_RESULT_RECORD 1
+/* Out of band subtypes. */
+#define MI_ST_ASYNC        0
+#define MI_ST_STREAM       1
+/* Async sub-subtypes. */
+#define MI_SST_EXEC        0
+#define MI_SST_STATUS      1
+#define MI_SST_NOTIFY      2
+/* Stream sub-subtypes. */
+#define MI_SST_CONSOLE     3
+#define MI_SST_TARGET      4
+#define MI_SST_LOG         5
+/* Classes. */
+/* Async classes. */
+#define MI_CL_UNKNOWN      0
+#define MI_CL_STOPPED      1
+#define MI_CL_DOWNLOAD     2
+/* Result classes. */
+#define MI_CL_DONE         2
+#define MI_CL_RUNNING      3
+#define MI_CL_CONNECTED    4
+#define MI_CL_ERROR        5
+#define MI_CL_EXIT         6
+
+#define MI_DEFAULT_TIME_OUT 10
+
+#define MI_DIS_ASM        0
+#define MI_DIS_SRC_ASM    1
+
+/* Implemented workaround for gdb bugs that we can dis/enable. */
+/* At least gdb<=6.1.1 fails to find a source file with absolute path if the
+   name is for a psym instead of a sym. psym==partially loaded symbol table. */
+#define MI_PSYM_SEARCH    0
+
+#define MI_VERSION_STR "0.8.12"
+#define MI_VERSION_MAJOR  0
+#define MI_VERSION_MIDDLE 8
+#define MI_VERSION_MINOR  12
+
+struct mi_results_struct
+{
+ char *var; /* Result name or NULL if just a value. */
+ enum mi_val_type type;
+ union
+ {
+  char *cstr;
+  struct mi_results_struct *rs;
+ } v;
+ struct mi_results_struct *next;
+};
+typedef struct mi_results_struct mi_results;
+
+struct mi_output_struct
+{
+ /* Type of output. */
+ char type;
+ char stype;
+ char sstype;
+ char tclass;
+ /* Content. */
+ mi_results *c;
+ /* Always modeled as a list. */
+ struct mi_output_struct *next;
+};
+typedef struct mi_output_struct mi_output;
+
+typedef void (*stream_cb)(const char *, void *);
+typedef void (*async_cb)(mi_output *o, void *);
+typedef int  (*tm_cb)(void *);
+
+/* Values of this structure shouldn't be manipulated by the user. */
+struct mi_h_struct
+{
+ /* Pipes connected to gdb. */
+ int to_gdb[2];
+ int from_gdb[2];
+ /* Streams for the pipes. */
+ FILE *to, *from;
+ /* PID of child gdb. */
+ pid_t pid;
+ char died;
+ /* Which rensponse we are waiting for. */
+ /*int response;*/
+ /* The line we are reading. */
+ char *line;
+ int   llen, lread;
+ /* Parsed output. */
+ mi_output *po, *last;
+ /* Tunneled streams callbacks. */
+ stream_cb console;
+ void *console_data;
+ stream_cb target;
+ void *target_data;
+ stream_cb log;
+ void *log_data;
+ /* Async responses callback. */
+ async_cb async;
+ void *async_data;
+ /* Callbacks to get echo of gdb dialog. */
+ stream_cb to_gdb_echo;
+ void *to_gdb_echo_data;
+ stream_cb from_gdb_echo;
+ void *from_gdb_echo_data;
+ /* Time out */
+ tm_cb time_out_cb;
+ void *time_out_cb_data;
+ int time_out;
+ /* Ugly workaround for some of the show responses :-( */
+ int catch_console;
+ char *catched_console;
+ /* MI version, currently unknown but the user can force v2 */
+ unsigned version;
+};
+typedef struct mi_h_struct mi_h;
+
+#define MI_TO(a) ((a)->to_gdb[1])
+
+enum mi_bkp_type { t_unknown=0, t_breakpoint=1, t_hw=2 };
+enum mi_bkp_disp { d_unknown=0, d_keep=1, d_del=2 };
+enum mi_bkp_mode { m_file_line=0, m_function=1, m_file_function=2, m_address=3 };
+
+struct mi_bkpt_struct
+{
+ int number;
+ enum mi_bkp_type type;
+ enum mi_bkp_disp disp; /* keep or del if temporal */
+ char enabled;
+ void *addr;
+ char *func;
+ char *file;
+ int line;
+ int ignore;
+ int times;
+
+ /* For the user: */
+ char *cond;
+ char *file_abs;
+ int thread;
+ enum mi_bkp_mode mode;
+ struct mi_bkpt_struct *next;
+};
+typedef struct mi_bkpt_struct mi_bkpt;
+
+enum mi_wp_mode { wm_unknown=0, wm_write=1, wm_read=2, wm_rw=3 };
+
+struct mi_wp_struct
+{
+ int number;
+ char *exp;
+ enum mi_wp_mode mode;
+
+ /* For the user: */
+ struct mi_wp_struct *next;
+ char enabled;
+};
+typedef struct mi_wp_struct mi_wp;
+
+struct mi_frames_struct
+{
+ int level;  /* The frame number, 0 being the topmost frame, i.e. the innermost
+                function. */
+ void *addr; /* The `$pc' value for that frame. */
+ char *func; /* Function name. */
+ char *file; /* File name of the source file where the function lives. */
+ char *from;
+ int line;   /* Line number corresponding to the `$pc'. */
+ /* When arguments are available: */
+ mi_results *args;
+ int thread_id;
+ /* When more than one is provided: */
+ struct mi_frames_struct *next;
+};
+typedef struct mi_frames_struct mi_frames;
+
+struct mi_aux_term_struct
+{
+ pid_t pid;
+ char *tty;
+};
+typedef struct mi_aux_term_struct mi_aux_term;
+
+struct mi_pty_struct
+{
+ char *slave;
+ int master;
+};
+typedef struct mi_pty_struct mi_pty;
+
+enum mi_gvar_fmt { fm_natural=0, fm_binary=1, fm_decimal=2, fm_hexadecimal=3,
+                   fm_octal=4,
+                   /* Only for registers format: */
+                   fm_raw=5 };
+enum mi_gvar_lang { lg_unknown=0, lg_c, lg_cpp, lg_java };
+
+#define MI_ATTR_DONT_KNOW   0
+#define MI_ATTR_NONEDITABLE 1
+#define MI_ATTR_EDITABLE    2
+
+struct mi_gvar_struct
+{
+ char *name;
+ int   numchild;
+ char *type;
+ enum mi_gvar_fmt format;
+ enum mi_gvar_lang lang;
+ char *exp;
+ int   attr;
+
+ /* MI v2 fills it, not yet implemented here. */
+ /* Use gmi_var_evaluate_expression. */
+ char *value;
+
+ /* Pointer to the parent. NULL if none. */
+ struct mi_gvar_struct *parent;
+ /* List containing the children.
+    Filled by gmi_var_list_children.
+    NULL if numchild==0 or not yet filled. */
+ struct mi_gvar_struct *child;
+ /* Next var in the list. */
+ struct mi_gvar_struct *next;
+
+ /* For the user: */
+ char opened;  /* We will show its children. 1 when we fill "child" */
+ char changed; /* Needs to be updated. 0 when created. */
+ int vischild; /* How many items visible. numchild when we fill "child" */
+ int depth;    /* How deep is this var. */
+ char ispointer;
+};
+typedef struct mi_gvar_struct mi_gvar;
+
+struct mi_gvar_chg_struct
+{
+ char *name;
+ int   in_scope;  /* if true the other fields apply. */
+ char *new_type;  /* NULL if type_changed==false */
+ int   new_num_children; /* only when new_type!=NULL */
+
+ struct mi_gvar_chg_struct *next;
+};
+typedef struct mi_gvar_chg_struct mi_gvar_chg;
+
+
+/* A list of assembler instructions. */
+struct mi_asm_insn_struct
+{
+ void *addr;
+ char *func;
+ unsigned offset;
+ char *inst;
+
+ struct mi_asm_insn_struct *next;
+};
+typedef struct mi_asm_insn_struct mi_asm_insn;
+
+/* A list of source lines containing assembler instructions. */
+struct mi_asm_insns_struct
+{
+ char *file;
+ int line;
+ mi_asm_insn *ins;
+
+ struct mi_asm_insns_struct *next;
+};
+typedef struct mi_asm_insns_struct mi_asm_insns;
+
+/* Changed register. */
+struct mi_chg_reg_struct
+{
+ int reg;
+ char *val;
+ char *name;
+ char updated;
+
+ struct mi_chg_reg_struct *next;
+};
+typedef struct mi_chg_reg_struct mi_chg_reg;
+
+/*
+ Examining gdb sources and looking at docs I can see the following "stop"
+reasons:
+
+Breakpoints:
+a) breakpoint-hit (bkptno) + frame
+Also: without reason for temporal breakpoints.
+
+Watchpoints:
+b) watchpoint-trigger (wpt={number,exp};value={old,new}) + frame
+c) read-watchpoint-trigger (hw-rwpt{number,exp};value={value}) + frame
+d) access-watchpoint-trigger (hw-awpt{number,exp};value={[old,]new}) + frame
+e) watchpoint-scope (wpnum) + frame
+
+Movement:
+f) function-finished ([gdb-result-var,return-value]) + frame
+g) location-reached + frame
+h) end-stepping-range + frame
+
+Exit:
+i) exited-signalled (signal-name,signal-meaning)
+j) exited (exit-code)
+k) exited-normally
+
+Signal:
+l) signal-received (signal-name,signal-meaning) + frame
+
+Plus: thread-id
+*/
+enum mi_stop_reason
+{
+ sr_unknown=0,
+ sr_bkpt_hit,
+ sr_wp_trigger, sr_read_wp_trigger, sr_access_wp_trigger, sr_wp_scope,
+ sr_function_finished, sr_location_reached, sr_end_stepping_range,
+ sr_exited_signalled, sr_exited, sr_exited_normally,
+ sr_signal_received
+};
+
+struct mi_stop_struct
+{
+ enum mi_stop_reason reason; /* If more than one reason just the last. */
+ /* Flags indicating if non-pointer fields are filled. */
+ char have_thread_id;
+ char have_bkptno;
+ char have_exit_code;
+ char have_wpno;
+ /* Where stopped. Doesn't exist for sr_exited*. */
+ int thread_id;
+ mi_frames *frame;
+ /* sr_bkpt_hit */
+ int bkptno;
+ /* sr_*wp_* no scope */
+ mi_wp *wp;
+ char *wp_old;
+ char *wp_val;
+ /* sr_wp_scope */
+ int wpno;
+ /* sr_function_finished. Not for void func. */
+ char *gdb_result_var;
+ char *return_value;
+ /* sr_exited_signalled, sr_signal_received */
+ char *signal_name;
+ char *signal_meaning;
+ /* sr_exited */
+ int exit_code;
+};
+typedef struct mi_stop_struct mi_stop;
+
+/* Variable containing the last error. */
+extern int mi_error;
+extern char *mi_error_from_gdb;
+const char *mi_get_error_str();
+
+/* Indicate the name of gdb exe. Default is /usr/bin/gdb */
+void mi_set_gdb_exe(const char *name);
+const char *mi_get_gdb_exe();
+/* Indicate the name of a file containing commands to send at start-up */
+void mi_set_gdb_start(const char *name);
+const char *mi_get_gdb_start();
+/* Indicate the name of a file containing commands to send after connection */
+void mi_set_gdb_conn(const char *name);
+const char *mi_get_gdb_conn();
+void mi_send_target_commands(mi_h *h);
+/* Connect to a local copy of gdb. */
+mi_h *mi_connect_local();
+/* Close connection. You should ask gdb to quit first. */
+void  mi_disconnect(mi_h *h);
+/* Force MI version. */
+#define MI_VERSION2U(maj,mid,min) (maj*0x1000000+mid*0x10000+min)
+void  mi_force_version(mi_h *h, unsigned vMajor, unsigned vMiddle,
+                       unsigned vMinor);
+void  mi_set_workaround(unsigned wa, int enable);
+int   mi_get_workaround(unsigned wa);
+/* Parse gdb output. */
+mi_output *mi_parse_gdb_output(const char *str);
+/* Functions to set/get the tunneled streams callbacks. */
+void mi_set_console_cb(mi_h *h, stream_cb cb, void *data);
+void mi_set_target_cb(mi_h *h, stream_cb cb, void *data);
+void mi_set_log_cb(mi_h *h, stream_cb cb, void *data);
+stream_cb mi_get_console_cb(mi_h *h, void **data);
+stream_cb mi_get_target_cb(mi_h *h, void **data);
+stream_cb mi_get_log_cb(mi_h *h, void **data);
+/* The callback to deal with async events. */
+void mi_set_async_cb(mi_h *h, async_cb cb, void *data);
+async_cb mi_get_async_cb(mi_h *h, void **data);
+/* Time out in gdb responses. */
+void mi_set_time_out_cb(mi_h *h, tm_cb cb, void *data);
+tm_cb mi_get_time_out_cb(mi_h *h, void **data);
+void mi_set_time_out(mi_h *h, int to);
+int mi_get_time_out(mi_h *h);
+/* Callbacks to "see" the dialog with gdb. */
+void mi_set_to_gdb_cb(mi_h *h, stream_cb cb, void *data);
+void mi_set_from_gdb_cb(mi_h *h, stream_cb cb, void *data);
+stream_cb mi_get_to_gdb_cb(mi_h *h, void **data);
+stream_cb mi_get_from_gdb_cb(mi_h *h, void **data);
+/* Sends a message to gdb. */
+int mi_send(mi_h *h, const char *format, ...);
+/* Wait until gdb sends a response. */
+mi_output *mi_get_response_blk(mi_h *h);
+/* Check if gdb sent a complete response. Use with mi_retire_response. */
+int mi_get_response(mi_h *h);
+/* Get the last response. Use with mi_get_response. */
+mi_output *mi_retire_response(mi_h *h);
+/* Look for a result record in gdb output. */
+mi_output *mi_get_rrecord(mi_output *r);
+/* Look if the output contains an async stop.
+   If that's the case return the reason for the stop.
+   If the output contains an error the description is returned in reason. */
+int mi_get_async_stop_reason(mi_output *r, char **reason);
+mi_stop *mi_get_stopped(mi_results *r);
+mi_frames *mi_get_async_frame(mi_output *r);
+/* Wait until gdb sends a response.
+   Then check if the response is of the desired type. */
+int mi_res_simple_exit(mi_h *h);
+int mi_res_simple_done(mi_h *h);
+int mi_res_simple_running(mi_h *h);
+int mi_res_simple_connected(mi_h *h);
+/* It additionally extracts an specified variable. */
+mi_results *mi_res_done_var(mi_h *h, const char *var);
+/* Extract a frames list from the response. */
+mi_frames *mi_res_frames_array(mi_h *h, const char *var);
+mi_frames *mi_res_frames_list(mi_h *h);
+mi_frames *mi_parse_frame(mi_results *c);
+mi_frames *mi_res_frame(mi_h *h);
+/* Create an auxiliar terminal using xterm. */
+mi_aux_term *gmi_start_xterm();
+/* Indicate the name of xterm exe. Default is /usr/bin/X11/xterm */
+void mi_set_xterm_exe(const char *name);
+const char *mi_get_xterm_exe();
+/* Kill the auxiliar terminal and release the structure. */
+void gmi_end_aux_term(mi_aux_term *t);
+/* Look for a free Linux VT for the child. */
+mi_aux_term *gmi_look_for_free_vt();
+/* Look for a free and usable Linux VT. */
+int mi_look_for_free_vt();
+/* Close master and release the structure. */
+void gmi_end_pty(mi_pty *p);
+/* Look for a free pseudo terminal. */
+mi_pty *gmi_look_for_free_pty();
+/* Extract a list of thread IDs from response. */
+int mi_res_thread_ids(mi_h *h, int **list);
+int mi_get_thread_ids(mi_output *res, int **list);
+/* A variable response. */
+mi_gvar *mi_res_gvar(mi_h *h, mi_gvar *cur, const char *expression);
+enum mi_gvar_fmt mi_format_str_to_enum(const char *format);
+const char *mi_format_enum_to_str(enum mi_gvar_fmt format);
+char mi_format_enum_to_char(enum mi_gvar_fmt format);
+enum mi_gvar_lang mi_lang_str_to_enum(const char *lang);
+const char *mi_lang_enum_to_str(enum mi_gvar_lang lang);
+int mi_res_changelist(mi_h *h, mi_gvar_chg **changed);
+int mi_res_children(mi_h *h, mi_gvar *v);
+mi_bkpt *mi_res_bkpt(mi_h *h);
+mi_wp *mi_res_wp(mi_h *h);
+char *mi_res_value(mi_h *h);
+mi_stop *mi_res_stop(mi_h *h);
+enum mi_stop_reason mi_reason_str_to_enum(const char *s);
+const char *mi_reason_enum_to_str(enum mi_stop_reason r);
+int mi_get_read_memory(mi_h *h, unsigned char *dest, unsigned ws, int *na,
+                       unsigned long *addr);
+mi_asm_insns *mi_get_asm_insns(mi_h *h);
+/* Starting point of the program. */
+void mi_set_main_func(const char *name);
+const char *mi_get_main_func();
+mi_chg_reg *mi_get_list_registers(mi_h *h, int *how_many);
+int mi_get_list_registers_l(mi_h *h, mi_chg_reg *l);
+mi_chg_reg *mi_get_list_changed_regs(mi_h *h);
+int mi_get_reg_values(mi_h *h, mi_chg_reg *l);
+mi_chg_reg *mi_get_reg_values_l(mi_h *h, int *how_many);
+int gmi_target_download(mi_h *h);
+
+/* Allocation functions: */
+void *mi_calloc(size_t count, size_t sz);
+void *mi_calloc1(size_t sz);
+char *mi_malloc(size_t sz);
+mi_results       *mi_alloc_results(void);
+mi_output        *mi_alloc_output(void);
+mi_frames        *mi_alloc_frames(void);
+mi_gvar          *mi_alloc_gvar(void);
+mi_gvar_chg      *mi_alloc_gvar_chg(void);
+mi_bkpt          *mi_alloc_bkpt(void);
+mi_wp            *mi_alloc_wp(void);
+mi_stop          *mi_alloc_stop(void);
+mi_asm_insns     *mi_alloc_asm_insns(void);
+mi_asm_insn      *mi_alloc_asm_insn(void);
+mi_chg_reg       *mi_alloc_chg_reg(void);
+void mi_free_output(mi_output *r);
+void mi_free_output_but(mi_output *r, mi_output *no, mi_results *no_r);
+void mi_free_frames(mi_frames *f);
+void mi_free_aux_term(mi_aux_term *t);
+void mi_free_results(mi_results *r);
+void mi_free_results_but(mi_results *r, mi_results *no);
+void mi_free_gvar(mi_gvar *v);
+void mi_free_gvar_chg(mi_gvar_chg *p);
+void mi_free_wp(mi_wp *wp);
+void mi_free_stop(mi_stop *s);
+void mi_free_asm_insns(mi_asm_insns *i);
+void mi_free_asm_insn(mi_asm_insn *i);
+void mi_free_charp_list(char **l);
+void mi_free_chg_reg(mi_chg_reg *r);
+
+/* Porgram control: */
+/* Specify the executable and arguments for local debug. */
+int gmi_set_unwind_on_signal_on(mi_h * h);
+int gmi_set_exec(mi_h *h, const char *file, const char *args);
+/* Start running the executable. Remote sessions starts running. */
+int gmi_exec_run(mi_h *h);
+/* Continue the execution after a "stop". */
+int gmi_exec_continue(mi_h *h);
+/* Continue the execution in reverse order after a "stop". */
+int gmi_exec_continue_reverse(mi_h *h);
+/* Indicate which terminal will use the target program. For local sessions. */
+int gmi_target_terminal(mi_h *h, const char *tty_name);
+/* Specify what's the local copy that have debug info. For remote sessions. */
+int gmi_file_symbol_file(mi_h *h, const char *file);
+/* Continue until function return, the return value is included in the async
+   response. */
+int gmi_exec_finish(mi_h *h);
+/* Continue backwardly until function return, the return value is included in
+  the async response.*/
+int gmi_exec_finish_reverse(mi_h *h);
+/* Stop the program using SIGINT. */
+int gmi_exec_interrupt(mi_h *h);
+/* Next line of code. */
+int gmi_exec_next(mi_h *h);
+/* Start recording a process */
+int gmi_exec_record_process(mi_h *h);
+/* Stop recording a process */
+int gmi_exec_record_stop(mi_h *h);
+/* Next count lines of code. */
+int gmi_exec_next_cnt(mi_h *h, int count);
+/* Next line of assembler code. */
+int gmi_exec_next_instruction(mi_h *h);
+/* Next line of code. Get inside functions. */
+int gmi_exec_step(mi_h *h);
+/* Previous line of code. Get inside functions. */
+int gmi_exec_step_back(mi_h *h);
+/*  Previous line of code (do not step into).*/
+int gmi_exec_next_reverse(mi_h *h);
+/* Next count lines of code. Get inside functions. */
+int gmi_exec_step_cnt(mi_h *h, int count);
+/* Next line of assembler code. Get inside calls. */
+int gmi_exec_step_instruction(mi_h *h);
+/* Execute until location is reached. If file is NULL then is until next line. */
+int gmi_exec_until(mi_h *h, const char *file, int line);
+int gmi_exec_until_addr(mi_h *h, void *addr);
+/* Return to previous frame inmediatly. */
+mi_frames *gmi_exec_return(mi_h *h);
+/* Just kill the program. Please read the notes in prg_control.c. */
+int gmi_exec_kill(mi_h *h);
+
+/* Target manipulation: */
+/* Connect to a remote gdbserver using the specified methode. */
+int gmi_target_select(mi_h *h, const char *type, const char *params);
+/* Attach to an already running process. */
+mi_frames *gmi_target_attach(mi_h *h, pid_t pid);
+/* Detach from an attached process. */
+int gmi_target_detach(mi_h *h);
+
+/* Miscellaneous commands: */
+/* Exit gdb killing the child is it is running. */
+void gmi_gdb_exit(mi_h *h);
+/* Send the version to the console. */
+int gmi_gdb_version(mi_h *h);
+/* Set a gdb variable. */
+int gmi_gdb_set(mi_h *h, const char *var, const char *val);
+/* Get a gdb variable. */
+char *gmi_gdb_show(mi_h *h, const char *var);
+
+/* Breakpoints manipulation: */
+/* Insert a breakpoint at file:line. */
+mi_bkpt *gmi_break_insert(mi_h *h, const char *file, int line);
+/* Insert a breakpoint, all available options. */
+mi_bkpt *gmi_break_insert_full(mi_h *h, int temporary, int hard_assist,
+                               const char *cond, int count, int thread,
+                               const char *where);
+mi_bkpt *gmi_break_insert_full_fl(mi_h *h, const char *file, int line,
+                                  int temporary, int hard_assist,
+                                  const char *cond, int count, int thread);
+/* Remove a breakpoint. */
+int gmi_break_delete(mi_h *h, int number);
+/* Free the memory used for a breakpoint description. */
+void mi_free_bkpt(mi_bkpt *b);
+/* Modify the "ignore" count for a breakpoint. */
+int gmi_break_set_times(mi_h *h, int number, int count);
+/* Associate a condition with the breakpoint. */
+int gmi_break_set_condition(mi_h *h, int number, const char *condition);
+/* Enable or disable a breakpoint. */
+int gmi_break_state(mi_h *h, int number, int enable);
+/* Set a watchpoint. It doesn't work for remote targets! */
+mi_wp *gmi_break_watch(mi_h *h, enum mi_wp_mode mode, const char *exp);
+
+/* Data Manipulation. */
+/* Evaluate an expression. Returns a parsed tree. */
+char *gmi_data_evaluate_expression(mi_h *h, const char *expression);
+/* Path for sources. */
+int gmi_dir(mi_h *h, const char *path);
+/* A very limited "data read memory" implementation. */
+int gmi_read_memory(mi_h *h, const char *exp, unsigned size,
+                    unsigned char *dest, int *na, int convAddr,
+                    unsigned long *addr);
+mi_asm_insns *gmi_data_disassemble_se(mi_h *h, const char *start,
+                                      const char *end, int mode);
+mi_asm_insns *gmi_data_disassemble_fl(mi_h *h, const char *file, int line,
+                                      int lines, int mode);
+mi_chg_reg *gmi_data_list_register_names(mi_h *h, int *how_many);
+int gmi_data_list_register_names_l(mi_h *h, mi_chg_reg *l);
+mi_chg_reg *gmi_data_list_changed_registers(mi_h *h);
+int gmi_data_list_register_values(mi_h *h, enum mi_gvar_fmt fmt, mi_chg_reg *l);
+mi_chg_reg *gmi_data_list_all_register_values(mi_h *h, enum mi_gvar_fmt fmt, int *how_many);
+
+/* Stack manipulation. */
+/* List of frames. Arguments aren't filled. */
+mi_frames *gmi_stack_list_frames(mi_h *h);
+/* List of frames. Indicating a range. */
+mi_frames *gmi_stack_list_frames_r(mi_h *h, int from, int to);
+/* List arguments. Only level and args filled. */
+mi_frames *gmi_stack_list_arguments(mi_h *h, int show);
+/* List arguments. Indicating a range. Only level and args filled. */
+mi_frames *gmi_stack_list_arguments_r(mi_h *h, int show, int from, int to);
+/* Information about the current frame, including args. */
+mi_frames *gmi_stack_info_frame(mi_h *h);
+/* Stack info depth. error => -1 */
+int gmi_stack_info_depth_get(mi_h *h);
+/* Set stack info depth. error => -1 */
+int gmi_stack_info_depth(mi_h *h, int max_depth);
+/* Change current frame. */
+int gmi_stack_select_frame(mi_h *h, int framenum);
+/* List of local vars. */
+mi_results *gmi_stack_list_locals(mi_h *h, int show);
+
+/* Thread. */
+/* List available thread ids. */
+int gmi_thread_list_ids(mi_h *h, int **list);
+/* Select a thread. */
+mi_frames *gmi_thread_select(mi_h *h, int id);
+/* List available threads. */
+mi_frames *gmi_thread_list_all_threads(mi_h *h);
+
+/* Variable objects. */
+/* Create a variable object. */
+mi_gvar *gmi_var_create_nm(mi_h *h, const char *name, int frame, const char *exp);
+mi_gvar *gmi_var_create(mi_h *h, int frame, const char *exp);
+/* Create the variable and also fill the lang and attr fields. */
+mi_gvar *gmi_full_var_create(mi_h *h, int frame, const char *exp);
+/* Delete a variable object. Doesn't free the mi_gvar data. */
+int gmi_var_delete(mi_h *h, mi_gvar *var);
+/* Set the format used to represent the result. */
+int gmi_var_set_format(mi_h *h, mi_gvar *var, enum mi_gvar_fmt format);
+/* Fill the format field with info from gdb. */
+int gmi_var_show_format(mi_h *h, mi_gvar *var);
+/* Fill the numchild field with info from gdb. */
+int gmi_var_info_num_children(mi_h *h, mi_gvar *var);
+/* Fill the type field with info from gdb. */
+int gmi_var_info_type(mi_h *h, mi_gvar *var);
+/* Fill the expression and lang fields with info from gdb.
+   Note that lang isn't filled during creation. */
+int gmi_var_info_expression(mi_h *h, mi_gvar *var);
+/* Fill the attr field with info from gdb.
+   Note that attr isn't filled during creation. */
+int gmi_var_show_attributes(mi_h *h, mi_gvar *var);
+/* Update variable. Use NULL for all.
+   Note that *changed can be NULL if none updated. */
+int gmi_var_update(mi_h *h, mi_gvar *var, mi_gvar_chg **changed);
+/* Change variable. Fills the value field. */
+int gmi_var_assign(mi_h *h, mi_gvar *var, const char *expression);
+/* Get current value for a variable. */
+int gmi_var_evaluate_expression(mi_h *h, mi_gvar *var);
+/* List children. It ONLY returns the first level information. :-( */
+int gmi_var_list_children(mi_h *h, mi_gvar *var);
+
+
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/pathologist/src/include/monkey_common.h b/pathologist/src/include/monkey_common.h
new file mode 100644
index 0000000..4973ac5
--- /dev/null
+++ b/pathologist/src/include/monkey_common.h
@@ -0,0 +1,443 @@
+/**
+ * @file monkey_common.h
+ * @brief commonly used definitions
+ * @author Safey A.Halim
+ */
+
+#ifndef MONKEY_COMMON_H
+#define MONKEY_COMMON_H
+
+#include <stdio.h>
+/**
+ * Named constants for return values.
+ */
+#define MONKEY_OK      1
+#define MONKEY_SYSERR -1
+#define MONKEY_YES     1
+#define MONKEY_NO      0
+
+/**
+ * Use this for fatal errors that cannot be handled
+ */
+#define MONKEY_assert(cond) do { if (! (cond)) { fprintf(stderr, "Assertion failed at %s:%d.\n", __FILE__, __LINE__); abort(); } } while(0)
+
+/**
+ * Use this for fatal errors that cannot be handled
+ */
+#define MONKEY_assert_at(cond, f, l) do { if (! (cond)) { fprintf(stderr, "Assertion failed at %s:%d.\n", f, l); abort(); } } while(0)
+
+/**
+ * Use this for internal assertion violations that are
+ * not fatal (can be handled) but should not occur.
+ */
+#define MONKEY_break(cond)  do { if (! (cond)) { fprintf(stderr, "Assertion failed at %s:%d.\n", __FILE__, __LINE__); } } while(0)
+
+
+/* ******************** doubly-linked list *************** */
+/* To avoid mistakes: head->prev == tail->next == NULL     */
+
+/**
+ * Insert an element at the head of a DLL. Assumes that head, tail and
+ * element are structs with prev and next fields.
+ *
+ * @param head pointer to the head of the DLL
+ * @param tail pointer to the tail of the DLL
+ * @param element element to insert
+ */
+#define MONKEY_CONTAINER_DLL_insert(head,tail,element) do { \
+  MONKEY_assert ( ( (element)->prev == NULL) && ((head) != (element))); \
+  MONKEY_assert ( ( (element)->next == NULL) && ((tail) != (element))); \
+  (element)->next = (head); \
+  (element)->prev = NULL; \
+  if ((tail) == NULL) \
+    (tail) = element; \
+  else \
+    (head)->prev = element; \
+  (head) = (element); } while (0)
+
+
+/**
+ * Insert an element at the tail of a DLL. Assumes that head, tail and
+ * element are structs with prev and next fields.
+ *
+ * @param head pointer to the head of the DLL
+ * @param tail pointer to the tail of the DLL
+ * @param element element to insert
+ */
+#define MONKEY_CONTAINER_DLL_insert_tail(head,tail,element) do { \
+  MONKEY_assert ( ( (element)->prev == NULL) && ((head) != (element))); \
+  MONKEY_assert ( ( (element)->next == NULL) && ((tail) != (element))); \
+  (element)->prev = (tail); \
+  (element)->next = NULL; \
+  if ((head) == NULL) \
+    (head) = element; \
+  else \
+    (tail)->next = element; \
+  (tail) = (element); } while (0)
+
+
+/**
+ * Insert an element into a DLL after the given other element.  Insert
+ * at the head if the other element is NULL.
+ *
+ * @param head pointer to the head of the DLL
+ * @param tail pointer to the tail of the DLL
+ * @param other prior element, NULL for insertion at head of DLL
+ * @param element element to insert
+ */
+#define MONKEY_CONTAINER_DLL_insert_after(head,tail,other,element) do { \
+  MONKEY_assert ( ( (element)->prev == NULL) && ((head) != (element))); \
+  MONKEY_assert ( ( (element)->next == NULL) && ((tail) != (element))); \
+  (element)->prev = (other); \
+  if (NULL == other) \
+    { \
+      (element)->next = (head); \
+      (head) = (element); \
+    } \
+  else \
+    { \
+      (element)->next = (other)->next; \
+      (other)->next = (element); \
+    } \
+  if (NULL == (element)->next) \
+    (tail) = (element); \
+  else \
+    (element)->next->prev = (element); } while (0)
+
+
+/**
+ * Insert an element into a DLL before the given other element.  Insert
+ * at the tail if the other element is NULL.
+ *
+ * @param head pointer to the head of the DLL
+ * @param tail pointer to the tail of the DLL
+ * @param other prior element, NULL for insertion at head of DLL
+ * @param element element to insert
+ */
+#define MONKEY_CONTAINER_DLL_insert_before(head,tail,other,element) do { \
+  MONKEY_assert ( ( (element)->prev == NULL) && ((head) != (element))); \
+  MONKEY_assert ( ( (element)->next == NULL) && ((tail) != (element))); \
+  (element)->next = (other); \
+  if (NULL == other) \
+    { \
+      (element)->prev = (tail); \
+      (tail) = (element); \
+    } \
+  else \
+    { \
+      (element)->prev = (other)->prev; \
+      (other)->prev = (element); \
+    } \
+  if (NULL == (element)->prev) \
+    (head) = (element); \
+  else \
+    (element)->prev->next = (element); } while (0)
+
+
+/**
+ * Remove an element from a DLL. Assumes
+ * that head, tail and element are structs
+ * with prev and next fields.
+ *
+ * @param head pointer to the head of the DLL
+ * @param tail pointer to the tail of the DLL
+ * @param element element to remove
+ */
+#define MONKEY_CONTAINER_DLL_remove(head,tail,element) do { \
+  MONKEY_assert ( ( (element)->prev != NULL) || ((head) == (element))); \
+  MONKEY_assert ( ( (element)->next != NULL) || ((tail) == (element))); \
+  if ((element)->prev == NULL) \
+    (head) = (element)->next;  \
+  else \
+    (element)->prev->next = (element)->next; \
+  if ((element)->next == NULL) \
+    (tail) = (element)->prev;  \
+  else \
+    (element)->next->prev = (element)->prev; \
+  (element)->next = NULL; \
+  (element)->prev = NULL; } while (0)
+
+
+#define MONKEY_MIN(a,b) (((a) < (b)) ? (a) : (b))
+
+#define MONKEY_MAX(a,b) (((a) > (b)) ? (a) : (b))
+
+/* ************************* allocation functions ****************** */
+
+/**
+ * Maximum allocation with MONKEY_malloc macro.
+ */
+#define MONKEY_MAX_MALLOC_CHECKED (1024 * 1024 * 40)
+
+/**
+ * Wrapper around malloc. Allocates size bytes of memory.
+ * The memory will be zero'ed out.
+ *
+ * @param size the number of bytes to allocate, must be
+ *        smaller than 40 MB.
+ * @return pointer to size bytes of memory, never NULL (!)
+ */
+#define MONKEY_malloc(size) MONKEY_xmalloc_(size, __FILE__, __LINE__)
+
+/**
+ * Allocate and initialize a block of memory.
+ *
+ * @param buf data to initalize the block with
+ * @param size the number of bytes in buf (and size of the allocation)
+ * @return pointer to size bytes of memory, never NULL (!)
+ */
+#define MONKEY_memdup(buf,size) MONKEY_xmemdup_(buf, size, __FILE__, __LINE__)
+
+/**
+ * Wrapper around malloc. Allocates size bytes of memory.
+ * The memory will be zero'ed out.
+ *
+ * @param size the number of bytes to allocate
+ * @return pointer to size bytes of memory, NULL if we do not have enough memory
+ */
+#define MONKEY_malloc_large(size) MONKEY_xmalloc_unchecked_(size, __FILE__, __LINE__)
+
+/**
+ * Wrapper around realloc. Rellocates size bytes of memory.
+ *
+ * @param ptr the pointer to reallocate
+ * @param size the number of bytes to reallocate
+ * @return pointer to size bytes of memory
+ */
+#define MONKEY_realloc(ptr, size) MONKEY_xrealloc_(ptr, size, __FILE__, __LINE__)
+
+/**
+ * Wrapper around free. Frees the memory referred to by ptr.
+ * Note that is is generally better to free memory that was
+ * allocated with MONKEY_array_grow using MONKEY_array_grow(mem, size, 0) instead of MONKEY_free.
+ *
+ * @param ptr location where to free the memory. ptr must have
+ *     been returned by MONKEY_strdup, MONKEY_strndup, MONKEY_malloc or MONKEY_array_grow earlier.
+ */
+#define MONKEY_free(ptr) MONKEY_xfree_(ptr, __FILE__, __LINE__)
+
+/**
+ * Free the memory pointed to by ptr if ptr is not NULL.
+ * Equivalent to if (ptr!=null)MONKEY_free(ptr).
+ *
+ * @param ptr the location in memory to free
+ */
+#define MONKEY_free_non_null(ptr) do { void * __x__ = ptr; if (__x__ != NULL) { MONKEY_free(__x__); } } while(0)
+
+/**
+ * Wrapper around MONKEY_strdup.  Makes a copy of the zero-terminated string
+ * pointed to by a.
+ *
+ * @param a pointer to a zero-terminated string
+ * @return a copy of the string including zero-termination
+ */
+#define MONKEY_strdup(a) MONKEY_xstrdup_(a,__FILE__,__LINE__)
+
+/**
+ * Wrapper around MONKEY_strndup.  Makes a partial copy of the string
+ * pointed to by a.
+ *
+ * @param a pointer to a string
+ * @param length of the string to duplicate
+ * @return a partial copy of the string including zero-termination
+ */
+#define MONKEY_strndup(a,length) MONKEY_xstrndup_(a,length,__FILE__,__LINE__)
+
+/**
+ * Grow a well-typed (!) array.  This is a convenience
+ * method to grow a vector <tt>arr</tt> of size <tt>size</tt>
+ * to the new (target) size <tt>tsize</tt>.
+ * <p>
+ *
+ * Example (simple, well-typed stack):
+ *
+ * <pre>
+ * static struct foo * myVector = NULL;
+ * static int myVecLen = 0;
+ *
+ * static void push(struct foo * elem) {
+ *   MONKEY_array_grow(myVector, myVecLen, myVecLen+1);
+ *   memcpy(&myVector[myVecLen-1], elem, sizeof(struct foo));
+ * }
+ *
+ * static void pop(struct foo * elem) {
+ *   if (myVecLen == 0) die();
+ *   memcpy(elem, myVector[myVecLen-1], sizeof(struct foo));
+ *   MONKEY_array_grow(myVector, myVecLen, myVecLen-1);
+ * }
+ * </pre>
+ *
+ * @param arr base-pointer of the vector, may be NULL if size is 0;
+ *        will be updated to reflect the new address. The TYPE of
+ *        arr is important since size is the number of elements and
+ *        not the size in bytes
+ * @param size the number of elements in the existing vector (number
+ *        of elements to copy over)
+ * @param tsize the target size for the resulting vector, use 0 to
+ *        free the vector (then, arr will be NULL afterwards).
+ */
+#define MONKEY_array_grow(arr,size,tsize) MONKEY_xgrow_((void**)&arr, sizeof(arr[0]), &size, tsize, __FILE__, __LINE__)
+
+/**
+ * Append an element to a list (growing the
+ * list by one).
+ */
+#define MONKEY_array_append(arr,size,element) do { MONKEY_array_grow(arr,size,size+1); arr[size-1] = element; } while(0)
+
+/**
+ * Like snprintf, just aborts if the buffer is of insufficient size.
+ *
+ * @param buf pointer to buffer that is written to
+ * @param size number of bytes in buf
+ * @param format format strings
+ * @param ... data for format string
+ * @return number of bytes written to buf or negative value on error
+ */
+int
+MONKEY_snprintf (char *buf, size_t size, const char *format, ...);
+
+
+/**
+ * Like asprintf, just portable.
+ *
+ * @param buf set to a buffer of sufficient size (allocated, caller must free)
+ * @param format format string (see printf, fprintf, etc.)
+ * @param ... data for format string
+ * @return number of bytes in "*buf" excluding 0-termination
+ */
+int
+MONKEY_asprintf (char **buf, const char *format, ...);
+
+
+/**
+ * Replace all occurrences of a substring in a string
+ * @param string target string
+ * @param substr substring to replace
+ * @param replacement substitution of the substring
+ */
+char *
+MONKEY_str_replace_all ( const char *string, const char *substr, const char *replacement );
+
+/* ************** internal implementations, use macros above! ************** */
+
+/**
+ * Allocate memory. Checks the return value, aborts if no more
+ * memory is available.  Don't use MONKEY_xmalloc_ directly. Use the
+ * MONKEY_malloc macro.
+ * The memory will be zero'ed out.
+ *
+ * @param size number of bytes to allocate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return allocated memory, never NULL
+ */
+void *
+MONKEY_xmalloc_ (size_t size, const char *filename, int linenumber);
+
+
+
+/**
+ * Allocate and initialize memory. Checks the return value, aborts if no more
+ * memory is available.  Don't use MONKEY_xmemdup_ directly. Use the
+ * MONKEY_memdup macro.
+ *
+ * @param buf buffer to initialize from (must contain size bytes)
+ * @param size number of bytes to allocate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return allocated memory, never NULL
+ */
+void *
+MONKEY_xmemdup_ (const void *buf, size_t size, const char *filename,
+                 int linenumber);
+
+
+/**
+ * Allocate memory.  This function does not check if the allocation
+ * request is within reasonable bounds, allowing allocations larger
+ * than 40 MB.  If you don't expect the possibility of very large
+ * allocations, use MONKEY_malloc instead.  The memory will be zero'ed
+ * out.
+ *
+ * @param size number of bytes to allocate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return pointer to size bytes of memory, NULL if we do not have enough memory
+ */
+void *
+MONKEY_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber);
+
+/**
+ * Reallocate memory. Checks the return value, aborts if no more
+ * memory is available.
+ */
+void *
+MONKEY_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber);
+
+/**
+ * Free memory. Merely a wrapper for the case that we
+ * want to keep track of allocations.  Don't use MONKEY_xfree_
+ * directly. Use the MONKEY_free macro.
+ *
+ * @param ptr pointer to memory to free
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ */
+void
+MONKEY_xfree_ (void *ptr, const char *filename, int linenumber);
+
+
+/**
+ * Dup a string. Don't call MONKEY_xstrdup_ directly. Use the MONKEY_strdup macro.
+ * @param str string to duplicate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return the duplicated string
+ */
+char *
+MONKEY_xstrdup_ (const char *str, const char *filename, int linenumber);
+
+/**
+ * Dup partially a string. Don't call MONKEY_xstrndup_ directly. Use the MONKEY_strndup macro.
+ *
+ * @param str string to duplicate
+ * @param len length of the string to duplicate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return the duplicated string
+ */
+char *
+MONKEY_xstrndup_ (const char *str, size_t len, const char *filename,
+                  int linenumber);
+
+/**
+ * Grow an array, the new elements are zeroed out.
+ * Grows old by (*oldCount-newCount)*elementSize
+ * bytes and sets *oldCount to newCount.
+ *
+ * Don't call MONKEY_xgrow_ directly. Use the MONKEY_array_grow macro.
+ *
+ * @param old address of the pointer to the array
+ *        *old may be NULL
+ * @param elementSize the size of the elements of the array
+ * @param oldCount address of the number of elements in the *old array
+ * @param newCount number of elements in the new array, may be 0 (then *old will be NULL afterwards)
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ */
+void
+MONKEY_xgrow_ (void **old, size_t elementSize, unsigned int *oldCount,
+               unsigned int newCount, const char *filename, int linenumber);
+
+
+
+
+#if __STDC_VERSION__ < 199901L
+#if __GNUC__ >= 2
+#define __func__ __FUNCTION__
+#else
+#define __func__ "<unknown>"
+#endif
+#endif
+
+#endif /* MONKEY_COMMON_H */
diff --git a/pathologist/src/include/monkey_getopt_lib.h b/pathologist/src/include/monkey_getopt_lib.h
new file mode 100644
index 0000000..50d9cc1
--- /dev/null
+++ b/pathologist/src/include/monkey_getopt_lib.h
@@ -0,0 +1,367 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2005, 2006, 2009, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file include/gnunet_getopt_lib.h
+ * @brief command line parsing and --help formatting
+ *
+ * @author Christian Grothoff
+ */
+
+#ifndef MONKEY_GETOPT_LIB_H
+#define MONKEY_GETOPT_LIB_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+//#include "gnunet_configuration_lib.h"
+
+/**
+ * @brief General context for command line processors.
+ */
+struct MONKEY_GETOPT_CommandLineProcessorContext
+{
+
+  /**
+   * Name of the application
+   */
+  const char *binaryName;
+
+  /**
+   * Name of application with option summary
+   */
+  const char *binaryOptions;
+
+  /**
+   * Array with all command line options.
+   */
+  const struct MONKEY_GETOPT_CommandLineOption *allOptions;
+
+  /**
+   * Original command line
+   */
+  char *const *argv;
+
+  /**
+   * Total number of argv's.
+   */
+  unsigned int argc;
+
+  /**
+   * Current argument.
+   */
+  unsigned int currentArgument;
+
+};
+
+/**
+ * @brief Process a command line option
+ *
+ * @param ctx context for all options
+ * @param scls specific closure (for this processor)
+ * @param option long name of the option (i.e. "config" for --config)
+ * @param value argument, NULL if none was given
+ * @return MONKEY_OK to continue processing other options, MONKEY_SYSERR to abort
+ */
+typedef int (*MONKEY_GETOPT_CommandLineOptionProcessor) (struct
+                                                         MONKEY_GETOPT_CommandLineProcessorContext
+                                                         * ctx, void *scls,
+                                                         const char *option,
+                                                         const char *value);
+
+/**
+ * @brief Definition of a command line option.
+ */
+struct MONKEY_GETOPT_CommandLineOption
+{
+
+  /**
+   * Short name of the option (use '\\0' for none).
+   */
+  const char shortName;
+
+  /**
+   * Long name of the option (may not be NULL)
+   */
+  const char *name;
+
+  /**
+   * Name of the argument for the user in help text
+   */
+  const char *argumentHelp;
+
+  /**
+   * Help text for the option (description)
+   */
+  const char *description;
+
+  /**
+   * Is an argument required?  0: MONKEY_NO (includes optional), 1: MONKEY_YES.
+   */
+  int require_argument;
+
+  /**
+   * Handler for the option.
+   */
+  MONKEY_GETOPT_CommandLineOptionProcessor processor;
+
+  /**
+   * Specific closure to pass to the processor.
+   */
+  void *scls;
+
+};
+
+/**
+ * Macro defining the option to print the command line
+ * help text (-h option).
+ *
+ * @param about string with brief description of the application
+ */
+#define MONKEY_GETOPT_OPTION_HELP(about) \
+  { 'h', "help", (const char *) NULL, gettext_noop("print this help"), 0, &MONKEY_GETOPT_format_help_, (void *) about }
+
+
+/**
+ * Macro defining the option to print the version of
+ * the application (-v option)
+ *
+ * @param version string with the version number
+ */
+#define MONKEY_GETOPT_OPTION_VERSION(version) \
+  { 'v', "version", (const char *) NULL, gettext_noop("print the version number"), 0, &MONKEY_GETOPT_print_version_, (void *) version }
+
+
+/**
+ * Allow user to specify log file name (-l option)
+ *
+ * @param logfn set to the name of the logfile
+ */
+#define MONKEY_GETOPT_OPTION_LOGFILE(logfn)                             \
+  { 'l', "logfile", "LOGFILE", gettext_noop("configure logging to write logs to LOGFILE"), 1, &MONKEY_GETOPT_set_string, (void *) logfn }
+
+
+/**
+ * Allow user to specify log level (-L option)
+ *
+ * @param loglev set to the log level
+ */
+#define MONKEY_GETOPT_OPTION_LOGLEVEL(loglev)                           \
+  { 'L', "log", "LOGLEVEL", gettext_noop("configure logging to use LOGLEVEL"), 1, &MONKEY_GETOPT_set_string, (void *) loglev }
+
+
+/**
+ * Get number of verbose (-V) flags
+ *
+ * @param level where to store the verbosity level (should be an 'int')
+ */
+#define MONKEY_GETOPT_OPTION_VERBOSE(level)                             \
+  { 'V', "verbose", (const char *) NULL, gettext_noop("be verbose"), 0, &MONKEY_GETOPT_increment_value, (void *) level }
+
+
+/**
+ * Get configuration file name (-c option)
+ *
+ * @param fn set to the configuration file name
+ */
+#define MONKEY_GETOPT_OPTION_CFG_FILE(fn)                               \
+  { 'c', "config", "FILENAME", gettext_noop("use configuration file FILENAME"), 1, &MONKEY_GETOPT_set_string, (void *) fn }
+
+
+/**
+ * Marker for the end of the list of options.
+ */
+#define MONKEY_GETOPT_OPTION_END \
+  { '\0', NULL, NULL, NULL, 0, NULL, NULL }
+
+
+/**
+ * Parse the command line.
+ *
+ * @param binaryOptions Name of application with option summary
+ * @param allOptions defined options and handlers
+ * @param argc number of arguments
+ * @param argv actual arguments
+ * @return index into argv with first non-option
+ *   argument, or MONKEY_SYSERR on error
+ */
+int
+MONKEY_GETOPT_run (const char *binaryOptions,
+                   const struct MONKEY_GETOPT_CommandLineOption *allOptions,
+                   unsigned int argc, char *const *argv);
+
+
+/**
+ * Set an option of type 'unsigned long long' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'unsigned long long'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'unsigned long long')
+ * @param option name of the option
+ * @param value actual value of the option as a string.
+ * @return MONKEY_OK if parsing the value worked
+ */
+int
+MONKEY_GETOPT_set_ulong (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                         void *scls, const char *option, const char *value);
+
+
+/**
+ * Set an option of type 'struct MONKEY_TIME_Relative' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'struct MONKEY_TIME_Relative'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'struct MONKEY_TIME_Relative')
+ * @param option name of the option
+ * @param value actual value of the option as a string.
+ * @return MONKEY_OK if parsing the value worked
+ */
+int
+MONKEY_GETOPT_set_relative_time (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                                 void *scls, const char *option, const char *value);
+
+
+/**
+ * Set an option of type 'unsigned int' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'unsigned int'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'unsigned int')
+ * @param option name of the option
+ * @param value actual value of the option as a string.
+ * @return MONKEY_OK if parsing the value worked
+ */
+int
+MONKEY_GETOPT_set_uint (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                        void *scls, const char *option, const char *value);
+
+
+/**
+ * Set an option of type 'int' from the command line to 1 if the
+ * given option is present.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'int'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'int')
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_OK
+ */
+int
+MONKEY_GETOPT_set_one (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                       void *scls, const char *option, const char *value);
+
+
+/**
+ * Set an option of type 'char *' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'char *'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'char *',
+ *             which will be allocated)
+ * @param option name of the option
+ * @param value actual value of the option (a string)
+ * @return MONKEY_OK
+ */
+int
+MONKEY_GETOPT_set_string (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                          void *scls, const char *option, const char *value);
+
+/**
+ * Set an option of type 'unsigned int' from the command line. Each
+ * time the option flag is given, the value is incremented by one.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'int'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'int')
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_OK
+ */
+int
+MONKEY_GETOPT_increment_value (struct MONKEY_GETOPT_CommandLineProcessorContext
+                               *ctx, void *scls, const char *option,
+                               const char *value);
+
+
+/* *************** internal prototypes - use macros above! ************* */
+
+/**
+ * Print out details on command line options (implements --help).
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (points to about text)
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_SYSERR (do not continue)
+ */
+int
+MONKEY_GETOPT_format_help_ (struct MONKEY_GETOPT_CommandLineProcessorContext
+                            *ctx, void *scls, const char *option,
+                            const char *value);
+
+/**
+ * Print out program version (implements --version).
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (points to version string)
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_SYSERR (do not continue)
+ */
+int
+MONKEY_GETOPT_print_version_ (struct MONKEY_GETOPT_CommandLineProcessorContext
+                              *ctx, void *scls, const char *option,
+                              const char *value);
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+
+/* ifndef MONKEY_GETOPT_LIB_H */
+#endif
+/* end of gnunet_getopt_lib.h */
diff --git a/pathologist/src/include/mxml.h b/pathologist/src/include/mxml.h
new file mode 100644
index 0000000..79c711f
--- /dev/null
+++ b/pathologist/src/include/mxml.h
@@ -0,0 +1,329 @@
+/*
+ * "$Id: mxml.h 427 2011-01-03 02:03:29Z mike $"
+ *
+ * Header file for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ */
+
+/*
+ * Prevent multiple inclusion...
+ */
+
+#ifndef _mxml_h_
+#  define _mxml_h_
+
+/*
+ * Include necessary headers...
+ */
+
+#  include <stdio.h>
+#  include <stdlib.h>
+#  include <string.h>
+#  include <ctype.h>
+#  include <errno.h>
+
+
+/*
+ * Constants...
+ */
+
+#  define MXML_TAB              8       /* Tabs every N columns */
+
+#  define MXML_NO_CALLBACK      0       /* Don't use a type callback */
+#  define MXML_INTEGER_CALLBACK mxml_integer_cb
+                                        /* Treat all data as integers */
+#  define MXML_OPAQUE_CALLBACK  mxml_opaque_cb
+                                        /* Treat all data as opaque */
+#  define MXML_REAL_CALLBACK    mxml_real_cb
+                                        /* Treat all data as real numbers */
+#  define MXML_TEXT_CALLBACK    0       /* Treat all data as text */
+#  define MXML_IGNORE_CALLBACK  mxml_ignore_cb
+                                        /* Ignore all non-element content */
+
+#  define MXML_NO_PARENT        0       /* No parent for the node */
+
+#  define MXML_DESCEND          1       /* Descend when finding/walking */
+#  define MXML_NO_DESCEND       0       /* Don't descend when finding/walking */
+#  define MXML_DESCEND_FIRST    -1      /* Descend for first find */
+
+#  define MXML_WS_BEFORE_OPEN   0       /* Callback for before open tag */
+#  define MXML_WS_AFTER_OPEN    1       /* Callback for after open tag */
+#  define MXML_WS_BEFORE_CLOSE  2       /* Callback for before close tag */
+#  define MXML_WS_AFTER_CLOSE   3       /* Callback for after close tag */
+
+#  define MXML_ADD_BEFORE       0       /* Add node before specified node */
+#  define MXML_ADD_AFTER        1       /* Add node after specified node */
+#  define MXML_ADD_TO_PARENT    NULL    /* Add node relative to parent */
+
+
+/*
+ * Data types...
+ */
+
+typedef enum mxml_sax_event_e           /**** SAX event type. ****/
+{
+  MXML_SAX_CDATA,                       /* CDATA node */
+  MXML_SAX_COMMENT,                     /* Comment node */
+  MXML_SAX_DATA,                        /* Data node */
+  MXML_SAX_DIRECTIVE,                   /* Processing directive node */
+  MXML_SAX_ELEMENT_CLOSE,               /* Element closed */
+  MXML_SAX_ELEMENT_OPEN                 /* Element opened */
+} mxml_sax_event_t;
+
+typedef enum mxml_type_e                /**** The XML node type. ****/
+{
+  MXML_IGNORE = -1,                     /* Ignore/throw away node @since Mini-XML 2.3@ */
+  MXML_ELEMENT,                         /* XML element with attributes */
+  MXML_INTEGER,                         /* Integer value */
+  MXML_OPAQUE,                          /* Opaque string */
+  MXML_REAL,                            /* Real value */
+  MXML_TEXT,                            /* Text fragment */
+  MXML_CUSTOM                           /* Custom data @since Mini-XML 2.1@ */
+} mxml_type_t;
+
+typedef void (*mxml_custom_destroy_cb_t)(void *);
+                                        /**** Custom data destructor ****/
+
+typedef void (*mxml_error_cb_t)(const char *);  
+                                        /**** Error callback function ****/
+
+typedef struct mxml_attr_s              /**** An XML element attribute value. @private@ ****/
+{
+  char                  *name;          /* Attribute name */
+  char                  *value;         /* Attribute value */
+} mxml_attr_t;
+
+typedef struct mxml_element_s           /**** An XML element value. @private@ ****/
+{
+  char                  *name;          /* Name of element */
+  int                   num_attrs;      /* Number of attributes */
+  mxml_attr_t           *attrs;         /* Attributes */
+} mxml_element_t;
+
+typedef struct mxml_text_s              /**** An XML text value. @private@ ****/
+{
+  int                   whitespace;     /* Leading whitespace? */
+  char                  *string;        /* Fragment string */
+} mxml_text_t;
+
+typedef struct mxml_custom_s            /**** An XML custom value. @private@ ****/
+{
+  void                  *data;          /* Pointer to (allocated) custom data */
+  mxml_custom_destroy_cb_t destroy;     /* Pointer to destructor function */
+} mxml_custom_t;
+
+typedef union mxml_value_u              /**** An XML node value. @private@ ****/
+{
+  mxml_element_t        element;        /* Element */
+  int                   integer;        /* Integer number */
+  char                  *opaque;        /* Opaque string */
+  double                real;           /* Real number */
+  mxml_text_t           text;           /* Text fragment */
+  mxml_custom_t         custom;         /* Custom data @since Mini-XML 2.1@ */
+} mxml_value_t;
+
+struct mxml_node_s                      /**** An XML node. @private@ ****/
+{
+  mxml_type_t           type;           /* Node type */
+  struct mxml_node_s    *next;          /* Next node under same parent */
+  struct mxml_node_s    *prev;          /* Previous node under same parent */
+  struct mxml_node_s    *parent;        /* Parent node */
+  struct mxml_node_s    *child;         /* First child node */
+  struct mxml_node_s    *last_child;    /* Last child node */
+  mxml_value_t          value;          /* Node value */
+  int                   ref_count;      /* Use count */
+  void                  *user_data;     /* User data */
+};
+
+typedef struct mxml_node_s mxml_node_t; /**** An XML node. ****/
+
+struct mxml_index_s                      /**** An XML node index. @private@ ****/
+{
+  char                  *attr;          /* Attribute used for indexing or NULL */
+  int                   num_nodes;      /* Number of nodes in index */
+  int                   alloc_nodes;    /* Allocated nodes in index */
+  int                   cur_node;       /* Current node */
+  mxml_node_t           **nodes;        /* Node array */
+};
+
+typedef struct mxml_index_s mxml_index_t;
+                                        /**** An XML node index. ****/
+
+typedef int (*mxml_custom_load_cb_t)(mxml_node_t *, const char *);
+                                        /**** Custom data load callback function ****/
+
+typedef char *(*mxml_custom_save_cb_t)(mxml_node_t *);  
+                                        /**** Custom data save callback function ****/
+
+typedef int (*mxml_entity_cb_t)(const char *);
+                                        /**** Entity callback function */
+
+typedef mxml_type_t (*mxml_load_cb_t)(mxml_node_t *);
+                                        /**** Load callback function ****/
+
+typedef const char *(*mxml_save_cb_t)(mxml_node_t *, int);
+                                        /**** Save callback function ****/
+
+typedef void (*mxml_sax_cb_t)(mxml_node_t *, mxml_sax_event_t, void *);  
+                                        /**** SAX callback function ****/
+
+
+/*
+ * C++ support...
+ */
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif /* __cplusplus */
+
+/*
+ * Prototypes...
+ */
+
+extern void             mxmlAdd(mxml_node_t *parent, int where,
+                                mxml_node_t *child, mxml_node_t *node);
+extern void             mxmlDelete(mxml_node_t *node);
+extern void             mxmlElementDeleteAttr(mxml_node_t *node,
+                                              const char *name);
+extern const char       *mxmlElementGetAttr(mxml_node_t *node, const char *name);
+extern void             mxmlElementSetAttr(mxml_node_t *node, const char *name,
+                                           const char *value);
+extern void             mxmlElementSetAttrf(mxml_node_t *node, const char *name,
+                                            const char *format, ...)
+#    ifdef __GNUC__
+__attribute__ ((__format__ (__printf__, 3, 4)))
+#    endif /* __GNUC__ */
+;
+extern int              mxmlEntityAddCallback(mxml_entity_cb_t cb);
+extern const char       *mxmlEntityGetName(int val);
+extern int              mxmlEntityGetValue(const char *name);
+extern void             mxmlEntityRemoveCallback(mxml_entity_cb_t cb);
+extern mxml_node_t      *mxmlFindElement(mxml_node_t *node, mxml_node_t *top,
+                                         const char *name, const char *attr,
+                                         const char *value, int descend);
+extern mxml_node_t      *mxmlFindPath(mxml_node_t *node, const char *path);
+extern const char       *mxmlGetCDATA(mxml_node_t *node);
+extern const void       *mxmlGetCustom(mxml_node_t *node);
+extern const char       *mxmlGetElement(mxml_node_t *node);
+extern mxml_node_t      *mxmlGetFirstChild(mxml_node_t *node);
+extern int              mxmlGetInteger(mxml_node_t *node);
+extern mxml_node_t      *mxmlGetLastChild(mxml_node_t *node);
+extern mxml_node_t      *mxmlGetNextSibling(mxml_node_t *node);
+extern const char       *mxmlGetOpaque(mxml_node_t *node);
+extern mxml_node_t      *mxmlGetParent(mxml_node_t *node);
+extern mxml_node_t      *mxmlGetPrevSibling(mxml_node_t *node);
+extern double           mxmlGetReal(mxml_node_t *node);
+extern int              mxmlGetRefCount(mxml_node_t *node);
+extern const char       *mxmlGetText(mxml_node_t *node, int *whitespace);
+extern mxml_type_t      mxmlGetType(mxml_node_t *node);
+extern void             *mxmlGetUserData(mxml_node_t *node);
+extern void             mxmlIndexDelete(mxml_index_t *ind);
+extern mxml_node_t      *mxmlIndexEnum(mxml_index_t *ind);
+extern mxml_node_t      *mxmlIndexFind(mxml_index_t *ind,
+                                       const char *element,
+                                       const char *value);
+extern int              mxmlIndexGetCount(mxml_index_t *ind);
+extern mxml_index_t     *mxmlIndexNew(mxml_node_t *node, const char *element,
+                                      const char *attr);
+extern mxml_node_t      *mxmlIndexReset(mxml_index_t *ind);
+extern mxml_node_t      *mxmlLoadFd(mxml_node_t *top, int fd,
+                                    mxml_type_t (*cb)(mxml_node_t *));
+extern mxml_node_t      *mxmlLoadFile(mxml_node_t *top, FILE *fp,
+                                      mxml_type_t (*cb)(mxml_node_t *));
+extern mxml_node_t      *mxmlLoadString(mxml_node_t *top, const char *s,
+                                        mxml_type_t (*cb)(mxml_node_t *));
+extern mxml_node_t      *mxmlNewCDATA(mxml_node_t *parent, const char *string);
+extern mxml_node_t      *mxmlNewCustom(mxml_node_t *parent, void *data,
+                                       mxml_custom_destroy_cb_t destroy);
+extern mxml_node_t      *mxmlNewElement(mxml_node_t *parent, const char *name);
+extern mxml_node_t      *mxmlNewInteger(mxml_node_t *parent, int integer);
+extern mxml_node_t      *mxmlNewOpaque(mxml_node_t *parent, const char *opaque);
+extern mxml_node_t      *mxmlNewReal(mxml_node_t *parent, double real);
+extern mxml_node_t      *mxmlNewText(mxml_node_t *parent, int whitespace,
+                                     const char *string);
+extern mxml_node_t      *mxmlNewTextf(mxml_node_t *parent, int whitespace,
+                                      const char *format, ...)
+#    ifdef __GNUC__
+__attribute__ ((__format__ (__printf__, 3, 4)))
+#    endif /* __GNUC__ */
+;
+extern mxml_node_t      *mxmlNewXML(const char *version);
+extern int              mxmlRelease(mxml_node_t *node);
+extern void             mxmlRemove(mxml_node_t *node);
+extern int              mxmlRetain(mxml_node_t *node);
+extern char             *mxmlSaveAllocString(mxml_node_t *node,
+                                             mxml_save_cb_t cb);
+extern int              mxmlSaveFd(mxml_node_t *node, int fd,
+                                   mxml_save_cb_t cb);
+extern int              mxmlSaveFile(mxml_node_t *node, FILE *fp,
+                                     mxml_save_cb_t cb);
+extern int              mxmlSaveString(mxml_node_t *node, char *buffer,
+                                       int bufsize, mxml_save_cb_t cb);
+extern mxml_node_t      *mxmlSAXLoadFd(mxml_node_t *top, int fd,
+                                       mxml_type_t (*cb)(mxml_node_t *),
+                                       mxml_sax_cb_t sax, void *sax_data);
+extern mxml_node_t      *mxmlSAXLoadFile(mxml_node_t *top, FILE *fp,
+                                         mxml_type_t (*cb)(mxml_node_t *),
+                                         mxml_sax_cb_t sax, void *sax_data);
+extern mxml_node_t      *mxmlSAXLoadString(mxml_node_t *top, const char *s,
+                                           mxml_type_t (*cb)(mxml_node_t *),
+                                           mxml_sax_cb_t sax, void *sax_data);
+extern int              mxmlSetCDATA(mxml_node_t *node, const char *data);
+extern int              mxmlSetCustom(mxml_node_t *node, void *data,
+                                      mxml_custom_destroy_cb_t destroy);
+extern void             mxmlSetCustomHandlers(mxml_custom_load_cb_t load,
+                                              mxml_custom_save_cb_t save);
+extern int              mxmlSetElement(mxml_node_t *node, const char *name);
+extern void             mxmlSetErrorCallback(mxml_error_cb_t cb);
+extern int              mxmlSetInteger(mxml_node_t *node, int integer);
+extern int              mxmlSetOpaque(mxml_node_t *node, const char *opaque);
+extern int              mxmlSetReal(mxml_node_t *node, double real);
+extern int              mxmlSetText(mxml_node_t *node, int whitespace,
+                                    const char *string);
+extern int              mxmlSetTextf(mxml_node_t *node, int whitespace,
+                                     const char *format, ...)
+#    ifdef __GNUC__
+__attribute__ ((__format__ (__printf__, 3, 4)))
+#    endif /* __GNUC__ */
+;
+extern int              mxmlSetUserData(mxml_node_t *node, void *data);
+extern void             mxmlSetWrapMargin(int column);
+extern mxml_node_t      *mxmlWalkNext(mxml_node_t *node, mxml_node_t *top,
+                                      int descend);
+extern mxml_node_t      *mxmlWalkPrev(mxml_node_t *node, mxml_node_t *top,
+                                      int descend);
+
+
+/*
+ * Semi-private functions...
+ */
+
+extern void             mxml_error(const char *format, ...);
+extern mxml_type_t      mxml_ignore_cb(mxml_node_t *node);
+extern mxml_type_t      mxml_integer_cb(mxml_node_t *node);
+extern mxml_type_t      mxml_opaque_cb(mxml_node_t *node);
+extern mxml_type_t      mxml_real_cb(mxml_node_t *node);
+
+
+/*
+ * C++ support...
+ */
+
+#  ifdef __cplusplus
+}
+#  endif /* __cplusplus */
+#endif /* !_mxml_h_ */
+
+
+/*
+ * End of "$Id: mxml.h 427 2011-01-03 02:03:29Z mike $".
+ */
diff --git a/pathologist/src/include/platform.h b/pathologist/src/include/platform.h
new file mode 100644
index 0000000..994a5b6
--- /dev/null
+++ b/pathologist/src/include/platform.h
@@ -0,0 +1,266 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file include/platform.h
+ * @brief plaform specifics
+ *
+ * @author Nils Durner
+ *
+ * This file should never be included by installed
+ * header files (thos starting with "gnunet_").
+ */
+
+#ifndef PLATFORM_H
+#define PLATFORM_H
+
+#ifndef HAVE_USED_CONFIG_H
+#define HAVE_USED_CONFIG_H
+#if HAVE_CONFIG_H
+//#include "gnunet_config.h"
+#endif
+#endif
+
+#ifdef WINDOWS
+#define BREAKPOINT asm("int $3;");
+#define GNUNET_SIGCHLD 17
+#else
+#define BREAKPOINT
+#define GNUNET_SIGCHLD SIGCHLD
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#define ALLOW_EXTRA_CHECKS GNUNET_NO
+
+/**
+ * For strptime (glibc2 needs this).
+ */
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE
+#endif
+
+#ifndef _REENTRANT
+#define _REENTRANT
+#endif
+
+/* configuration options */
+
+#define VERBOSE_STATS 0
+
+#ifdef CYGWIN
+#include <sys/reent.h>
+#endif
+
+#ifdef _MSC_VER
+#ifndef FD_SETSIZE
+#define FD_SETSIZE 1024
+#endif
+#include <Winsock2.h>
+#include <ws2tcpip.h>
+#else
+#ifndef MINGW
+#include <netdb.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#if HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#if HAVE_NETINET_IN_SYSTM_H
+#include <netinet/in_systm.h>
+#endif
+#include <netinet/ip.h>         /* superset of previous */
+#include <arpa/inet.h>
+#include <netinet/tcp.h>
+#include <pwd.h>
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#include <grp.h>
+#else
+#include "winproc.h"
+#endif
+#endif
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <signal.h>
+#include <libgen.h>
+#ifdef WINDOWS
+#include <malloc.h>             /* for alloca(), on other OSes it's in stdlib.h */
+#endif
+#ifndef _MSC_VER
+#include <unistd.h>             /* KLB_FIX */
+#endif
+#include <sys/stat.h>
+#include <sys/types.h>
+#ifndef _MSC_VER
+#include <dirent.h>             /* KLB_FIX */
+#endif
+#include <fcntl.h>
+#include <math.h>
+#if HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+#if TIME_WITH_SYS_TIME
+#include <sys/time.h>
+#include <time.h>
+#else
+#if HAVE_SYS_TIME_H
+#include <sys/time.h>
+#else
+#include <time.h>
+#endif
+#endif
+
+#ifdef SOMEBSD
+#include <net/if.h>
+#endif
+#ifdef GNUNET_freeBSD
+#include <semaphore.h>
+#endif
+#ifdef DARWIN
+#include <dlfcn.h>
+#include <semaphore.h>
+#include <net/if.h>
+#endif
+#if defined(LINUX) || defined(GNU)
+#include <net/if.h>
+#endif
+#ifdef SOLARIS
+#include <sys/sockio.h>
+#include <sys/filio.h>
+#include <sys/loadavg.h>
+#include <semaphore.h>
+#endif
+#if HAVE_UCRED_H
+#include <ucred.h>
+#endif
+#ifdef CYGWIN
+#include <windows.h>
+#include <cygwin/if.h>
+#endif
+#if HAVE_IFADDRS_H
+#include <ifaddrs.h>
+#endif
+#include <errno.h>
+#include <limits.h>
+
+#if HAVE_VFORK_H
+#include <vfork.h>
+#endif
+
+#include <ctype.h>
+#if HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#endif
+
+#if HAVE_ENDIAN_H
+#include <endian.h>
+#endif
+#if HAVE_SYS_ENDIAN_H
+#include <sys/endian.h>
+#endif
+
+#include "plibc.h"
+
+//#include <locale.h>
+//#ifndef FRAMEWORK_BUILD
+//#include "gettext.h"
+///**
+// * GNU gettext support macro.
+// */
+//#define _(String) dgettext("gnunet",String)
+//#define LIBEXTRACTOR_GETTEXT_DOMAIN "libextractor"
+//#else
+//#include "libintlemu.h"
+//#define _(String) dgettext("org.gnunet.gnunet",String)
+//#define LIBEXTRACTOR_GETTEXT_DOMAIN "org.gnunet.libextractor"
+//#endif
+
+#ifdef CYGWIN
+#define SIOCGIFCONF     _IOW('s', 100, struct ifconf)   /* get if list */
+#define SIOCGIFFLAGS    _IOW('s', 101, struct ifreq)    /* Get if flags */
+#define SIOCGIFADDR     _IOW('s', 102, struct ifreq)    /* Get if addr */
+#endif
+
+#ifndef MINGW
+#include <sys/mman.h>
+#endif
+
+#ifdef FREEBSD
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+#endif
+
+#ifdef DARWIN
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+ /* not available on darwin, override configure */
+#undef HAVE_STAT64
+#undef HAVE_MREMAP
+#endif
+
+
+#if !HAVE_ATOLL
+long long
+atoll (const char *nptr);
+#endif
+
+#if ENABLE_NLS
+#include "langinfo.h"
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX ((size_t)(-1))
+#endif
+
+#ifndef O_LARGEFILE
+#define O_LARGEFILE 0
+#endif
+
+/**
+ * AI_NUMERICSERV not defined in windows.  Then we just do without.
+ */
+#ifndef AI_NUMERICSERV
+#define AI_NUMERICSERV 0
+#endif
+
+
+#if defined(__sparc__)
+#define MAKE_UNALIGNED(val) ({ __typeof__((val)) __tmp; memmove(&__tmp, &(val), sizeof((val))); __tmp; })
+#else
+#define MAKE_UNALIGNED(val) val
+#endif
+
+#if WINDOWS
+#define FDTYPE HANDLE
+#define SOCKTYPE SOCKET
+#else
+#define FDTYPE int
+#define SOCKTYPE int
+#endif
+
+#endif
diff --git a/pathologist/src/include/plibc.h b/pathologist/src/include/plibc.h
new file mode 100644
index 0000000..8314f21
--- /dev/null
+++ b/pathologist/src/include/plibc.h
@@ -0,0 +1,810 @@
+/*
+     This file is part of PlibC.
+     (C) 2005, 2006, 2007, 2008, 2009, 2010 Nils Durner (and other contributing authors)
+
+           This library is free software; you can redistribute it and/or
+           modify it under the terms of the GNU Lesser General Public
+           License as published by the Free Software Foundation; either
+           version 2.1 of the License, or (at your option) any later version.
+
+           This library is distributed in the hope that it will be useful,
+           but WITHOUT ANY WARRANTY; without even the implied warranty of
+           MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+           Lesser General Public License for more details.
+
+           You should have received a copy of the GNU Lesser General Public
+           License along with this library; if not, write to the Free Software
+           Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+/**
+ * @file include/plibc.h
+ * @brief PlibC header
+ * @attention This file is usually not installed under Unix,
+ *            so ship it with your application
+ * @version $Revision: 69 $
+ */
+
+#ifndef _PLIBC_H_
+#define _PLIBC_H_
+
+#ifndef SIGALRM
+#define SIGALRM 14
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stddef.h>
+
+#ifdef Q_OS_WIN32
+#define WINDOWS 1
+#endif
+
+#define HAVE_PLIBC_FD 0
+
+#ifdef WINDOWS
+
+#if ENABLE_NLS
+#include "langinfo.h"
+#endif
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#include <sys/types.h>
+#include <time.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <errno.h>
+#include <stdarg.h>
+
+#define __BYTE_ORDER BYTE_ORDER
+#define __BIG_ENDIAN BIG_ENDIAN
+
+/* Conflicts with our definitions */
+#define __G_WIN32_H__
+
+/* Convert LARGE_INTEGER to double */
+#define Li2Double(x) ((double)((x).HighPart) * 4.294967296E9 + \
+  (double)((x).LowPart))
+
+  struct stat64
+  {
+    _dev_t st_dev;
+    _ino_t st_ino;
+    _mode_t st_mode;
+    short st_nlink;
+    short st_uid;
+    short st_gid;
+    _dev_t st_rdev;
+    __int64 st_size;
+    __time64_t st_atime;
+    __time64_t st_mtime;
+    __time64_t st_ctime;
+  };
+
+  typedef unsigned int sa_family_t;
+
+  struct sockaddr_un
+  {
+    short sun_family;           /*AF_UNIX */
+    char sun_path[108];         /*path name */
+  };
+
+#ifndef pid_t
+#define pid_t DWORD
+#endif
+
+#ifndef error_t
+#define error_t int
+#endif
+
+#ifndef WEXITSTATUS
+#define WEXITSTATUS(status) (((status) & 0xff00) >> 8)
+#endif
+
+#ifndef MSG_DONTWAIT
+#define MSG_DONTWAIT 0
+#endif
+
+  enum
+  {
+    _SC_PAGESIZE = 30,
+    _SC_PAGE_SIZE = 30
+  };
+
+/* Thanks to the Cygwin project */
+#define ENOCSI 43               /* No CSI structure available */
+#define EL2HLT 44               /* Level 2 halted */
+#ifndef  EDEADLK
+#define EDEADLK 45              /* Deadlock condition */
+#endif
+#ifndef  ENOLCK
+#define ENOLCK 46               /* No record locks available */
+#endif
+#define EBADE 50                /* Invalid exchange */
+#define EBADR 51                /* Invalid request descriptor */
+#define EXFULL 52               /* Exchange full */
+#define ENOANO 53               /* No anode */
+#define EBADRQC 54              /* Invalid request code */
+#define EBADSLT 55              /* Invalid slot */
+#ifndef  EDEADLOCK
+#define EDEADLOCK EDEADLK       /* File locking deadlock error */
+#endif
+#define EBFONT 57               /* Bad font file fmt */
+#define ENOSTR 60               /* Device not a stream */
+#define ENODATA 61              /* No data (for no delay io) */
+#define ETIME 62                /* Timer expired */
+#define ENOSR 63                /* Out of streams resources */
+#define ENONET 64               /* Machine is not on the network */
+#define ENOPKG 65               /* Package not installed */
+#define EREMOTE 66              /* The object is remote */
+#define ENOLINK 67              /* The link has been severed */
+#define EADV 68                 /* Advertise error */
+#define ESRMNT 69               /* Srmount error */
+#define ECOMM 70                /* Communication error on send */
+#define EPROTO 71               /* Protocol error */
+#define EMULTIHOP 74            /* Multihop attempted */
+#define ELBIN 75                /* Inode is remote (not really error) */
+#define EDOTDOT 76              /* Cross mount point (not really error) */
+#define EBADMSG 77              /* Trying to read unreadable message */
+#define ENOTUNIQ 80             /* Given log. name not unique */
+#define EBADFD 81               /* f.d. invalid for this operation */
+#define EREMCHG 82              /* Remote address changed */
+#define ELIBACC 83              /* Can't access a needed shared lib */
+#define ELIBBAD 84              /* Accessing a corrupted shared lib */
+#define ELIBSCN 85              /* .lib section in a.out corrupted */
+#define ELIBMAX 86              /* Attempting to link in too many libs */
+#define ELIBEXEC 87             /* Attempting to exec a shared library */
+#ifndef  ENOSYS
+#define ENOSYS 88               /* Function not implemented */
+#endif
+#define ENMFILE 89              /* No more files */
+#ifndef  ENOTEMPTY
+#define ENOTEMPTY 90            /* Directory not empty */
+#endif
+#ifndef  ENAMETOOLONG
+#define ENAMETOOLONG 91         /* File or path name too long */
+#endif
+#define ELOOP 92                /* Too many symbolic links */
+#define EOPNOTSUPP 95           /* Operation not supported on transport endpoint */
+#define EPFNOSUPPORT 96         /* Protocol family not supported */
+#define ECONNRESET 104          /* Connection reset by peer */
+#define ENOBUFS 105             /* No buffer space available */
+#define EAFNOSUPPORT 106        /* Address family not supported by protocol family */
+#define EPROTOTYPE 107          /* Protocol wrong type for socket */
+#define ENOTSOCK 108            /* Socket operation on non-socket */
+#define ENOPROTOOPT 109         /* Protocol not available */
+#define ESHUTDOWN 110           /* Can't send after socket shutdown */
+#define ECONNREFUSED 111        /* Connection refused */
+#define EADDRINUSE 112          /* Address already in use */
+#define ECONNABORTED 113        /* Connection aborted */
+#define ENETUNREACH 114         /* Network is unreachable */
+#define ENETDOWN 115            /* Network interface is not configured */
+#ifndef  ETIMEDOUT
+#define ETIMEDOUT 116           /* Connection timed out */
+#endif
+#define EHOSTDOWN 117           /* Host is down */
+#define EHOSTUNREACH 118        /* Host is unreachable */
+#define EINPROGRESS 119         /* Connection already in progress */
+#define EALREADY 120            /* Socket already connected */
+#define EDESTADDRREQ 121        /* Destination address required */
+#define EMSGSIZE 122            /* Message too long */
+#define EPROTONOSUPPORT 123     /* Unknown protocol */
+#define ESOCKTNOSUPPORT 124     /* Socket type not supported */
+#define EADDRNOTAVAIL 125       /* Address not available */
+#define ENETRESET 126           /* Connection aborted by network */
+#define EISCONN 127             /* Socket is already connected */
+#define ENOTCONN 128            /* Socket is not connected */
+#define ETOOMANYREFS 129        /* Too many references: cannot splice */
+#define EPROCLIM 130            /* Too many processes */
+#define EUSERS 131              /* Too many users */
+#define EDQUOT 132              /* Disk quota exceeded */
+#define ESTALE 133              /* Unknown error */
+#ifndef  ENOTSUP
+#define ENOTSUP 134             /* Not supported */
+#endif
+#define ENOMEDIUM 135           /* No medium (in tape drive) */
+#define ENOSHARE 136            /* No such host or network path */
+#define ECASECLASH 137          /* Filename exists with different case */
+#define EWOULDBLOCK EAGAIN      /* Operation would block */
+#define EOVERFLOW 139           /* Value too large for defined data type */
+
+#undef HOST_NOT_FOUND
+#define HOST_NOT_FOUND 1
+#undef TRY_AGAIN
+#define TRY_AGAIN 2
+#undef NO_RECOVERY
+#define NO_RECOVERY 3
+#undef NO_ADDRESS
+#define NO_ADDRESS 4
+
+#define PROT_READ   0x1
+#define PROT_WRITE  0x2
+#define MAP_SHARED  0x1
+#define MAP_PRIVATE 0x2         /* unsupported */
+#define MAP_FIXED   0x10
+#define MAP_FAILED  ((void *)-1)
+
+  struct statfs
+  {
+    long f_type;                /* type of filesystem (see below) */
+    long f_bsize;               /* optimal transfer block size */
+    long f_blocks;              /* total data blocks in file system */
+    long f_bfree;               /* free blocks in fs */
+    long f_bavail;              /* free blocks avail to non-superuser */
+    long f_files;               /* total file nodes in file system */
+    long f_ffree;               /* free file nodes in fs */
+    long f_fsid;                /* file system id */
+    long f_namelen;             /* maximum length of filenames */
+    long f_spare[6];            /* spare for later */
+  };
+
+  extern const struct in6_addr in6addr_any;     /* :: */
+  extern const struct in6_addr in6addr_loopback;        /* ::1 */
+
+/* Taken from the Wine project <http://www.winehq.org>
+    /wine/include/winternl.h */
+  enum SYSTEM_INFORMATION_CLASS
+  {
+    SystemBasicInformation = 0,
+    Unknown1,
+    SystemPerformanceInformation = 2,
+    SystemTimeOfDayInformation = 3,     /* was SystemTimeInformation */
+    Unknown4,
+    SystemProcessInformation = 5,
+    Unknown6,
+    Unknown7,
+    SystemProcessorPerformanceInformation = 8,
+    Unknown9,
+    Unknown10,
+    SystemDriverInformation,
+    Unknown12,
+    Unknown13,
+    Unknown14,
+    Unknown15,
+    SystemHandleList,
+    Unknown17,
+    Unknown18,
+    Unknown19,
+    Unknown20,
+    SystemCacheInformation,
+    Unknown22,
+    SystemInterruptInformation = 23,
+    SystemExceptionInformation = 33,
+    SystemRegistryQuotaInformation = 37,
+    SystemLookasideInformation = 45
+  };
+
+  typedef struct
+  {
+    LARGE_INTEGER IdleTime;
+    LARGE_INTEGER KernelTime;
+    LARGE_INTEGER UserTime;
+    LARGE_INTEGER Reserved1[2];
+    ULONG Reserved2;
+  } SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
+
+#define sleep(secs) (Sleep(secs * 1000))
+
+/*********************** statfs *****************************/
+/* fake block size */
+#define FAKED_BLOCK_SIZE 512
+
+/* linux-compatible values for fs type */
+#define MSDOS_SUPER_MAGIC     0x4d44
+#define NTFS_SUPER_MAGIC      0x5346544E
+
+/*********************** End of statfs ***********************/
+
+#define SHUT_RDWR SD_BOTH
+
+/* Operations for flock() */
+#define LOCK_SH  1              /* shared lock */
+#define LOCK_EX  2              /* exclusive lock */
+#define LOCK_NB  4              /* or'd with one of the above to prevent
+                                 * blocking */
+#define LOCK_UN  8              /* remove lock */
+
+/* Not supported under MinGW */
+#define S_IRGRP 0
+#define S_IWGRP 0
+#define S_IROTH 0
+#define S_IXGRP 0
+#define S_IWOTH 0
+#define S_IXOTH 0
+#define S_ISUID 0
+#define S_ISGID 0
+#define S_ISVTX 0
+#define S_IRWXG 0
+#define S_IRWXO 0
+
+#define SHUT_WR SD_SEND
+#define SHUT_RD SD_RECEIVE
+#define SHUT_RDWR SD_BOTH
+
+#define SIGKILL 9
+#define SIGTERM 15
+
+#define SetErrnoFromWinError(e) _SetErrnoFromWinError(e, __FILE__, __LINE__)
+
+  BOOL _plibc_CreateShortcut (const char *pszSrc, const char *pszDest);
+  BOOL _plibc_DereferenceShortcut (char *pszShortcut);
+  char *plibc_ChooseDir (char *pszTitle, unsigned long ulFlags);
+  char *plibc_ChooseFile (char *pszTitle, unsigned long ulFlags);
+  long QueryRegistry (HKEY hMainKey, const char *pszKey, const char *pszSubKey,
+                      char *pszBuffer, long *pdLength);
+
+  BOOL __win_IsHandleMarkedAsBlocking (int hHandle);
+  void __win_SetHandleBlockingMode (int s, BOOL bBlocking);
+  void __win_DiscardHandleBlockingMode (int s);
+  int _win_isSocketValid (int s);
+  int plibc_conv_to_win_path (const char *pszUnix, char *pszWindows);
+  unsigned plibc_get_handle_count ();
+
+  typedef void (*TPanicProc) (int, char *);
+  void plibc_set_panic_proc (TPanicProc proc);
+
+  int flock (int fd, int operation);
+  int fsync (int fildes);
+  int inet_pton (int af, const char *src, void *dst);
+  int inet_pton4 (const char *src, u_char * dst, int pton);
+#if USE_IPV6
+  int inet_pton6 (const char *src, u_char * dst);
+#endif
+  int truncate (const char *fname, int distance);
+  int statfs (const char *path, struct statfs *buf);
+  const char *hstrerror (int err);
+  int mkstemp (char *tmplate);
+  char *strptime (const char *buf, const char *format, struct tm *tm);
+  const char *inet_ntop (int af, const void *src, char *dst, size_t size);
+
+  int plibc_init (char *pszOrg, char *pszApp);
+  void plibc_shutdown ();
+  int plibc_initialized ();
+  int plibc_conv_to_win_path_ex (const char *pszUnix, char *pszWindows,
+                                 int derefLinks);
+  void _SetErrnoFromWinError (long lWinError, char *pszCaller, int iLine);
+  void SetErrnoFromWinsockError (long lWinError);
+  void SetHErrnoFromWinError (long lWinError);
+  void SetErrnoFromHRESULT (HRESULT hRes);
+  int GetErrnoFromWinsockError (long lWinError);
+  FILE *_win_fopen (const char *filename, const char *mode);
+  DIR *_win_opendir (const char *dirname);
+  int _win_open (const char *filename, int oflag, ...);
+#ifdef ENABLE_NLS
+  char *_win_bindtextdomain (const char *domainname, const char *dirname);
+#endif
+  int _win_chdir (const char *path);
+  int _win_close (int fd);
+  int _win_creat (const char *path, mode_t mode);
+  char *_win_ctime (const time_t * clock);
+  char *_win_ctime_r (const time_t * clock, char *buf);
+  int _win_fstat (int handle, struct stat *buffer);
+  int _win_ftruncate (int fildes, off_t length);
+  void _win_gettimeofday (struct timeval *tp, void *tzp);
+  int _win_kill (pid_t pid, int sig);
+  int _win_pipe (int *phandles);
+  int _win_rmdir (const char *path);
+  int _win_access (const char *path, int mode);
+  int _win_chmod (const char *filename, int pmode);
+  char *realpath (const char *file_name, char *resolved_name);
+  long _win_random (void);
+  void _win_srandom (unsigned int seed);
+  int _win_remove (const char *path);
+  int _win_rename (const char *oldname, const char *newname);
+  int _win_stat (const char *path, struct stat *buffer);
+  int _win_stat64 (const char *path, struct stat64 *buffer);
+  long _win_sysconf (int name);
+  int _win_unlink (const char *filename);
+  int _win_write (int fildes, const void *buf, size_t nbyte);
+  int _win_read (int fildes, void *buf, size_t nbyte);
+  size_t _win_fwrite (const void *buffer, size_t size, size_t count,
+                      FILE * stream);
+  size_t _win_fread (void *buffer, size_t size, size_t count, FILE * stream);
+  int _win_symlink (const char *path1, const char *path2);
+  void *_win_mmap (void *start, size_t len, int access, int flags, int fd,
+                   unsigned long long offset);
+  int _win_munmap (void *start, size_t length);
+  int _win_lstat (const char *path, struct stat *buf);
+  int _win_lstat64 (const char *path, struct stat64 *buf);
+  int _win_readlink (const char *path, char *buf, size_t bufsize);
+  int _win_accept (int s, struct sockaddr *addr, int *addrlen);
+  int _win_printf (const char *format, ...);
+  int _win_fprintf (FILE * f, const char *format, ...);
+  int _win_vprintf (const char *format, va_list ap);
+  int _win_vfprintf (FILE * stream, const char *format, va_list arg_ptr);
+  int _win_vsprintf (char *dest, const char *format, va_list arg_ptr);
+  int _win_vsnprintf (char *str, size_t size, const char *format,
+                      va_list arg_ptr);
+  int _win_snprintf (char *str, size_t size, const char *format, ...);
+  int _win_sprintf (char *dest, const char *format, ...);
+  int _win_vsscanf (const char *str, const char *format, va_list arg_ptr);
+  int _win_sscanf (const char *str, const char *format, ...);
+  int _win_vfscanf (FILE * stream, const char *format, va_list arg_ptr);
+  int _win_vscanf (const char *format, va_list arg_ptr);
+  int _win_scanf (const char *format, ...);
+  int _win_fscanf (FILE * stream, const char *format, ...);
+  pid_t _win_waitpid (pid_t pid, int *stat_loc, int options);
+  int _win_bind (int s, const struct sockaddr *name, int namelen);
+  int _win_connect (int s, const struct sockaddr *name, int namelen);
+  int _win_getpeername (int s, struct sockaddr *name, int *namelen);
+  int _win_getsockname (int s, struct sockaddr *name, int *namelen);
+  int _win_getsockopt (int s, int level, int optname, char *optval,
+                       int *optlen);
+  int _win_listen (int s, int backlog);
+  int _win_recv (int s, char *buf, int len, int flags);
+  int _win_recvfrom (int s, void *buf, int len, int flags,
+                     struct sockaddr *from, int *fromlen);
+  int _win_select (int max_fd, fd_set * rfds, fd_set * wfds, fd_set * efds,
+                   const struct timeval *tv);
+  int _win_send (int s, const char *buf, int len, int flags);
+  int _win_sendto (int s, const char *buf, int len, int flags,
+                   const struct sockaddr *to, int tolen);
+  int _win_setsockopt (int s, int level, int optname, const void *optval,
+                       int optlen);
+  int _win_shutdown (int s, int how);
+  int _win_socket (int af, int type, int protocol);
+  struct hostent *_win_gethostbyaddr (const char *addr, int len, int type);
+  struct hostent *_win_gethostbyname (const char *name);
+  struct hostent *gethostbyname2 (const char *name, int af);
+  char *_win_strerror (int errnum);
+  int IsWinNT ();
+  char *index (const char *s, int c);
+
+#if !HAVE_STRNDUP
+  char *strndup (const char *s, size_t n);
+#endif
+#if !HAVE_STRNLEN
+  size_t strnlen (const char *str, size_t maxlen);
+#endif
+  char *stpcpy (char *dest, const char *src);
+  char *strcasestr (const char *haystack_start, const char *needle_start);
+
+#define strcasecmp(a, b) stricmp(a, b)
+#define strncasecmp(a, b, c) strnicmp(a, b, c)
+
+#endif                          /* WINDOWS */
+
+#ifndef WINDOWS
+#define DIR_SEPARATOR '/'
+#define DIR_SEPARATOR_STR "/"
+#define PATH_SEPARATOR ':'
+#define PATH_SEPARATOR_STR ":"
+#define NEWLINE "\n"
+
+#ifdef ENABLE_NLS
+#define BINDTEXTDOMAIN(d, n) bindtextdomain(d, n)
+#endif
+#define CREAT(p, m) creat(p, m)
+#define PLIBC_CTIME(c) ctime(c)
+#define CTIME_R(c, b) ctime_r(c, b)
+#undef FOPEN
+#define FOPEN(f, m) fopen(f, m)
+#define FTRUNCATE(f, l) ftruncate(f, l)
+#define OPENDIR(d) opendir(d)
+#define OPEN open
+#define CHDIR(d) chdir(d)
+#define CLOSE(f) close(f)
+#define LSEEK(f, o, w) lseek(f, o, w)
+#define RMDIR(f) rmdir(f)
+#define ACCESS(p, m) access(p, m)
+#define CHMOD(f, p) chmod(f, p)
+#define FSTAT(h, b) fstat(h, b)
+#define PLIBC_KILL(p, s) kill(p, s)
+#define PIPE(h) pipe(h)
+#define REMOVE(p) remove(p)
+#define RENAME(o, n) rename(o, n)
+#define STAT(p, b) stat(p, b)
+#define STAT64(p, b) stat64(p, b)
+#define SYSCONF(n) sysconf(n)
+#define UNLINK(f) unlink(f)
+#define WRITE(f, b, n) write(f, b, n)
+#define READ(f, b, n) read(f, b, n)
+#define GN_FREAD(b, s, c, f) fread(b, s, c, f)
+#define GN_FWRITE(b, s, c, f) fwrite(b, s, c, f)
+#define SYMLINK(a, b) symlink(a, b)
+#define MMAP(s, l, p, f, d, o) mmap(s, l, p, f, d, o)
+#define MUNMAP(s, l) munmap(s, l)
+#define STRERROR(i) strerror(i)
+#define RANDOM() random()
+#define SRANDOM(s) srandom(s)
+#define READLINK(p, b, s) readlink(p, b, s)
+#define LSTAT(p, b) lstat(p, b)
+#define LSTAT64(p, b) lstat64(p, b)
+#define PRINTF printf
+#define FPRINTF fprintf
+#define VPRINTF(f, a) vprintf(f, a)
+#define VFPRINTF(s, f, a) vfprintf(s, f, a)
+#define VSPRINTF(d, f, a) vsprintf(d, f, a)
+#define VSNPRINTF(str, size, fmt, a) vsnprintf(str, size, fmt, a)
+#define _REAL_SNPRINTF snprintf
+#define SPRINTF sprintf
+#define VSSCANF(s, f, a) vsscanf(s, f, a)
+#define SSCANF sscanf
+#define VFSCANF(s, f, a) vfscanf(s, f, a)
+#define VSCANF(f, a) vscanf(f, a)
+#define SCANF scanf
+#define FSCANF fscanf
+#define WAITPID(p, s, o) waitpid(p, s, o)
+#define ACCEPT(s, a, l) accept(s, a, l)
+#define BIND(s, n, l) bind(s, n, l)
+#define CONNECT(s, n, l) connect(s, n, l)
+#define GETPEERNAME(s, n, l) getpeername(s, n, l)
+#define GETSOCKNAME(s, n, l) getsockname(s, n, l)
+#define GETSOCKOPT(s, l, o, v, p) getsockopt(s, l, o, v, p)
+#define LISTEN(s, b) listen(s, b)
+#define RECV(s, b, l, f) recv(s, b, l, f)
+#define RECVFROM(s, b, l, f, r, o) recvfrom(s, b, l, f, r, o)
+#define SELECT(n, r, w, e, t) select(n, r, w, e, t)
+#define SEND(s, b, l, f) send(s, b, l, f)
+#define SENDTO(s, b, l, f, o, n) sendto(s, b, l, f, o, n)
+#define SETSOCKOPT(s, l, o, v, n) setsockopt(s, l, o, v, n)
+#define SHUTDOWN(s, h) shutdown(s, h)
+#define SOCKET(a, t, p) socket(a, t, p)
+#define GETHOSTBYADDR(a, l, t) gethostbyname(a, l, t)
+#define GETHOSTBYNAME(n) gethostbyname(n)
+#define GETTIMEOFDAY(t, n) gettimeofday(t, n)
+#define INSQUE(e, p) insque(e, p)
+#define REMQUE(e) remque(e)
+#define HSEARCH(i, a) hsearch(i, a)
+#define HCREATE(n) hcreate(n)
+#define HDESTROY() hdestroy()
+#define HSEARCH_R(i, a, r, h) hsearch_r(i, a, r, h)
+#define HCREATE_R(n, h) hcreate_r(n, h)
+#define HDESTROY_R(h) hdestroy_r(h)
+#define TSEARCH(k, r, c) tsearch(k, r, c)
+#define TFIND(k, r, c) tfind(k, r, c)
+#define TDELETE(k, r, c) tdelete(k, r, c)
+#define TWALK(r, a) twalk(r, a)
+#define TDESTROY(r, f) tdestroy(r, f)
+#define LFIND(k, b, n, s, c) lfind(k, b, n, s, c)
+#define LSEARCH(k, b, n, s, c) lsearch(k, b, n, s, c)
+#else
+#define DIR_SEPARATOR '\\'
+#define DIR_SEPARATOR_STR "\\"
+#define PATH_SEPARATOR ';'
+#define PATH_SEPARATOR_STR ";"
+#define NEWLINE "\r\n"
+
+#ifdef ENABLE_NLS
+#define BINDTEXTDOMAIN(d, n) _win_bindtextdomain(d, n)
+#endif
+#define CREAT(p, m) _win_creat(p, m)
+#define PLIBC_CTIME(c) _win_ctime(c)
+#define CTIME_R(c, b) _win_ctime_r(c, b)
+#define FOPEN(f, m) _win_fopen(f, m)
+#define FTRUNCATE(f, l) _win_ftruncate(f, l)
+#define OPENDIR(d) _win_opendir(d)
+#define OPEN _win_open
+#define CHDIR(d) _win_chdir(d)
+#define CLOSE(f) _win_close(f)
+#define PLIBC_KILL(p, s) _win_kill(p, s)
+#define LSEEK(f, o, w) _win_lseek(f, o, w)
+#define FSTAT(h, b) _win_fstat(h, b)
+#define RMDIR(f) _win_rmdir(f)
+#define ACCESS(p, m) _win_access(p, m)
+#define CHMOD(f, p) _win_chmod(f, p)
+#define PIPE(h) _win_pipe(h)
+#define RANDOM() _win_random()
+#define SRANDOM(s) _win_srandom(s)
+#define REMOVE(p) _win_remove(p)
+#define RENAME(o, n) _win_rename(o, n)
+#define STAT(p, b) _win_stat(p, b)
+#define STAT64(p, b) _win_stat64(p, b)
+#define SYSCONF(n) _win_sysconf(n)
+#define UNLINK(f) _win_unlink(f)
+#define WRITE(f, b, n) _win_write(f, b, n)
+#define READ(f, b, n) _win_read(f, b, n)
+#define GN_FREAD(b, s, c, f) _win_fread(b, s, c, f)
+#define GN_FWRITE(b, s, c, f) _win_fwrite(b, s, c, f)
+#define SYMLINK(a, b) _win_symlink(a, b)
+#define MMAP(s, l, p, f, d, o) _win_mmap(s, l, p, f, d, o)
+#define MUNMAP(s, l) _win_munmap(s, l)
+#define STRERROR(i) _win_strerror(i)
+#define READLINK(p, b, s) _win_readlink(p, b, s)
+#define LSTAT(p, b) _win_lstat(p, b)
+#define LSTAT64(p, b) _win_lstat64(p, b)
+#define PRINTF(f, ...) _win_printf(f , __VA_ARGS__)
+#define FPRINTF(fil, fmt, ...) _win_fprintf(fil, fmt, __VA_ARGS__)
+#define VPRINTF(f, a) _win_vprintf(f, a)
+#define VFPRINTF(s, f, a) _win_vfprintf(s, f, a)
+#define VSPRINTF(d, f, a) _win_vsprintf(d, f, a)
+#define VSNPRINTF(str, size, fmt, a) _win_vsnprintf(str, size, fmt, a)
+#define _REAL_SNPRINTF(str, size, fmt, ...) _win_snprintf(str, size, fmt, __VA_ARGS__)
+#define SPRINTF(d, f, ...) _win_sprintf(d, f, __VA_ARGS__)
+#define VSSCANF(s, f, a) _win_vsscanf(s, f, a)
+#define SSCANF(s, f, ...) _win_sscanf(s, f, __VA_ARGS__)
+#define VFSCANF(s, f, a) _win_vfscanf(s, f, a)
+#define VSCANF(f, a) _win_vscanf(f, a)
+#define SCANF(f, ...) _win_scanf(f, __VA_ARGS__)
+#define FSCANF(s, f, ...) _win_fscanf(s, f, __VA_ARGS__)
+#define WAITPID(p, s, o) _win_waitpid(p, s, o)
+#define ACCEPT(s, a, l) _win_accept(s, a, l)
+#define BIND(s, n, l) _win_bind(s, n, l)
+#define CONNECT(s, n, l) _win_connect(s, n, l)
+#define GETPEERNAME(s, n, l) _win_getpeername(s, n, l)
+#define GETSOCKNAME(s, n, l) _win_getsockname(s, n, l)
+#define GETSOCKOPT(s, l, o, v, p) _win_getsockopt(s, l, o, v, p)
+#define LISTEN(s, b) _win_listen(s, b)
+#define RECV(s, b, l, f) _win_recv(s, b, l, f)
+#define RECVFROM(s, b, l, f, r, o) _win_recvfrom(s, b, l, f, r, o)
+#define SELECT(n, r, w, e, t) _win_select(n, r, w, e, t)
+#define SEND(s, b, l, f) _win_send(s, b, l, f)
+#define SENDTO(s, b, l, f, o, n) _win_sendto(s, b, l, f, o, n)
+#define SETSOCKOPT(s, l, o, v, n) _win_setsockopt(s, l, o, v, n)
+#define SHUTDOWN(s, h) _win_shutdown(s, h)
+#define SOCKET(a, t, p) _win_socket(a, t, p)
+#define GETHOSTBYADDR(a, l, t) _win_gethostbyname(a, l, t)
+#define GETHOSTBYNAME(n) _win_gethostbyname(n)
+#define GETTIMEOFDAY(t, n) _win_gettimeofday(t, n)
+#define INSQUE(e, p) _win_insque(e, p)
+#define REMQUE(e) _win_remque(e)
+#define HSEARCH(i, a) _win_hsearch(i, a)
+#define HCREATE(n) _win_hcreate(n)
+#define HDESTROY() _win_hdestroy()
+#define HSEARCH_R(i, a, r, h) _win_hsearch_r(i, a, r, h)
+#define HCREATE_R(n, h) _win_hcreate_r(n, h)
+#define HDESTROY_R(h) _win_hdestroy_r(h)
+#define TSEARCH(k, r, c) _win_tsearch(k, r, c)
+#define TFIND(k, r, c) _win_tfind(k, r, c)
+#define TDELETE(k, r, c) _win_tdelete(k, r, c)
+#define TWALK(r, a) _win_twalk(r, a)
+#define TDESTROY(r, f) _win_tdestroy(r, f)
+#define LFIND(k, b, n, s, c) _win_lfind(k, b, n, s, c)
+#define LSEARCH(k, b, n, s, c) _win_lsearch(k, b, n, s, c)
+#endif
+
+/* search.h */
+
+/* Prototype structure for a linked-list data structure.
+   This is the type used by the `insque' and `remque' functions.  */
+
+  struct PLIBC_SEARCH_QELEM
+  {
+    struct qelem *q_forw;
+    struct qelem *q_back;
+    char q_data[1];
+  };
+
+
+/* Insert ELEM into a doubly-linked list, after PREV.  */
+  void _win_insque (void *__elem, void *__prev);
+
+/* Unlink ELEM from the doubly-linked list that it is in.  */
+  void _win_remque (void *__elem);
+
+
+/* For use with hsearch(3).  */
+  typedef int (*PLIBC_SEARCH__compar_fn_t) (__const void *, __const void *);
+
+  typedef PLIBC_SEARCH__compar_fn_t _win_comparison_fn_t;
+
+/* Action which shall be performed in the call the hsearch.  */
+  typedef enum
+  {
+    PLIBC_SEARCH_FIND,
+    PLIBC_SEARCH_ENTER
+  }
+  PLIBC_SEARCH_ACTION;
+
+  typedef struct PLIBC_SEARCH_entry
+  {
+    char *key;
+    void *data;
+  }
+  PLIBC_SEARCH_ENTRY;
+
+/* The reentrant version has no static variables to maintain the state.
+   Instead the interface of all functions is extended to take an argument
+   which describes the current status.  */
+  typedef struct _PLIBC_SEARCH_ENTRY
+  {
+    unsigned int used;
+    PLIBC_SEARCH_ENTRY entry;
+  }
+  _PLIBC_SEARCH_ENTRY;
+
+
+/* Family of hash table handling functions.  The functions also
+   have reentrant counterparts ending with _r.  The non-reentrant
+   functions all work on a signle internal hashing table.  */
+
+/* Search for entry matching ITEM.key in internal hash table.  If
+   ACTION is `FIND' return found entry or signal error by returning
+   NULL.  If ACTION is `ENTER' replace existing data (if any) with
+   ITEM.data.  */
+  PLIBC_SEARCH_ENTRY *_win_hsearch (PLIBC_SEARCH_ENTRY __item,
+                                    PLIBC_SEARCH_ACTION __action);
+
+/* Create a new hashing table which will at most contain NEL elements.  */
+  int _win_hcreate (size_t __nel);
+
+/* Destroy current internal hashing table.  */
+  void _win_hdestroy (void);
+
+/* Data type for reentrant functions.  */
+  struct PLIBC_SEARCH_hsearch_data
+  {
+    struct _PLIBC_SEARCH_ENTRY *table;
+    unsigned int size;
+    unsigned int filled;
+  };
+
+/* Reentrant versions which can handle multiple hashing tables at the
+   same time.  */
+  int _win_hsearch_r (PLIBC_SEARCH_ENTRY __item, PLIBC_SEARCH_ACTION __action,
+                      PLIBC_SEARCH_ENTRY ** __retval,
+                      struct PLIBC_SEARCH_hsearch_data *__htab);
+  int _win_hcreate_r (size_t __nel, struct PLIBC_SEARCH_hsearch_data *__htab);
+  void _win_hdestroy_r (struct PLIBC_SEARCH_hsearch_data *__htab);
+
+
+/* The tsearch routines are very interesting. They make many
+   assumptions about the compiler.  It assumes that the first field
+   in node must be the "key" field, which points to the datum.
+   Everything depends on that.  */
+/* For tsearch */
+  typedef enum
+  {
+    PLIBC_SEARCH_preorder,
+    PLIBC_SEARCH_postorder,
+    PLIBC_SEARCH_endorder,
+    PLIBC_SEARCH_leaf
+  }
+  PLIBC_SEARCH_VISIT;
+
+/* Search for an entry matching the given KEY in the tree pointed to
+   by *ROOTP and insert a new element if not found.  */
+  void *_win_tsearch (__const void *__key, void **__rootp,
+                      PLIBC_SEARCH__compar_fn_t __compar);
+
+/* Search for an entry matching the given KEY in the tree pointed to
+   by *ROOTP.  If no matching entry is available return NULL.  */
+  void *_win_tfind (__const void *__key, void *__const * __rootp,
+                    PLIBC_SEARCH__compar_fn_t __compar);
+
+/* Remove the element matching KEY from the tree pointed to by *ROOTP.  */
+  void *_win_tdelete (__const void *__restrict __key, void **__restrict __rootp,
+                      PLIBC_SEARCH__compar_fn_t __compar);
+
+  typedef void (*PLIBC_SEARCH__action_fn_t) (__const void *__nodep,
+                                             PLIBC_SEARCH_VISIT __value,
+                                             int __level);
+
+/* Walk through the whole tree and call the ACTION callback for every node
+   or leaf.  */
+  void _win_twalk (__const void *__root, PLIBC_SEARCH__action_fn_t __action);
+
+/* Callback type for function to free a tree node.  If the keys are atomic
+   data this function should do nothing.  */
+  typedef void (*PLIBC_SEARCH__free_fn_t) (void *__nodep);
+
+/* Destroy the whole tree, call FREEFCT for each node or leaf.  */
+  void _win_tdestroy (void *__root, PLIBC_SEARCH__free_fn_t __freefct);
+
+
+/* Perform linear search for KEY by comparing by COMPAR in an array
+   [BASE,BASE+NMEMB*SIZE).  */
+  void *_win_lfind (__const void *__key, __const void *__base, size_t * __nmemb,
+                    size_t __size, PLIBC_SEARCH__compar_fn_t __compar);
+
+/* Perform linear search for KEY by comparing by COMPAR function in
+   array [BASE,BASE+NMEMB*SIZE) and insert entry if not found.  */
+  void *_win_lsearch (__const void *__key, void *__base, size_t * __nmemb,
+                      size_t __size, PLIBC_SEARCH__compar_fn_t __compar);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif                          //_PLIBC_H_
+
+/* end of plibc.h */
diff --git a/pathologist/src/mi/Makefile.am b/pathologist/src/mi/Makefile.am
new file mode 100644
index 0000000..1248080
--- /dev/null
+++ b/pathologist/src/mi/Makefile.am
@@ -0,0 +1,29 @@
+INCLUDES = -I$(top_srcdir)/src/include -I$(top_builddir)/src/include
+
+if MINGW
+ WINFLAGS = -Wl,--no-undefined -Wl,--export-all-symbols 
+endif
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+  XLIB = -lgcov
+endif
+
+lib_LTLIBRARIES = libmi.la
+
+libmi_la_SOURCES = \
+         gdbmi_alloc.c \
+         gdbmi_breakpoint.c \
+         gdbmi_connect.c \
+         gdbmi_data_man.c \
+         gdbmi_error.c \
+         gdbmi_get_free_pty.c \
+         gdbmi_get_free_vt.c \
+         gdbmi_misc.c \
+         gdbmi_parse.c \
+         gdbmi_prg_control.c \
+         gdbmi_stack_man.c \
+         gdbmi_symbol_query.c \
+         gdbmi_target_man.c \
+         gdbmi_thread.c \
+         gdbmi_var_obj.c
\ No newline at end of file
diff --git a/pathologist/src/mi/gdbmi_alloc.c b/pathologist/src/mi/gdbmi_alloc.c
new file mode 100644
index 0000000..0fe6e14
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_alloc.c
@@ -0,0 +1,308 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Allocator.
+  Comments:
+  Most alloc/free routines are here. Free routines must accept NULL
+pointers. Alloc functions must set mi_error.  @<p>
+  
+***************************************************************************/
+
+#include "gdbmi.h"
+
+void *mi_calloc(size_t count, size_t sz)
+{
+ void *res=calloc(count,sz);
+ if (!res)
+    mi_error=MI_OUT_OF_MEMORY;
+ return res;
+}
+
+void *mi_calloc1(size_t sz)
+{
+ return mi_calloc(1,sz);
+}
+
+char *mi_malloc(size_t sz)
+{
+ char *res=malloc(sz);
+ if (!res)
+    mi_error=MI_OUT_OF_MEMORY;
+ return res;
+}
+
+mi_results *mi_alloc_results(void)
+{
+ return (mi_results *)mi_calloc1(sizeof(mi_results));
+}
+
+mi_output *mi_alloc_output(void)
+{
+ return (mi_output *)mi_calloc1(sizeof(mi_output));
+}
+
+mi_frames *mi_alloc_frames(void)
+{
+ return (mi_frames *)mi_calloc1(sizeof(mi_frames));
+}
+
+mi_gvar *mi_alloc_gvar(void)
+{
+ return (mi_gvar *)mi_calloc1(sizeof(mi_gvar));
+}
+
+mi_gvar_chg *mi_alloc_gvar_chg(void)
+{
+ return (mi_gvar_chg *)mi_calloc1(sizeof(mi_gvar_chg));
+}
+
+mi_bkpt *mi_alloc_bkpt(void)
+{
+ mi_bkpt *b=(mi_bkpt *)mi_calloc1(sizeof(mi_bkpt));
+ if (b)
+   {
+    b->thread=-1;
+    b->ignore=-1;
+   }
+ return b;
+}
+
+mi_wp *mi_alloc_wp(void)
+{
+ return (mi_wp *)mi_calloc1(sizeof(mi_wp));
+}
+
+mi_stop *mi_alloc_stop(void)
+{
+ return (mi_stop *)mi_calloc1(sizeof(mi_stop));
+}
+
+mi_asm_insns *mi_alloc_asm_insns(void)
+{
+ return (mi_asm_insns *)mi_calloc1(sizeof(mi_asm_insns));
+}
+
+mi_asm_insn *mi_alloc_asm_insn(void)
+{
+ return (mi_asm_insn *)mi_calloc1(sizeof(mi_asm_insn));
+}
+
+mi_chg_reg *mi_alloc_chg_reg(void)
+{
+ return (mi_chg_reg *)mi_calloc1(sizeof(mi_chg_reg));
+}
+
+/*****************************************************************************
+  Free functions
+*****************************************************************************/
+
+void mi_free_frames(mi_frames *f)
+{
+ mi_frames *aux;
+
+ while (f)
+   {
+    free(f->func);
+    free(f->file);
+    free(f->from);
+    mi_free_results(f->args);
+    aux=f->next;
+    free(f);
+    f=aux;
+   }
+}
+
+void mi_free_bkpt(mi_bkpt *b)
+{
+ mi_bkpt *aux;
+
+ while (b)
+   {
+    free(b->func);
+    free(b->file);
+    free(b->file_abs);
+    free(b->cond);
+    aux=b->next;
+    free(b);
+    b=aux;
+   }
+}
+
+void mi_free_gvar(mi_gvar *v)
+{
+ mi_gvar *aux;
+
+ while (v)
+   {
+    free(v->name);
+    free(v->type);
+    free(v->exp);
+    free(v->value);
+    if (v->numchild && v->child)
+       mi_free_gvar(v->child);
+    aux=v->next;
+    free(v);
+    v=aux;
+   }
+}
+
+void mi_free_gvar_chg(mi_gvar_chg *p)
+{
+ mi_gvar_chg *aux;
+
+ while (p)
+   {
+    free(p->name);
+    free(p->new_type);
+    aux=p->next;
+    free(p);
+    p=aux;
+   }
+}
+
+void mi_free_results_but(mi_results *r, mi_results *no)
+{
+ mi_results *aux;
+
+ while (r)
+   {
+    if (r==no)
+      {
+       aux=r->next;
+       r->next=NULL;
+       r=aux;
+      }
+    else
+      {
+       free(r->var);
+       switch (r->type)
+         {
+          case t_const:
+               free(r->v.cstr);
+               break;
+          case t_tuple:
+          case t_list:
+               mi_free_results_but(r->v.rs,no);
+               break;
+         }
+       aux=r->next;
+       free(r);
+       r=aux;
+      }
+   }
+}
+
+void mi_free_results(mi_results *r)
+{
+ mi_free_results_but(r,NULL);
+}
+
+void mi_free_output_but(mi_output *r, mi_output *no, mi_results *no_r)
+{
+ mi_output *aux;
+
+ while (r)
+   {
+    if (r==no)
+      {
+       aux=r->next;
+       r->next=NULL;
+       r=aux;
+      }
+    else
+      {
+       if (r->c)
+          mi_free_results_but(r->c,no_r);
+       aux=r->next;
+       free(r);
+       r=aux;
+      }
+   }
+}
+
+void mi_free_output(mi_output *r)
+{
+ mi_free_output_but(r,NULL,NULL);
+}
+
+void mi_free_stop(mi_stop *s)
+{
+ if (!s)
+    return;
+ mi_free_frames(s->frame);
+ mi_free_wp(s->wp);
+ free(s->wp_old);
+ free(s->wp_val);
+ free(s->gdb_result_var);
+ free(s->return_value);
+ free(s->signal_name);
+ free(s->signal_meaning);
+ free(s);
+}
+
+void mi_free_wp(mi_wp *wp)
+{
+ mi_wp *aux;
+ while (wp)
+   {
+    free(wp->exp);
+    aux=wp->next;
+    free(wp);
+    wp=aux;
+   }
+}
+
+void mi_free_asm_insns(mi_asm_insns *i)
+{
+ mi_asm_insns *aux;
+
+ while (i)
+   {
+    free(i->file);
+    mi_free_asm_insn(i->ins);
+    aux=i->next;
+    free(i);
+    i=aux;
+   }
+}
+
+void mi_free_asm_insn(mi_asm_insn *i)
+{
+ mi_asm_insn *aux;
+
+ while (i)
+   {
+    free(i->func);
+    free(i->inst);
+    aux=i->next;
+    free(i);
+    i=aux;
+   }
+}
+
+/*void mi_free_charp_list(char **l)
+{
+ char **c=l;
+ while (c)
+   {
+    free(*c);
+    c++;
+   }
+ free(l);
+}*/
+
+void mi_free_chg_reg(mi_chg_reg *r)
+{
+ mi_chg_reg *aux;
+ while (r)
+   {
+    free(r->val);
+    free(r->name);
+    aux=r->next;
+    free(r);
+    r=aux;
+   }
+}
+
diff --git a/pathologist/src/mi/gdbmi_breakpoint.c b/pathologist/src/mi/gdbmi_breakpoint.c
new file mode 100644
index 0000000..f91cc3e
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_breakpoint.c
@@ -0,0 +1,265 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Breakpoint table commands.
+  Comments:
+  GDB/MI commands for the "Breakpoint Table Commands" section.
+   @<p>
+@<pre>
+gdb command:          Implemented?
+
+-break-after          Yes
+-break-condition      Yes
+-break-delete         Yes
+-break-disable        Yes
+-break-enable         Yes
+-break-info           N.A. (info break NUMBER) (*)
+-break-insert         Yes
+-break-list           No (*)
+-break-watch          Yes
+@</pre>
+
+(*) I think the program should keep track of the breakpoints, so it will
+be implemented when I have more time.  @<p>
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_break_insert_fl(mi_h *h, const char *file, int line)
+{
+ mi_send(h,"-break-insert %s:%d\n",file,line);
+}
+
+void mi_break_insert(mi_h *h, int temporary, int hard_assist,
+                     const char *cond, int count, int thread,
+                     const char *where)
+{
+ char s_count[32];
+ char s_thread[32];
+
+ if (count>=0)
+    snprintf(s_count,32,"%d",count);
+ if (thread>=0)
+    snprintf(s_thread,32,"%d",thread);
+ if (cond)
+    // Conditions may contain spaces, in fact, if they don't gdb will add
+    // them after parsing. Enclosing the expression with "" solves the
+    // problem.
+    mi_send(h,"-break-insert %s %s -c \"%s\" %s %s %s %s %s\n",
+            temporary   ? "-t" : "",
+            hard_assist ? "-h" : "",
+            cond,
+            count>=0    ? "-i" : "", count>=0  ? s_count  : "",
+            thread>=0   ? "-p" : "", thread>=0 ? s_thread : "",
+            where);
+ else
+    mi_send(h,"-break-insert %s %s %s %s %s %s %s\n",
+            temporary   ? "-t" : "",
+            hard_assist ? "-h" : "",
+            count>=0    ? "-i" : "", count>=0  ? s_count  : "",
+            thread>=0   ? "-p" : "", thread>=0 ? s_thread : "",
+            where);
+}
+
+void mi_break_insert_flf(mi_h *h, const char *file, int line, int temporary,
+                         int hard_assist, const char *cond, int count,
+                         int thread)
+{
+ char s_count[32];
+ char s_thread[32];
+
+ if (count>=0)
+    snprintf(s_count,32,"%d",count);
+ if (thread>=0)
+    snprintf(s_thread,32,"%d",thread);
+ mi_send(h,"-break-insert %s %s %s %s %s %s %s %s %s:%d\n",
+         temporary   ? "-t" : "",
+         hard_assist ? "-h" : "",
+         cond        ? "-c" : "", cond      ? cond     : "",
+         count>=0    ? "-i" : "", count>=0  ? s_count  : "",
+         thread>=0   ? "-p" : "", thread>=0 ? s_thread : "",
+         file,line);
+}
+
+void mi_break_delete(mi_h *h, int number)
+{
+ mi_send(h,"-break-delete %d\n",number);
+}
+
+void mi_break_after(mi_h *h, int number, int count)
+{
+ mi_send(h,"-break-after %d %d\n",number,count);
+}
+
+void mi_break_condition(mi_h *h, int number, const char *condition)
+{
+ mi_send(h,"-break-condition %d %s\n",number,condition);
+}
+
+void mi_break_enable(mi_h *h, int number)
+{
+ mi_send(h,"-break-enable %d\n",number);
+}
+
+void mi_break_disable(mi_h *h, int number)
+{
+ mi_send(h,"-break-disable %d\n",number);
+}
+
+void mi_break_watch(mi_h *h, enum mi_wp_mode mode, const char *exp)
+{
+ if (mode==wm_write)
+    mi_send(h,"-break-watch \"%s\"\n",exp);
+ else
+    mi_send(h,"-break-watch -%c \"%s\"\n",mode==wm_rw ? 'a' : 'r',exp);
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  Insert a breakpoint at file:line.
+
+  Command: -break-insert file:line
+  Return: A new mi_bkpt structure with info about the breakpoint. NULL on
+error.
+  
+***************************************************************************/
+
+mi_bkpt *gmi_break_insert(mi_h *h, const char *file, int line)
+{
+ mi_break_insert_fl(h,file,line);
+ return mi_res_bkpt(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Insert a breakpoint, all available options.
+  
+  Command: -break-insert
+  Return: A new mi_bkpt structure with info about the breakpoint. NULL on
+error.
+  
+***************************************************************************/
+
+mi_bkpt *gmi_break_insert_full(mi_h *h, int temporary, int hard_assist,
+                               const char *cond, int count, int thread,
+                               const char *where)
+{
+ mi_break_insert(h,temporary,hard_assist,cond,count,thread,where);
+ return mi_res_bkpt(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Insert a breakpoint, all available options.
+  
+  Command: -break-insert [ops] file:line
+  Return: A new mi_bkpt structure with info about the breakpoint. NULL on
+error.
+  
+***************************************************************************/
+
+mi_bkpt *gmi_break_insert_full_fl(mi_h *h, const char *file, int line,
+                                  int temporary, int hard_assist,
+                                  const char *cond, int count, int thread)
+{
+ mi_break_insert_flf(h,file,line,temporary,hard_assist,cond,count,thread);
+ return mi_res_bkpt(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Remove a breakpoint.
+
+  Command: -break-delete
+  Return: !=0 OK. Note that gdb always says OK, but errors can be sent to the
+console.
+  
+***************************************************************************/
+
+int gmi_break_delete(mi_h *h, int number)
+{
+ mi_break_delete(h,number);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Modify the "ignore" count for a breakpoint.
+
+  Command: -break-after
+  Return: !=0 OK. Note that gdb always says OK, but errors can be sent to the
+console.
+  
+***************************************************************************/
+
+int gmi_break_set_times(mi_h *h, int number, int count)
+{
+ mi_break_after(h,number,count);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Associate a condition with the breakpoint.
+
+  Command: -break-condition
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_break_set_condition(mi_h *h, int number, const char *condition)
+{
+ mi_break_condition(h,number,condition);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Enable or disable a breakpoint.
+
+  Command: -break-enable + -break-disable
+  Return: !=0 OK. Note that gdb always says OK, but errors can be sent to the
+console.
+  
+***************************************************************************/
+
+int gmi_break_state(mi_h *h, int number, int enable)
+{
+ if (enable)
+    mi_break_enable(h,number);
+ else
+    mi_break_disable(h,number);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Set a watchpoint. It doesn't work for remote targets!
+
+  Command: -break-watch
+  Return: A new mi_wp structure with info about the watchpoint. NULL on
+error.
+  
+***************************************************************************/
+
+mi_wp *gmi_break_watch(mi_h *h, enum mi_wp_mode mode, const char *exp)
+{
+ mi_break_watch(h,mode,exp);
+ return mi_res_wp(h);
+}
+
diff --git a/pathologist/src/mi/gdbmi_connect.c b/pathologist/src/mi/gdbmi_connect.c
new file mode 100644
index 0000000..b9f3754
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_connect.c
@@ -0,0 +1,885 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004-2009 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Connect.
+  Comments:
+  This module handles the dialog with gdb, including starting and stopping
+gdb.
+  @<p>
+
+GDB Bug workaround for "file -readnow": I tried to workaround a bug using
+it but looks like this option also have bugs!!!! so I have to use the
+command line option --readnow.
+It also have a bug!!!! when the binary is changed and gdb must reload it
+this option is ignored. So it looks like we have no solution but 3 gdb bugs
+in a row.
+
+***************************************************************************/
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdarg.h>
+#include <limits.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include "plibc.h"
+
+#include "gdbmi.h"
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#ifndef TEMP_FAILURE_RETRY
+ #define TEMP_FAILURE_RETRY(a) (a)
+#endif
+
+int mi_error=MI_OK;
+char *mi_error_from_gdb=NULL;
+static char *gdb_exe=NULL;
+static char *xterm_exe=NULL;
+static char *gdb_start=NULL;
+static char *gdb_conn=NULL;
+static char *main_func=NULL;
+static char  disable_psym_search_workaround=0;
+
+mi_h *mi_alloc_h()
+{
+ mi_h *h=(mi_h *)calloc(1,sizeof(mi_h));
+ if (!h)
+   {
+    mi_error=MI_OUT_OF_MEMORY;
+    return NULL;
+   }
+ h->to_gdb[0]=h->to_gdb[1]=h->from_gdb[0]=h->from_gdb[1]=-1;
+ h->pid=-1;
+ return h;
+}
+
+int mi_check_running_pid(pid_t pid)
+{
+ int status;
+
+ if (pid<=0)
+    return 0;
+ /* If waitpid returns the number of our child means it communicated
+    to as a termination status. */
+ if (waitpid(pid,&status,WNOHANG)==pid)
+   {
+    pid=0;
+    return 0;
+   }
+ return 1;
+}
+
+int mi_check_running(mi_h *h)
+{
+ return !h->died && mi_check_running_pid(h->pid);
+}
+
+void mi_kill_child(pid_t pid)
+{
+ kill(pid,SIGTERM);
+ usleep(100000);
+ if (mi_check_running_pid(pid))
+   {
+    int status;
+    kill(pid,SIGKILL);
+    waitpid(pid,&status,0);
+   }
+}
+
+void mi_free_h(mi_h **handle)
+{
+ mi_h *h=*handle;
+ if (h->to_gdb[0]>=0)
+    close(h->to_gdb[0]);
+ if (h->to)
+    fclose(h->to);
+ else if (h->to_gdb[1]>=0)
+    close(h->to_gdb[1]);
+ if (h->from)
+    fclose(h->from);
+ else if (h->from_gdb[0]>=0)
+    close(h->from_gdb[0]);
+ if (h->from_gdb[1]>=0)
+    close(h->from_gdb[1]);
+ if (mi_check_running(h))
+   {/* GDB is running! */
+    mi_kill_child(h->pid);
+   }
+ if (h->line)
+    free(h->line);
+ mi_free_output(h->po);
+ free(h->catched_console);
+ free(h);
+ *handle=NULL;
+}
+
+void mi_set_nonblk(int h)
+{
+ int flf;
+ flf=fcntl(h,F_GETFL,0);
+ flf=flf | O_NONBLOCK;
+ fcntl(h,F_SETFL,flf);
+}
+
+int mi_getline(mi_h *h)
+{
+ char c;
+
+ while (read(h->from_gdb[0],&c,1)==1)
+   {
+    if (h->lread>=h->llen)
+      {
+       h->llen=h->lread+128;
+       h->line=(char *)realloc(h->line,h->llen);
+       if (!h->line)
+         {
+          h->llen=0;
+          h->lread=0;
+          return -1;
+         }
+      }
+    if (c=='\n')
+      {
+       int ret=h->lread;
+       h->line[ret]=0;
+       h->lread=0;
+       return ret;
+      }
+    h->line[h->lread]=c;
+    h->lread++;
+   }
+ return 0;
+}
+
+char *get_cstr(mi_output *o)
+{
+ if (!o->c || o->c->type!=t_const)
+    return NULL;
+ return o->c->v.cstr;
+}
+
+int mi_get_response(mi_h *h)
+{
+ int l=mi_getline(h);
+ if (!l)
+    return 0;
+
+ if (h->from_gdb_echo)
+    h->from_gdb_echo(h->line,h->from_gdb_echo_data);
+ if (strncmp(h->line,"(gdb)",5)==0)
+   {/* End of response. */
+    return 1;
+   }
+ else
+   {/* Add to the response. */
+    mi_output *o;
+    int add=1, is_exit=0;
+    o=mi_parse_gdb_output(h->line);
+
+    if (!o)
+       return 0;
+    /* Tunneled streams callbacks. */
+    if (o->type==MI_T_OUT_OF_BAND && o->stype==MI_ST_STREAM)
+      {
+       char *aux;
+       add=0;
+       switch (o->sstype)
+         {
+          case MI_SST_CONSOLE:
+               aux=get_cstr(o);
+               if (h->console)
+                  h->console(aux,h->console_data);
+               if (h->catch_console && aux)
+                 {
+                  h->catch_console--;
+                  if (!h->catch_console)
+                    {
+                     free(h->catched_console);
+                     h->catched_console=strdup(aux);
+                    }
+                 }
+               break;
+          case MI_SST_TARGET:
+               /* This one seems to be useless. */
+               if (h->target)
+                  h->target(get_cstr(o),h->target_data);
+               break;
+          case MI_SST_LOG:
+               if (h->log)
+                  h->log(get_cstr(o),h->log_data);
+               break;
+         }
+      }
+    else if (o->type==MI_T_OUT_OF_BAND && o->stype==MI_ST_ASYNC)
+      {
+       if (h->async)
+          h->async(o,h->async_data);
+      }
+    else if (o->type==MI_T_RESULT_RECORD && o->tclass==MI_CL_ERROR)
+      {/* Error from gdb, record it. */
+       mi_error=MI_FROM_GDB;
+       free(mi_error_from_gdb);
+       mi_error_from_gdb=NULL;
+       if (o->c && strcmp(o->c->var,"msg")==0 && o->c->type==t_const)
+          mi_error_from_gdb=strdup(o->c->v.cstr);
+      }
+    is_exit=(o->type==MI_T_RESULT_RECORD && o->tclass==MI_CL_EXIT);
+    /* Add to the list of responses. */
+    if (add)
+      {
+       if (h->last)
+          h->last->next=o;
+       else
+          h->po=o;
+       h->last=o;
+      }
+    else
+       mi_free_output(o);
+    /* Exit RR means gdb exited, we won't get a new prompt ;-) */
+    if (is_exit)
+       return 1;
+   }
+
+ return 0;
+}
+
+mi_output *mi_retire_response(mi_h *h)
+{
+ mi_output *ret=h->po;
+ h->po=h->last=NULL;
+ return ret;
+}
+
+mi_output *mi_get_response_blk(mi_h *h)
+{
+ int r;
+ /* Sometimes gdb dies. */
+ if (!mi_check_running(h))
+   {
+    h->died=1;
+    mi_error=MI_GDB_DIED;
+    return NULL;
+   }
+ do
+   {
+   /*
+    That's a must. If we just keep trying to read and failing things
+    become really sloooowwww. Instead we try and if it fails we wait
+    until something is available.
+    TODO: Implement something with the time out, a callback to ask the
+    application is we have to wait or not could be a good thing.
+   */
+   fd_set set;
+   struct timeval timeout;
+   int ret;
+
+   r=mi_get_response(h);
+   if (r)
+      return mi_retire_response(h);
+
+   FD_ZERO(&set);
+   FD_SET(h->from_gdb[0],&set);
+   timeout.tv_sec=h->time_out;
+   timeout.tv_usec=0;
+   ret=TEMP_FAILURE_RETRY(select(FD_SETSIZE,&set,NULL,NULL,&timeout));
+   if (!ret)
+     {
+      if (!mi_check_running(h))
+        {
+         h->died=1;
+         mi_error=MI_GDB_DIED;
+         return NULL;
+        }
+      if (h->time_out_cb)
+         ret=h->time_out_cb(h->time_out_cb_data);
+      if (!ret)
+        {
+         mi_error=MI_GDB_TIME_OUT;
+         return NULL;
+        }
+     }
+   }
+ while (!r);
+
+ return NULL;
+}
+
+void mi_send_commands(mi_h *h, const char *file)
+{
+ FILE *f;
+ char b[PATH_MAX];
+
+ //printf("File: %s\n",file);
+ if (!file)
+    return;
+ f=fopen(file,"rt");
+ if (!f)
+    return;
+ while (!feof(f))
+   {
+    if (fgets(b,PATH_MAX,f))
+      {
+        //printf("Send: %s\n",b);
+        mi_send (h, "%s", b);
+        mi_res_simple_done(h);
+      }
+   }
+ fclose(f);
+}
+
+void mi_send_target_commands(mi_h *h)
+{
+ mi_send_commands(h,gdb_conn);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Connect to a local copy of gdb. Note that the mi_h structure is something
+similar to a "FILE *" for stdio.
+  
+  Return: A new mi_h structure or NULL on error.
+  
+***************************************************************************/
+
+mi_h *mi_connect_local()
+{
+ mi_h *h;
+ const char *gdb=mi_get_gdb_exe();
+
+ /* Start without error. */
+ mi_error=MI_OK;
+ /* Verify we have a GDB binary. */
+ if (access(gdb,X_OK))
+   {
+    mi_error=MI_MISSING_GDB;
+    return NULL;
+   }
+ /* Alloc the handle structure. */
+ h=mi_alloc_h();
+ if (!h)
+    return h;
+ h->time_out=MI_DEFAULT_TIME_OUT;
+ /* Create the pipes to connect with the child. */
+ if (pipe(h->to_gdb) || pipe(h->from_gdb))
+   {
+    mi_error=MI_PIPE_CREATE;
+    mi_free_h(&h);
+    return NULL;
+   }
+ mi_set_nonblk(h->to_gdb[1]);
+ mi_set_nonblk(h->from_gdb[0]);
+ /* Associate streams to the file handles. */
+ h->to=fdopen(h->to_gdb[1],"w");
+ h->from=fdopen(h->from_gdb[0],"r");
+ if (!h->to || !h->from)
+   {
+    mi_error=MI_PIPE_CREATE;
+    mi_free_h(&h);
+    return NULL;
+   }
+ /* Create the child. */
+ h->pid=fork();
+ if (h->pid==0)
+   {/* We are the child. */
+    char *argv[5];
+    /* Connect stdin/out to the pipes. */
+    dup2(h->to_gdb[0],STDIN_FILENO);
+    dup2(h->from_gdb[1],STDOUT_FILENO);
+    /* Pass the control to gdb. */
+    argv[0]=(char *)gdb; /* Is that OK? */
+    argv[1]="--interpreter=mi";
+    argv[2]="--quiet";
+    argv[3]=disable_psym_search_workaround ? 0 : "--readnow";
+    argv[4]=0;
+    execvp(argv[0],argv);
+    /* We get here only if exec failed. */
+    _exit(127);
+   }
+ /* We are the parent. */
+ if (h->pid==-1)
+   {/* Fork failed. */
+    mi_error=MI_FORK;
+    mi_free_h(&h);
+    return NULL;
+   }
+ if (!mi_check_running(h))
+   {
+    mi_error=MI_DEBUGGER_RUN;
+    mi_free_h(&h);
+    return NULL;
+   }
+ /* Wait for the prompt. */
+ mi_get_response_blk(h);
+ /* Send the start-up commands */
+ mi_send_commands(h,gdb_start);
+
+ return h;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Close connection. You should ask gdb to quit first gmi_gdb_exit.
+  
+***************************************************************************/
+
+void mi_disconnect(mi_h *h)
+{
+ mi_free_h(&h);
+ free(mi_error_from_gdb);
+ mi_error_from_gdb=NULL;
+}
+
+void mi_set_console_cb(mi_h *h, stream_cb cb, void *data)
+{
+ h->console=cb;
+ h->console_data=data;
+}
+
+void mi_set_target_cb(mi_h *h, stream_cb cb, void *data)
+{
+ h->target=cb;
+ h->target_data=data;
+}
+
+void mi_set_log_cb(mi_h *h, stream_cb cb, void *data)
+{
+ h->log=cb;
+ h->log_data=data;
+}
+
+stream_cb mi_get_console_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->console_data;
+ return h->console;
+}
+
+stream_cb mi_get_target_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->target_data;
+ return h->target;
+}
+
+stream_cb mi_get_log_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->log_data;
+ return h->log;
+}
+
+void mi_set_async_cb(mi_h *h, async_cb cb, void *data)
+{
+ h->async=cb;
+ h->async_data=data;
+}
+
+async_cb mi_get_async_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->async_data;
+ return h->async;
+}
+
+void mi_set_to_gdb_cb(mi_h *h, stream_cb cb, void *data)
+{
+ h->to_gdb_echo=cb;
+ h->to_gdb_echo_data=data;
+}
+
+void mi_set_from_gdb_cb(mi_h *h, stream_cb cb, void *data)
+{
+ h->from_gdb_echo=cb;
+ h->from_gdb_echo_data=data;
+}
+
+stream_cb mi_get_to_gdb_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->to_gdb_echo_data;
+ return h->to_gdb_echo;
+}
+
+stream_cb mi_get_from_gdb_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->from_gdb_echo_data;
+ return h->from_gdb_echo;
+}
+
+void mi_set_time_out_cb(mi_h *h, tm_cb cb, void *data)
+{
+ h->time_out_cb=cb;
+ h->time_out_cb_data=data;
+}
+
+tm_cb mi_get_time_out_cb(mi_h *h, void **data)
+{
+ if (data)
+    *data=h->time_out_cb_data;
+ return h->time_out_cb;
+}
+
+void mi_set_time_out(mi_h *h, int to)
+{
+ h->time_out=to;
+}
+
+int mi_get_time_out(mi_h *h)
+{
+ return h->time_out;
+}
+
+int mi_send(mi_h *h, const char *format, ...)
+{
+ int ret;
+ char *str;
+ va_list argptr;
+
+ if (h->died)
+    return 0;
+
+ va_start(argptr,format);
+ ret=vasprintf(&str,format,argptr);
+ va_end(argptr);
+ if (-1 != ret)
+   {
+     fputs(str,h->to);
+     fflush(h->to);
+     if (h->to_gdb_echo)
+       h->to_gdb_echo(str,h->to_gdb_echo_data);
+     free(str);
+   }
+ else
+   {
+     abort ();
+   }
+
+ return ret;
+}
+
+void mi_clean_up_globals()
+{
+ free(gdb_exe);
+ gdb_exe=NULL;
+ free(xterm_exe);
+ xterm_exe=NULL;
+ free(gdb_start);
+ gdb_start=NULL;
+ free(gdb_conn);
+ gdb_conn=NULL;
+ free(main_func);
+ main_func=NULL;
+}
+
+void mi_register_exit()
+{
+ static int registered=0;
+ if (!registered)
+   {
+    registered=1;
+    atexit(mi_clean_up_globals);
+   }
+}
+
+void mi_set_gdb_exe(const char *name)
+{
+ free(gdb_exe);
+ gdb_exe=name ? strdup(name) : NULL;
+ mi_register_exit();
+}
+
+void mi_set_gdb_start(const char *name)
+{
+ free(gdb_start);
+ gdb_start=name ? strdup(name) : NULL;
+ mi_register_exit();
+}
+
+void mi_set_gdb_conn(const char *name)
+{
+ free(gdb_conn);
+ gdb_conn=name ? strdup(name) : NULL;
+ mi_register_exit();
+}
+
+static
+char *mi_search_in_path(const char *file)
+{
+ char *path, *pt, *r;
+ char test[PATH_MAX];
+ struct stat st;
+
+ path=getenv("PATH");
+ if (!path)
+    return NULL;
+ pt=strdup(path);
+ r=strtok(pt,PATH_SEPARATOR_STR);
+ while (r)
+   {
+    strcpy(test,r);
+    strcat(test,"/");
+    strcat(test,file);
+    if (stat(test,&st)==0 && S_ISREG(st.st_mode))
+      {
+       free(pt);
+       return strdup(test);
+      }
+    r=strtok(NULL,PATH_SEPARATOR_STR);
+   }
+ free(pt);
+ return NULL;
+}
+
+const char *mi_get_gdb_exe()
+{
+ if (!gdb_exe)
+   {/* Look for gdb in path */
+    gdb_exe=mi_search_in_path("gdb");
+    if (!gdb_exe)
+       return "/usr/bin/gdb";
+   }
+ return gdb_exe;
+}
+
+const char *mi_get_gdb_start()
+{
+ return gdb_start;
+}
+
+const char *mi_get_gdb_conn()
+{
+ return gdb_conn;
+}
+
+void mi_set_xterm_exe(const char *name)
+{
+ free(xterm_exe);
+ xterm_exe=name ? strdup(name) : NULL;
+ mi_register_exit();
+}
+
+const char *mi_get_xterm_exe()
+{
+ if (!xterm_exe)
+   {/* Look for xterm in path */
+    xterm_exe=mi_search_in_path("xterm");
+    if (!xterm_exe)
+       return "/usr/bin/X11/xterm";
+   }
+ return xterm_exe;
+}
+
+void mi_set_main_func(const char *name)
+{
+ free(main_func);
+ main_func=name ? strdup(name) : NULL;
+ mi_register_exit();
+}
+
+const char *mi_get_main_func()
+{
+ if (main_func)
+    return main_func;
+ return "main";
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Opens a new xterm to be used by the child process to debug.
+  
+  Return: A new mi_aux_term structure, you can use gmi_end_aux_term to
+release it.
+  
+***************************************************************************/
+
+mi_aux_term *gmi_start_xterm()
+{
+ char nsh[14]="/tmp/shXXXXXX";
+ char ntt[14]="/tmp/ttXXXXXX";
+ const char *xterm;
+ struct stat st;
+ int hsh, htt=-1;
+ mi_aux_term *res=NULL;
+ FILE *f;
+ pid_t pid;
+ char buf[PATH_MAX];
+
+ /* Verify we have an X terminal. */
+ xterm=mi_get_xterm_exe();
+ if (access(xterm,X_OK))
+   {
+    mi_error=MI_MISSING_XTERM;
+    return NULL;
+   }
+
+ /* Create 2 temporals. */
+ hsh=mkstemp(nsh);
+ if (hsh==-1)
+   {
+    mi_error=MI_CREATE_TEMPORAL;
+    return NULL;
+   }
+ htt=mkstemp(ntt);
+ if (htt==-1)
+   {
+    close(hsh);
+    unlink(nsh);
+    mi_error=MI_CREATE_TEMPORAL;
+    return NULL;
+   }
+ close(htt);
+ /* Create the script. */
+ f=fdopen(hsh,"w");
+ if (!f)
+   {
+    close(hsh);
+    unlink(nsh);
+    unlink(ntt);
+    mi_error=MI_CREATE_TEMPORAL;
+    return NULL;
+   }
+ fprintf(f,"#!/bin/sh\n");
+ fprintf(f,"tty > %s\n",ntt);
+ fprintf(f,"rm %s\n",nsh);
+ fprintf(f,"sleep 365d\n");
+ fclose(f);
+ /* Spawn xterm. */
+ /* Create the child. */
+ pid=fork();
+ if (pid==0)
+   {/* We are the child. */
+    char *argv[5];
+    /* Pass the control to gdb. */
+    argv[0]=(char *)mi_get_xterm_exe(); /* Is that ok? */
+    argv[1]="-e";
+    argv[2]="/bin/sh";
+    argv[3]=nsh;
+    argv[4]=0;
+    execvp(argv[0],argv);
+    /* We get here only if exec failed. */
+    unlink(nsh);
+    unlink(ntt);
+    _exit(127);
+   }
+ /* We are the parent. */
+ if (pid==-1)
+   {/* Fork failed. */
+    unlink(nsh);
+    unlink(ntt);
+    mi_error=MI_FORK;
+    return NULL;
+   }
+ /* Wait until the shell is deleted. */
+ while (stat(nsh,&st)==0)
+   usleep(1000);
+ /* Try to read the tty name. */
+ f=fopen(ntt,"rt");
+ if (f)
+   {
+    if (fgets(buf,PATH_MAX,f))
+      {
+       char *s; /* Strip the \n. */
+       for (s=buf; *s && *s!='\n'; s++);
+       *s=0;
+       res=(mi_aux_term *)malloc(sizeof(mi_aux_term));
+       if (res)
+         {
+          res->pid=pid;
+          res->tty=strdup(buf);
+         }
+      }
+    fclose(f);
+   }
+ unlink(ntt);
+ return res;
+}
+
+void mi_free_aux_term(mi_aux_term *t)
+{
+ if (!t)
+    return;
+ free(t->tty);
+ free(t);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Closes the auxiliar terminal and releases the allocated memory.
+  
+***************************************************************************/
+
+void gmi_end_aux_term(mi_aux_term *t)
+{
+ if (!t)
+    return;
+ if (t->pid!=-1 && mi_check_running_pid(t->pid))
+    mi_kill_child(t->pid);
+ mi_free_aux_term(t);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Forces the MI version. Currently the library can't detect it so you must
+force it manually. GDB 5.x implemented MI v1 and 6.x v2.
+  
+***************************************************************************/
+
+void mi_force_version(mi_h *h, unsigned vMajor, unsigned vMiddle,
+                      unsigned vMinor)
+{
+ h->version=MI_VERSION2U(vMajor,vMiddle,vMinor);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Dis/Enables the workaround for a bug in gdb.
+
+***************************************************************************/
+
+void mi_set_workaround(unsigned wa, int enable)
+{
+ switch (wa)
+   {
+    case MI_PSYM_SEARCH:
+         disable_psym_search_workaround=enable ? 0 : 1;
+         break;
+   }
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Finds if the workaround for a bug in gdb is enabled.
+  
+  Return: !=0 if enabled.
+  
+***************************************************************************/
+
+int mi_get_workaround(unsigned wa)
+{
+ switch (wa)
+   {
+    case MI_PSYM_SEARCH:
+         return disable_psym_search_workaround==0;
+   }
+ return 0;
+}
+
diff --git a/pathologist/src/mi/gdbmi_data_man.c b/pathologist/src/mi/gdbmi_data_man.c
new file mode 100644
index 0000000..06e1377
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_data_man.c
@@ -0,0 +1,243 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Data manipulation.
+  Comments:
+  GDB/MI commands for the "Data manipulation" section.
+
+  @<p>
+
+@<pre>
+gdb command:                       Implemented?
+
+-data-disassemble                  Yes
+-data-evaluate-expression          Yes
+-data-list-changed-registers       No
+-data-list-register-names          Yes
+-data-list-register-values         No
+-data-read-memory                  No
+-display-delete                    N.A. (delete display)
+-display-disable                   N.A. (disable display)
+-display-enable                    N.A. (enable display)
+-display-insert                    N.A. (display)
+-display-list                      N.A. (info display)
+-environment-cd                    No
+-environment-directory             Yes, MI v1 implementation
+-environment-path                  No
+@</pre>
+
+Notes:  @<p>
+
+1) -display* aren't implemented. You can use CLI command display, but the
+results are sent to the console. So it looks like the best is to manually
+use -data-evaluate-expression to emulate it.  @<p>
+
+2) GDB bug mi/1770: Affects gdb<=6.2, when you ask for the names of the
+registers you get it plus the name of the "pseudo-registers", but if you
+try to get the value of a pseudo-register you get an error saying the
+register number is invalid. I reported to gdb-patches@sources.redhat.com
+on 2004/08/25 and as I didn't get any answer I filled a bug report on
+2004/09/02. The patch to fix this annoying bug is:
+
+Index: gdb/mi/mi-main.c
+===================================================================
+RCS file: /cvs/src/src/gdb/mi/mi-main.c,v
+retrieving revision 1.64
+diff -u -r1.64 mi-main.c
+--- gdb/mi/mi-main.c    3 Aug 2004 00:57:27 -0000       1.64
++++ gdb/mi/mi-main.c    25 Aug 2004 14:12:50 -0000
+@@ -423,7 +423,7 @@
+      case, some entries of REGISTER_NAME will change depending upon
+      the particular processor being debugged.
+
+-  numregs = NUM_REGS;
++  numregs = NUM_REGS + NUM_PSEUDO_REGS;
+
+   if (argc == 0)
+     {
+----
+
+Note I had to remove an end of comment in the patch to include it here.
+This bug forced me to create another set of functions. The only way is to
+first get the values and then the names.
+Fixed by Changelog entry:
+
+2004-09-12  Salvador E. Tropea  <set@users.sf.net>
+            Andrew Cagney  <cagney@gnu.org>
+
+        * mi/mi-main.c (mi_cmd_data_list_changed_registers)
+        (mi_cmd_data_list_register_values)
+        (mi_cmd_data_write_register_values): Include the PSEUDO_REGS in
+        the register number computation.
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_data_evaluate_expression(mi_h *h, const char *expression)
+{
+ mi_send(h,"-data-evaluate-expression \"%s\"\n",expression);
+}
+
+void mi_dir(mi_h *h, const char *path)
+{
+ if (h->version>=MI_VERSION2U(2,0,0))
+   {// MI v2
+    if (path)
+       mi_send(h,"-environment-directory \"%s\"\n",path);
+    else
+       mi_send(h,"-environment-directory -r\n");
+   }
+ else
+   {
+    mi_send(h,"-environment-directory %s\n",path ? path : "");
+   }
+}
+
+void mi_data_read_memory_hx(mi_h *h, const char *exp, unsigned ws,
+                            unsigned c, int convAddr)
+{
+ if (convAddr)
+    mi_send(h,"-data-read-memory \"&%s\" x %d 1 %d\n",exp,ws,c);
+ else
+    mi_send(h,"-data-read-memory \"%s\" x %d 1 %d\n",exp,ws,c);
+}
+
+void mi_data_disassemble_se(mi_h *h, const char *start, const char *end,
+                            int mode)
+{
+ mi_send(h,"-data-disassemble -s \"%s\" -e \"%s\" -- %d\n",start,end,mode);
+}
+
+void mi_data_disassemble_fl(mi_h *h, const char *file, int line, int lines,
+                            int mode)
+{
+ mi_send(h,"-data-disassemble -f \"%s\" -l %d -n %d -- %d\n",file,line,lines,
+         mode);
+}
+
+void mi_data_list_register_names(mi_h *h)
+{
+ mi_send(h,"-data-list-register-names\n");
+}
+
+void mi_data_list_register_names_l(mi_h *h, mi_chg_reg *l)
+{
+ mi_send(h,"-data-list-register-names ");
+ while (l)
+   {
+    mi_send(h,"%d ",l->reg);
+    l=l->next;
+   }
+ mi_send(h,"\n");
+}
+
+void mi_data_list_changed_registers(mi_h *h)
+{
+ mi_send(h,"-data-list-changed-registers\n");
+}
+
+void mi_data_list_register_values(mi_h *h, enum mi_gvar_fmt fmt, mi_chg_reg *l)
+{
+ mi_send(h,"-data-list-register-values %c ",mi_format_enum_to_char(fmt));
+ while (l)
+   {
+    mi_send(h,"%d ",l->reg);
+    l=l->next;
+   }
+ mi_send(h,"\n");
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  Evaluate an expression. Returns a parsed tree.
+
+  Command: -data-evaluate-expression
+  Return: The resulting value (as plain text) or NULL on error.
+  
+***************************************************************************/
+
+char *gmi_data_evaluate_expression(mi_h *h, const char *expression)
+{
+ mi_data_evaluate_expression(h,expression);
+ return mi_res_value(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Path for sources. You must use it to indicate where are the sources for
+the program to debug. Only the MI v1 implementation is available.
+
+  Command: -environment-directory
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_dir(mi_h *h, const char *path)
+{
+ mi_dir(h,path);
+ return mi_res_simple_done(h);
+}
+
+int gmi_read_memory(mi_h *h, const char *exp, unsigned size,
+                    unsigned char *dest, int *na, int convAddr,
+                    unsigned long *addr)
+{
+ mi_data_read_memory_hx(h,exp,1,size,convAddr);
+ return mi_get_read_memory(h,dest,1,na,addr);
+}
+
+mi_asm_insns *gmi_data_disassemble_se(mi_h *h, const char *start,
+                                      const char *end, int mode)
+{
+ mi_data_disassemble_se(h,start,end,mode);
+ return mi_get_asm_insns(h);
+}
+
+mi_asm_insns *gmi_data_disassemble_fl(mi_h *h, const char *file, int line,
+                                      int lines, int mode)
+{
+ mi_data_disassemble_fl(h,file,line,lines,mode);
+ return mi_get_asm_insns(h);
+}
+
+// Affected by gdb bug mi/1770
+mi_chg_reg *gmi_data_list_register_names(mi_h *h, int *how_many)
+{
+ mi_data_list_register_names(h);
+ return mi_get_list_registers(h,how_many);
+}
+
+int gmi_data_list_register_names_l(mi_h *h, mi_chg_reg *l)
+{
+ mi_data_list_register_names_l(h,l);
+ return mi_get_list_registers_l(h,l);
+}
+
+mi_chg_reg *gmi_data_list_changed_registers(mi_h *h)
+{
+ mi_error=MI_OK;
+ mi_data_list_changed_registers(h);
+ return mi_get_list_changed_regs(h);
+}
+
+int gmi_data_list_register_values(mi_h *h, enum mi_gvar_fmt fmt, mi_chg_reg *l)
+{
+ mi_data_list_register_values(h,fmt,l);
+ return mi_get_reg_values(h,l);
+}
+
+mi_chg_reg *gmi_data_list_all_register_values(mi_h *h, enum mi_gvar_fmt fmt, int *how_many)
+{
+ mi_data_list_register_values(h,fmt,NULL);
+ return mi_get_reg_values_l(h,how_many);
+}
+
diff --git a/pathologist/src/mi/gdbmi_error.c b/pathologist/src/mi/gdbmi_error.c
new file mode 100644
index 0000000..abb20f6
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_error.c
@@ -0,0 +1,38 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Error.
+  Comment:
+  Translates error numbers into messages.
+  
+***************************************************************************/
+
+#include "gdbmi.h"
+
+static
+const char *error_strs[]=
+{
+ "Ok",
+ "Out of memory",
+ "Pipe creation",
+ "Fork failed",
+ "GDB not running",
+ "Parser failed",
+ "Unknown asyn response",
+ "Unknown result response",
+ "Error from gdb",
+ "Time out in gdb response",
+ "GDB suddenly died",
+ "Can't execute X terminal",
+ "Failed to create temporal",
+ "Can't execute the debugger"
+};
+
+const char *mi_get_error_str()
+{
+ if (mi_error<0 || mi_error>MI_LAST_ERROR)
+    return "Unknown";
+ return error_strs[mi_error];
+}
diff --git a/pathologist/src/mi/gdbmi_get_free_pty.c b/pathologist/src/mi/gdbmi_get_free_pty.c
new file mode 100644
index 0000000..4274c78
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_get_free_pty.c
@@ -0,0 +1,132 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: pseudo terminal
+  Comments:
+  Helper to find a free pseudo terminal. Use this if you need to manage
+  input *and* output to the target process. If you just need output then
+  define a handler for target output stream records (assuming that this
+  is working for your particular version of gdb).
+  Usage:
+
+        mi_pty *pty = gmi_look_for_free_pty();
+        if (pty) gmi_target_terminal(mih, pty->slave);
+        ...
+        * reading from pty->master will get stdout from target *
+        * writing to pty->master will send to target stdin *
+        
+  Note: Contributed by Greg Watson (gwatson lanl gov)
+
+***************************************************************************/
+
+#define _GNU_SOURCE
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+#include "gdbmi.h"
+
+/**[txh]********************************************************************
+
+  Description:
+  Look for a free and usable pseudo terminal. Low level, use
+  gmi_look_for_free_pty().
+  
+  Return: A file descriptor connected to the master pty and the name of the slave device, or <0 on error.
+  
+***************************************************************************/
+
+#ifdef __APPLE__
+
+#include <util.h>
+
+int mi_look_for_free_pty(int *master, char **slave)
+{
+ int fdmaster;
+ int fdslave;
+ static char name[BUFSIZ];
+
+ if (openpty(&fdmaster,&fdslave,name,NULL,NULL)<0)
+    return -1;
+
+ (void)close(fdslave); /* this will be reopened by gdb */
+ *master=fdmaster;
+ *slave =name;
+
+ return 0;
+}
+
+#elif defined(__linux__)
+
+int mi_look_for_free_pty(int *master, char **slave)
+{
+ if ((*master=open("/dev/ptmx",O_RDWR))<0)
+    return -1;
+ if (grantpt(*master)<0 || unlockpt(*master)<0)
+    return -1;
+ *slave = ptsname(*master);
+
+ return 0;
+}
+
+#else /* undefined o/s */
+
+int mi_look_for_free_pty(int *master, char **slave)
+{
+ return -1;
+}
+#endif
+
+/**[txh]********************************************************************
+
+  Description:
+  Look for a free and usable pseudo terminal to be used by the child.
+  
+  Return: A new mi_pty structure, you can use gmi_end_pty to
+release it.
+  
+***************************************************************************/
+
+mi_pty *gmi_look_for_free_pty()
+{
+ int master;
+ char *slave;
+ int pty=mi_look_for_free_pty(&master,&slave);
+ mi_pty *res;
+
+ if (pty<0)
+    return NULL;
+ res=(mi_pty *)malloc(sizeof(mi_pty));
+ if (!res)
+    return NULL;
+ res->slave=strdup(slave);
+ res->master=master;
+ return res;
+}
+
+void mi_free_pty(mi_pty *p)
+{
+ if (!p)
+    return;
+ free(p->slave);
+ free(p);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Closes the pseudo termial master and releases the allocated memory.
+  
+***************************************************************************/
+
+void gmi_end_pty(mi_pty *p)
+{
+ if (!p)
+    return;
+ close(p->master);
+ mi_free_pty(p);
+}
diff --git a/pathologist/src/mi/gdbmi_get_free_vt.c b/pathologist/src/mi/gdbmi_get_free_vt.c
new file mode 100644
index 0000000..25e5e75
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_get_free_vt.c
@@ -0,0 +1,156 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Linux VT.
+  Comments:
+  Helper to find a free VT. That's 100% Linux specific.@p
+  The code comes from "lconsole.c" from Allegro project and was originally
+created by Marek Habersack and then modified by George Foot. I addapted it
+to my needs and changed license from giftware to GPL.@p
+  
+***************************************************************************/
+
+#define _GNU_SOURCE
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#ifdef __APPLE__
+#include <util.h>
+#endif /* __APPLE__ */
+
+#include "gdbmi.h"
+
+#if !defined(__linux__)
+
+int mi_look_for_free_vt()
+{
+ return -1;
+}
+
+mi_aux_term *gmi_look_for_free_vt()
+{
+ return NULL;
+}
+
+#else
+
+#include <linux/vt.h>
+
+/**[txh]********************************************************************
+
+  Description:
+  Look for a free and usable Linux VT. Low level, use
+@x{gmi_look_for_free_vt}.
+  
+  Return: The VT number or <0 on error.
+  
+***************************************************************************/
+
+int mi_look_for_free_vt()
+{/* Code from Allegro. */
+ int tty, console_fd, fd;
+ unsigned short mask;
+ char tty_name[16];
+ struct vt_stat vts; 
+
+ /* Now we need to find a VT we can use.  It must be readable and
+  * writable by us, if we're not setuid root.  VT_OPENQRY itself
+  * isn't too useful because it'll only ever come up with one 
+  * suggestion, with no guarrantee that we actually have access 
+  * to it.
+  *
+  * At some stage I think this is a candidate for config
+  * file overriding, but for now we'll stat the first N consoles
+  * to see which ones we can write to (hopefully at least one!),
+  * so that we can use that one to do ioctls.  We used to use 
+  * /dev/console for that purpose but it looks like it's not 
+  * always writable by enough people.
+  *
+  * Having found and opened a writable device, we query the state
+  * of the first sixteen (fifteen really) consoles, and try 
+  * opening each unused one in turn.
+  */
+
+ console_fd=open("/dev/console",O_WRONLY);
+ if (console_fd<0)
+   {
+    int n;
+    /* Try some ttys instead... */
+    for (n=1; n<=24; n++)
+       {
+        snprintf(tty_name,sizeof(tty_name),"/dev/tty%d",n);
+        console_fd=open(tty_name,O_WRONLY);
+        if (console_fd>=0)
+           break;
+       }
+    if (n>24)
+       return -1;
+   }
+
+ /* Get the state of the console -- in particular, the free VT field */
+ if (ioctl(console_fd,VT_GETSTATE,&vts)) {
+         close(console_fd);
+    return -2;
+ }
+ close(console_fd);
+
+ /* We attempt to set our euid to 0; if we were run with euid 0 to
+  * start with, we'll be able to do this now.  Otherwise, we'll just
+  * ignore the error returned since it might not be a problem if the
+  * ttys we look at are owned by the user running the program. */
+ seteuid(0);
+
+ /* tty0 is not really a console, so start counting at 2. */
+ fd=-1;
+ for (tty=1, mask=2; mask; tty++, mask<<=1)
+     if (!(vts.v_state & mask))
+       {
+        snprintf(tty_name,sizeof(tty_name),"/dev/tty%d",tty);
+        fd=open(tty_name,O_RDWR);
+        if (fd!=-1)
+          {
+           close(fd);
+           break;
+          }
+       }
+
+ seteuid(getuid());
+
+ if (!mask)
+    return -3;
+
+ return tty;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Look for a free and usable Linux VT to be used by the child.
+  
+  Return: A new mi_aux_term structure, you can use @x{gmi_end_aux_term} to
+release it.
+  
+***************************************************************************/
+
+mi_aux_term *gmi_look_for_free_vt()
+{
+ int ret;
+ int vt=mi_look_for_free_vt();
+ mi_aux_term *res;
+
+ if (vt<0)
+    return NULL;
+ res=(mi_aux_term *)malloc(sizeof(mi_aux_term));
+ if (!res)
+    return NULL;
+ res->pid=-1;
+ ret = asprintf(&res->tty,"/dev/tty%d",vt);
+ return res;
+}
+
+#endif
+
diff --git a/pathologist/src/mi/gdbmi_misc.c b/pathologist/src/mi/gdbmi_misc.c
new file mode 100644
index 0000000..51088a7
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_misc.c
@@ -0,0 +1,118 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Miscellaneous commands.
+  Comments:
+  GDB/MI commands for the "Miscellaneous Commands" section.  @<p>
+
+@<pre>
+gdb command:       Implemented?
+
+-gdb-exit          Yes
+-gdb-set           Yes
+-gdb-show          Yes
+-gdb-version       Yes
+@</pre>
+
+GDB Bug workaround for "-gdb-show architecture": gdb 6.1 and olders doesn't
+report it in "value", but they give the output of "show architecture". In
+6.4 we observed that not even a clue is reported. So now we always use
+"show architecture".
+
+***************************************************************************/
+
+#include <string.h>
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_gdb_exit(mi_h *h)
+{
+ mi_send(h,"-gdb-exit\n");
+}
+
+void mi_gdb_version(mi_h *h)
+{
+ mi_send(h,"-gdb-version\n");
+}
+
+void mi_gdb_set(mi_h *h, const char *var, const char *val)
+{
+ mi_send(h,"-gdb-set %s %s\n",var,val);
+}
+
+void mi_gdb_show(mi_h *h, const char *var)
+{
+ if (strcmp(var,"architecture")==0)
+    mi_send(h,"show %s\n",var);
+ else
+    mi_send(h,"-gdb-show %s\n",var);
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  Exit gdb killing the child is it is running.
+
+  Command: -gdb-exit
+
+***************************************************************************/
+
+void gmi_gdb_exit(mi_h *h)
+{
+ mi_gdb_exit(h);
+ mi_res_simple_exit(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Send the version to the console.
+
+  Command: -gdb-version
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_gdb_version(mi_h *h)
+{
+ mi_gdb_version(h);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Set a gdb variable.
+
+  Command: -gdb-set
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_gdb_set(mi_h *h, const char *var, const char *val)
+{
+ mi_gdb_set(h,var,val);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Get a gdb variable.
+
+  Command: -gdb-show
+  Return: The current value of the variable or NULL on error.
+  
+***************************************************************************/
+
+char *gmi_gdb_show(mi_h *h, const char *var)
+{
+ mi_gdb_show(h,var);
+ return mi_res_value(h);
+}
+
diff --git a/pathologist/src/mi/gdbmi_parse.c b/pathologist/src/mi/gdbmi_parse.c
new file mode 100644
index 0000000..d30bd22
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_parse.c
@@ -0,0 +1,1927 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004-2007 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Parser.
+  Comments:
+  Parses the output of gdb. It basically converts the text from gdb into a
+tree (could be a complex one) that we can easily interpret using C code.
+  
+***************************************************************************/
+
+#include <ctype.h>
+#include <string.h>
+#include <assert.h>
+#include "gdbmi.h"
+
+mi_results *mi_get_result(const char *str, const char **end);
+int mi_get_value(mi_results *r, const char *str, const char **end);
+
+
+/* GDB BUG!!!! I got:
+^error,msg="Problem parsing arguments: data-evaluate-expression ""1+2"""
+Afects gdb 2002-04-01-cvs and 6.1.1 for sure.
+That's an heuristical workaround.
+*/
+static inline
+int EndOfStr(const char *s)
+{
+ if (*s=='"')
+   {
+    s++;
+    return !*s || *s==',' || *s==']' || *s=='}';
+   }
+ return 0;
+}
+
+int mi_get_cstring_r(mi_results *r, const char *str, const char **end)
+{
+ const char *s;
+ char *d;
+ int len;
+
+ if (*str!='"')
+   {
+    mi_error=MI_PARSER;
+    return 0;
+   }
+ str++;
+ /* Meassure. */
+ for (s=str, len=0; *s && !EndOfStr(s); s++)
+    {
+         if (!*s) {
+                 mi_error = MI_PARSER;
+                 return 0;
+         }
+     if (*s=='\\')
+         s++;
+     len++;
+    }
+ /* Copy. */
+ r->type=t_const;
+ d=r->v.cstr=mi_malloc(len+1);
+ if (!r->v.cstr)
+    return 0;
+ for (s=str; *s && !EndOfStr(s); s++, d++)
+    {
+     if (*s=='\\')
+       {
+        s++;
+        switch (*s)
+          {
+           case 'n':
+                *d='\n';
+                break;
+           case 't':
+                *d='\t';
+                break;
+           default:
+                *d=*s;
+          }
+       }
+     else
+        *d=*s;
+    }
+ *d=0;
+ if (end)
+    *end=s+1;
+
+ return 1;
+}
+
+/* TODO: What's a valid variable name?
+   I'll assume a-zA-Z0-9_- */
+//inline
+int mi_is_var_name_char(char c)
+{
+ return isalnum(c) || c=='-' || c=='_';
+}
+
+char *mi_get_var_name(const char *str, const char **end)
+{
+ const char *s;
+ char *r;
+ int l;
+ /* Meassure. */
+ for (s=str; *s && mi_is_var_name_char(*s); s++);
+ if (*s!='=')
+   {
+    mi_error=MI_PARSER;
+    return NULL;
+   }
+ /* Allocate. */
+ l=s-str;
+ r=mi_malloc(l+1);
+ /* Copy. */
+ if (NULL != r) {
+         memcpy(r,str,l);
+         r[l]=0;
+ }
+ if (end)
+    *end=s+1;
+ return r;
+}
+
+
+int mi_get_list_res(mi_results *r, const char *str, const char **end, char closeC)
+{
+ mi_results *last_r, *rs;
+
+ last_r=NULL;
+ do
+   {
+    rs=mi_get_result(str,&str);
+    if (last_r)
+       last_r->next=rs;
+    else
+       r->v.rs=rs;
+    last_r=rs;
+    if (*str==closeC)
+      {
+       *end=str+1;
+       return 1;
+      }
+    if (*str!=',')
+       break;
+    str++;
+   }
+ while (1);
+
+ mi_error=MI_PARSER;
+ return 0;
+}
+
+#ifdef __APPLE__
+int mi_get_tuple_val(mi_results *r, const char *str, const char **end)
+{
+ mi_results *last_r, *rs;
+
+ last_r=NULL;
+ do
+   {
+    rs=mi_alloc_results();
+    if (!rs || !mi_get_value(rs,str,&str))
+      {
+       mi_free_results(rs);
+       return 0;
+      }
+    /* Note that rs->var is NULL, that indicates that's just a value and not
+       a result. */
+    if (last_r)
+       last_r->next=rs;
+    else
+       r->v.rs=rs;
+    last_r=rs;
+    if (*str=='}')
+      {
+       *end=str+1;
+       return 1;
+      }
+    if (*str!=',')
+       break;
+    str++;
+   }
+ while (1);
+
+ mi_error=MI_PARSER;
+ return 0;
+}
+#endif /* __APPLE__ */
+
+int mi_get_tuple(mi_results *r, const char *str, const char **end)
+{
+ if (*str!='{')
+   {
+    mi_error=MI_PARSER;
+    return 0;
+   }
+ r->type=t_tuple;
+ str++;
+ if (*str=='}')
+   {/* Special case: empty tuple */
+    *end=str+1;
+    return 1;
+   }
+ #ifdef __APPLE__
+ if (mi_is_var_name_char(*str))
+    return mi_get_list_res(r,str,end,'}');
+ return mi_get_tuple_val(r,str,end);
+ #else /* __APPLE__ */
+ return mi_get_list_res(r,str,end,'}');
+ #endif /* __APPLE__ */
+}
+
+int mi_get_list_val(mi_results *r, const char *str, const char **end)
+{
+ mi_results *last_r, *rs;
+
+ last_r=NULL;
+ do
+   {
+    rs=mi_alloc_results();
+    if (!rs || !mi_get_value(rs,str,&str))
+      {
+       mi_free_results(rs);
+       return 0;
+      }
+    /* Note that rs->var is NULL, that indicates that's just a value and not
+       a result. */
+    if (last_r)
+       last_r->next=rs;
+    else
+       r->v.rs=rs;
+    last_r=rs;
+    if (*str==']')
+      {
+       *end=str+1;
+       return 1;
+      }
+    if (*str!=',')
+       break;
+    str++;
+   }
+ while (1);
+
+ mi_error=MI_PARSER;
+ return 0;
+}
+
+int mi_get_list(mi_results *r, const char *str, const char **end)
+{
+ if (*str!='[')
+   {
+    mi_error=MI_PARSER;
+    return 0;
+   }
+ r->type=t_list;
+ str++;
+ if (*str==']')
+   {/* Special case: empty list */
+    *end=str+1;
+    return 1;
+   }
+ /* Comment: I think they could choose () for values. Is confusing in this way. */
+ if (mi_is_var_name_char(*str))
+    return mi_get_list_res(r,str,end,']');
+ return mi_get_list_val(r,str,end);
+}
+
+int mi_get_value(mi_results *r, const char *str, const char **end)
+{
+ switch (str[0])
+   {
+    case '"':
+         return mi_get_cstring_r(r,str,end);
+    case '{':
+         return mi_get_tuple(r,str,end);
+    case '[':
+         return mi_get_list(r,str,end);
+   }
+ mi_error=MI_PARSER;
+ return 0;
+}
+
+mi_results *mi_get_result(const char *str, const char **end)
+{
+ char *var;
+ mi_results *r;
+
+ var=mi_get_var_name(str,&str);
+ if (!var)
+    return NULL;
+
+ r=mi_alloc_results();
+ if (!r)
+   {
+    free(var);
+    return NULL;
+   }
+ r->var=var;
+
+ if (!mi_get_value(r,str,end))
+   {
+    mi_free_results(r);
+    return NULL;
+   }
+
+ return r;
+}
+
+mi_output *mi_get_results_alone(mi_output *r,const char *str)
+{
+ mi_results *last_r, *rs;
+
+ /* * results */
+ last_r=NULL;
+ do
+   {
+    if (!*str)
+       return r;
+    if (*str!=',')
+      {
+       mi_error=MI_PARSER;
+       break;
+      }
+    str++;
+    rs=mi_get_result(str,&str);
+    if (!rs)
+       break;
+    if (!last_r)
+       r->c=rs;
+    else
+       last_r->next=rs;
+    last_r=rs;
+   }
+ while (1);
+ mi_free_output(r);
+ return NULL;
+}
+
+mi_output *mi_parse_result_record(mi_output *r,const char *str)
+{
+ r->type=MI_T_RESULT_RECORD;
+
+ /* Solve the result-class. */
+ if (strncmp(str,"done",4)==0)
+   {
+    str+=4;
+    r->tclass=MI_CL_DONE;
+   }
+ else if (strncmp(str,"running",7)==0)
+   {
+    str+=7;
+    r->tclass=MI_CL_RUNNING;
+   }
+ else if (strncmp(str,"connected",9)==0)
+   {
+    str+=9;
+    r->tclass=MI_CL_CONNECTED;
+   }
+ else if (strncmp(str,"error",5)==0)
+   {
+    str+=5;
+    r->tclass=MI_CL_ERROR;
+   }
+ else if (strncmp(str,"exit",4)==0)
+   {
+    str+=4;
+    r->tclass=MI_CL_EXIT;
+   }
+ else
+   {
+    mi_error=MI_UNKNOWN_RESULT;
+    return NULL;
+   }
+
+ return mi_get_results_alone(r,str);
+}
+
+mi_output *mi_parse_asyn(mi_output *r,const char *str)
+{
+ r->type=MI_T_OUT_OF_BAND;
+ r->stype=MI_ST_ASYNC;
+ /* async-class. */
+ if (strncmp(str,"stopped",7)==0)
+   {
+    r->tclass=MI_CL_STOPPED;
+    str+=7;
+    return mi_get_results_alone(r,str);
+   }
+ if (strncmp(str,"download",8)==0)
+   {
+    r->tclass=MI_CL_DOWNLOAD;
+    str+=8;
+    return mi_get_results_alone(r,str);
+   }
+ mi_error=MI_UNKNOWN_ASYNC;
+ mi_free_output(r);
+ return NULL;
+}
+
+mi_output *mi_parse_exec_asyn(mi_output *r,const char *str)
+{
+ r->sstype=MI_SST_EXEC;
+ return mi_parse_asyn(r,str);
+}
+
+mi_output *mi_parse_status_asyn(mi_output *r,const char *str)
+{
+ r->sstype=MI_SST_STATUS;
+ return mi_parse_asyn(r,str);
+}
+
+mi_output *mi_parse_notify_asyn(mi_output *r,const char *str)
+{
+ r->sstype=MI_SST_NOTIFY;
+ return mi_parse_asyn(r,str);
+}
+
+mi_output *mi_console(mi_output *r,const char *str)
+{
+ r->type=MI_T_OUT_OF_BAND;
+ r->stype=MI_ST_STREAM;
+ r->c=mi_alloc_results();
+ if (!r->c || !mi_get_cstring_r(r->c,str,NULL))
+   {
+    mi_free_output(r);
+    return NULL;
+   }
+ return r;
+}
+
+mi_output *mi_console_stream(mi_output *r,const char *str)
+{
+ r->sstype=MI_SST_CONSOLE;
+ return mi_console(r,str);
+}
+
+mi_output *mi_target_stream(mi_output *r,const char *str)
+{
+ r->sstype=MI_SST_TARGET;
+ return mi_console(r,str);
+}
+
+mi_output *mi_log_stream(mi_output *r,const char *str)
+{
+ r->sstype=MI_SST_LOG;
+ return mi_console(r,str);
+}
+
+mi_output *mi_parse_gdb_output(const char *str)
+{
+ char type=str[0];
+
+ mi_output *r=mi_alloc_output();
+ if (!r)
+   {
+    mi_error=MI_OUT_OF_MEMORY;
+    return NULL;
+   }
+ str++;
+ switch (type)
+   {
+    case '^':
+         return mi_parse_result_record(r,str);
+    case '*':
+         return mi_parse_exec_asyn(r,str);
+    case '+':
+         return mi_parse_status_asyn(r,str);
+    case '=':
+         return mi_parse_notify_asyn(r,str);
+    case '~':
+         return mi_console_stream(r,str);
+    case '@':
+         return mi_target_stream(r,str);
+    case '&':
+         return mi_log_stream(r,str);
+   }   
+ mi_error=MI_PARSER;
+ return NULL;
+}
+
+mi_output *mi_get_rrecord(mi_output *r)
+{
+ if (!r)
+    return NULL;
+ while (r)
+   {
+    if (r->type==MI_T_RESULT_RECORD)
+       return r;
+    r=r->next;
+   }
+ return r;
+}
+
+mi_results *mi_get_var_r(mi_results *r, const char *var)
+{
+ while (r)
+   {
+    if (strcmp(r->var,var)==0)
+       return r;
+    r=r->next;
+   }
+ return NULL;
+}
+
+mi_results *mi_get_var(mi_output *res, const char *var)
+{
+ if (!res)
+    return NULL;
+ return mi_get_var_r(res->c,var);
+}
+
+int mi_get_async_stop_reason(mi_output *r, char **reason)
+{
+ int found_stopped=0;
+
+ *reason=NULL;
+ while (r)
+   {
+    if (r->type==MI_T_RESULT_RECORD && r->tclass==MI_CL_ERROR)
+      {
+       if (r->c->type==t_const)
+          *reason=r->c->v.cstr;
+       return 0;
+      }
+    if (r->type==MI_T_OUT_OF_BAND && r->stype==MI_ST_ASYNC &&
+        r->sstype==MI_SST_EXEC && r->tclass==MI_CL_STOPPED)
+      {
+       mi_results *p=r->c;
+       found_stopped=1;
+       while (p)
+         {
+          if (strcmp(p->var,"reason")==0)
+            {
+             *reason=p->v.cstr;
+             return 1;
+            }
+          p=p->next;
+         }
+      }
+    r=r->next;
+   }
+ if (*reason==NULL && found_stopped)
+   {
+    *reason=strdup("unknown (temp bkpt?)");
+    return 1;
+   }
+ return 0;
+}
+
+mi_frames *mi_get_async_frame(mi_output *r)
+{
+ while (r)
+   {
+    if (r->type==MI_T_OUT_OF_BAND && r->stype==MI_ST_ASYNC &&
+        r->sstype==MI_SST_EXEC && r->tclass==MI_CL_STOPPED)
+      {
+       mi_results *p=r->c;
+       while (p)
+         {
+          if (strcmp(p->var,"frame")==0)
+             return mi_parse_frame(p->v.rs);
+          p=p->next;
+         }
+      }
+    r=r->next;
+   }
+ return NULL;
+}
+
+int mi_res_simple(mi_h *h, int tclass, int accert_ret)
+{
+ mi_output *r, *res;
+ int ret=0;
+
+ r=mi_get_response_blk(h);
+ res=mi_get_rrecord(r);
+
+ if (res)
+    ret=res->tclass==tclass;
+ mi_free_output(r);
+
+ return ret;
+}
+
+
+int mi_res_simple_done(mi_h *h)
+{
+ return mi_res_simple(h,MI_CL_DONE,0);
+}
+
+int mi_res_simple_exit(mi_h *h)
+{
+ return mi_res_simple(h,MI_CL_EXIT,1);
+}
+
+int mi_res_simple_running(mi_h *h)
+{
+ return mi_res_simple(h,MI_CL_RUNNING,0);
+}
+
+int mi_res_simple_connected(mi_h *h)
+{
+ return mi_res_simple(h,MI_CL_CONNECTED,0);
+}
+
+mi_results *mi_res_var(mi_h *h, const char *var, int tclass)
+{
+ mi_output *r, *res;
+ mi_results *the_var=NULL;
+
+ r=mi_get_response_blk(h);
+ /* All the code that follows is "NULL" tolerant. */
+ /* Look for the result-record. */
+ res=mi_get_rrecord(r);
+ /* Look for the desired var. */
+ if (res && res->tclass==tclass)
+    the_var=mi_get_var(res,var);
+ /* Release all but the one we want. */
+ mi_free_output_but(r,NULL,the_var);
+ return the_var;
+}
+
+mi_results *mi_res_done_var(mi_h *h, const char *var)
+{
+ return mi_res_var(h,var,MI_CL_DONE);
+}
+
+mi_frames *mi_parse_frame(mi_results *c)
+{
+ mi_frames *res=mi_alloc_frames();
+ char *end;
+
+ if (res)
+   {
+    while (c)
+      {
+       if (c->type==t_const)
+         {
+          if (strcmp(c->var,"level")==0)
+             res->level=atoi(c->v.cstr);
+          else if (strcmp(c->var,"addr")==0)
+             res->addr=(void *)strtoul(c->v.cstr,&end,0);
+          else if (strcmp(c->var,"func")==0)
+            {
+             res->func=c->v.cstr;
+             c->v.cstr=NULL;
+            }
+          else if (strcmp(c->var,"file")==0)
+            {
+             res->file=c->v.cstr;
+             c->v.cstr=NULL;
+            }
+          else if (strcmp(c->var,"from")==0)
+            {
+             res->from=c->v.cstr;
+             c->v.cstr=NULL;
+            }
+          else if (strcmp(c->var,"line")==0)
+             res->line=atoi(c->v.cstr);
+         }
+       else if (c->type==t_list && strcmp(c->var,"args")==0)
+         {
+          res->args=c->v.rs;
+          c->v.rs=NULL;
+         }
+       c=c->next;
+      }
+   }
+ return res;
+}
+
+mi_frames *mi_res_frame(mi_h *h)
+{
+ mi_results *r=mi_res_done_var(h,"frame");
+ mi_frames *f=NULL;
+
+ if (r && r->type==t_tuple)
+    f=mi_parse_frame(r->v.rs);
+ mi_free_results(r);
+ return f;
+}
+
+mi_frames *mi_res_frames_array(mi_h *h, const char *var)
+{
+ mi_results *r=mi_res_done_var(h,var), *c;
+ mi_frames *res=NULL, *nframe, *last=NULL;
+
+ if (!r)
+    return NULL;
+#ifdef __APPLE__
+ if (r->type!=t_list && r->type!=t_tuple)
+#else
+ if (r->type!=t_list)
+#endif
+   {
+    mi_free_results(r);
+    return NULL;
+   }
+ c=r->v.rs;
+ while (c)
+   {
+    if (strcmp(c->var,"frame")==0 && c->type==t_tuple)
+      {
+       nframe=mi_parse_frame(c->v.rs);
+       if (nframe)
+         {
+          if (!last)
+             res=nframe;
+          else
+             last->next=nframe;
+          last=nframe;
+         }
+      }
+    c=c->next;
+   }
+ mi_free_results(r);
+ return res;
+}
+
+mi_frames *mi_res_frames_list(mi_h *h)
+{
+ mi_output *r, *res;
+ mi_frames *ret=NULL, *nframe, *last=NULL;
+ mi_results *c;
+
+ r=mi_get_response_blk(h);
+ res=mi_get_rrecord(r);
+ if (res && res->tclass==MI_CL_DONE)
+   {
+    c=res->c;
+    while (c)
+      {
+       if (strcmp(c->var,"frame")==0 && c->type==t_tuple)
+         {
+          nframe=mi_parse_frame(c->v.rs);
+          if (nframe)
+            {
+             if (!last)
+                ret=nframe;
+             else
+                last->next=nframe;
+             last=nframe;
+            }
+         }
+       c=c->next;
+      }
+   }
+ mi_free_output(r);
+ return ret;
+}
+
+int mi_get_thread_ids(mi_output *res, int **list)
+{
+ mi_results *vids, *lids;
+ int ids=-1, i;
+
+ *list=NULL;
+ vids=mi_get_var(res,"number-of-threads");
+ lids=mi_get_var(res,"thread-ids");
+ if (vids && vids->type==t_const &&
+     lids && lids->type==t_tuple)
+   {
+    ids=atoi(vids->v.cstr);
+    if (ids)
+      {
+       int *lst;
+       lst=(int *)mi_calloc(ids,sizeof(int));
+       if (lst)
+         {
+          lids=lids->v.rs;
+          i=0;
+          while (lids)
+            {
+             if (strcmp(lids->var,"thread-id")==0 && lids->type==t_const)
+                lst[i++]=atoi(lids->v.cstr);
+             lids=lids->next;
+            }
+          *list=lst;
+         }
+       else
+          ids=-1;
+      }
+   }
+ return ids;
+}
+
+int mi_res_thread_ids(mi_h *h, int **list)
+{
+ mi_output *r, *res;
+ int ids=-1;
+
+ r=mi_get_response_blk(h);
+ res=mi_get_rrecord(r);
+ if (res && res->tclass==MI_CL_DONE)
+    ids=mi_get_thread_ids(res,list);
+ mi_free_output(r);
+ return ids;
+}
+
+enum mi_gvar_lang mi_lang_str_to_enum(const char *lang)
+{
+ enum mi_gvar_lang lg=lg_unknown;
+
+ if (strcmp(lang,"C")==0)
+    lg=lg_c;
+ else if (strcmp(lang,"C++")==0)
+    lg=lg_cpp;
+ else if (strcmp(lang,"Java")==0)
+    lg=lg_java;
+
+ return lg;
+}
+
+const char *mi_lang_enum_to_str(enum mi_gvar_lang lang)
+{
+ const char *lg;
+
+ switch (lang)
+   {
+    case lg_c:
+         lg="C";
+         break;
+    case lg_cpp:
+         lg="C++";
+         break;
+    case lg_java:
+         lg="Java";
+         break;
+    /*case lg_unknown:*/
+    default:
+         lg="unknown";
+         break;
+   }
+ return lg;
+}
+
+enum mi_gvar_fmt mi_format_str_to_enum(const char *format)
+{
+ enum mi_gvar_fmt fmt=fm_natural;
+
+ if (strcmp(format,"binary")==0)
+    fmt=fm_binary;
+ else if (strcmp(format,"decimal")==0)
+    fmt=fm_decimal;
+ else if (strcmp(format,"hexadecimal")==0)
+    fmt=fm_hexadecimal;
+ else if (strcmp(format,"octal")==0)
+    fmt=fm_octal;
+
+ return fmt;
+}
+
+const char *mi_format_enum_to_str(enum mi_gvar_fmt format)
+{
+ const char *fmt;
+
+ switch (format)
+   {
+    case fm_natural:
+         fmt="natural";
+         break;
+    case fm_binary:
+         fmt="binary";
+         break;
+    case fm_decimal:
+         fmt="decimal";
+         break;
+    case fm_hexadecimal:
+         fmt="hexadecimal";
+         break;
+    case fm_octal:
+         fmt="octal";
+         break;
+    case fm_raw:
+         fmt="raw";
+         break;
+    default:
+         fmt="unknown";
+   }
+ return fmt;
+}
+
+char mi_format_enum_to_char(enum mi_gvar_fmt format)
+{
+ char fmt;
+
+ switch (format)
+   {
+    case fm_natural:
+         fmt='N';
+         break;
+    case fm_binary:
+         fmt='t';
+         break;
+    case fm_decimal:
+         fmt='d';
+         break;
+    case fm_hexadecimal:
+         fmt='x';
+         break;
+    case fm_octal:
+         fmt='o';
+         break;
+    case fm_raw:
+         fmt='r';
+         break;
+    default:
+         fmt=' ';
+   }
+ return fmt;
+}
+
+mi_gvar *mi_get_gvar(mi_output *o, mi_gvar *cur, const char *expression)
+{
+ mi_results *r;
+ mi_gvar *res=cur ? cur : mi_alloc_gvar();
+ int l;
+
+ if (!res)
+    return res;
+ r=o->c;
+ if (expression)
+    res->exp=strdup(expression);
+ while (r)
+   {
+    if (r->type==t_const)
+      {
+       if (strcmp(r->var,"name")==0)
+         {
+          free(res->name);
+          res->name=r->v.cstr;
+          r->v.cstr=NULL;
+         }
+       else if (strcmp(r->var,"numchild")==0)
+         {
+          res->numchild=atoi(r->v.cstr);
+         }
+       else if (strcmp(r->var,"type")==0)
+         {
+          free(res->type);
+          res->type=r->v.cstr;
+          r->v.cstr=NULL;
+          l=strlen(res->type);
+          if (l && res->type[l-1]=='*')
+             res->ispointer=1;
+         }
+       else if (strcmp(r->var,"lang")==0)
+         {
+          res->lang=mi_lang_str_to_enum(r->v.cstr);
+         }
+       else if (strcmp(r->var,"exp")==0)
+         {
+          free(res->exp);
+          res->exp=r->v.cstr;
+          r->v.cstr=NULL;
+         }
+       else if (strcmp(r->var,"format")==0)
+         {
+          res->format=mi_format_str_to_enum(r->v.cstr);
+         }
+       else if (strcmp(r->var,"attr")==0)
+         { /* Note: gdb 6.1.1 have only this: */
+          if (strcmp(r->v.cstr,"editable")==0)
+             res->attr=MI_ATTR_EDITABLE;
+          else /* noneditable */
+             res->attr=MI_ATTR_NONEDITABLE;
+         }
+      }
+    r=r->next;
+   }
+ return res;
+}
+
+mi_gvar *mi_res_gvar(mi_h *h, mi_gvar *cur, const char *expression)
+{
+ mi_output *r, *res;
+ mi_gvar *gvar=NULL;
+
+ r=mi_get_response_blk(h);
+ res=mi_get_rrecord(r);
+ if (res && res->tclass==MI_CL_DONE)
+    gvar=mi_get_gvar(res,cur,expression);
+ mi_free_output(r);
+ return gvar;
+}
+
+mi_gvar_chg *mi_get_gvar_chg(mi_results *r)
+{
+ mi_gvar_chg *n;
+
+ if (r->type!=t_const)
+    return NULL;
+ n=mi_alloc_gvar_chg();
+ if (n)
+   {
+    while (r)
+      {
+       if (r->type==t_const)
+         {
+          if (strcmp(r->var,"name")==0)
+            {
+             n->name=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if (strcmp(r->var,"in_scope")==0)
+            {
+             n->in_scope=strcmp(r->v.cstr,"true")==0;
+            }
+          else if (strcmp(r->var,"new_type")==0)
+            {
+             n->new_type=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if (strcmp(r->var,"new_num_children")==0)
+            {
+             n->new_num_children=atoi(r->v.cstr);
+            }
+          // type_changed="false" is the default
+         }
+       r=r->next;
+      }
+   }
+ return n;
+}
+
+int mi_res_changelist(mi_h *h, mi_gvar_chg **changed)
+{
+ mi_gvar_chg *last, *n;
+ mi_results *res=mi_res_done_var(h,"changelist"), *r;
+ int count=0;
+
+ *changed=NULL;
+ if (!res)
+    return 0;
+ last=NULL;
+ count=1;
+ n=NULL;
+ r=res->v.rs;
+
+ if (res->type==t_list)
+   {// MI v2 a list of tuples
+    while (r)
+      {
+       if (r->type==t_tuple)
+         {
+          n=mi_get_gvar_chg(r->v.rs);
+          if (n)
+            {
+             if (last)
+                last->next=n;
+             else
+                *changed=n;
+             last=n;
+             count++;
+            }
+         }
+       r=r->next;
+      }
+   }
+ else if (res->type==t_tuple)
+   {// MI v1 a tuple with all together *8-P
+    while (r)
+      {
+       if (r->type==t_const) /* Just in case. */
+         {/* Get one var. */
+          if (strcmp(r->var,"name")==0)
+            {
+             if (n)
+               {/* Add to the list*/
+                if (last)
+                   last->next=n;
+                else
+                   *changed=n;
+                last=n;
+                count++;
+               }
+             n=mi_alloc_gvar_chg();
+             if (!n)
+               {
+                mi_free_gvar_chg(*changed);
+                return 0;
+               }
+             n->name=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if ((NULL != n) && (strcmp(r->var,"in_scope")==0))
+            {
+             n->in_scope=strcmp(r->v.cstr,"true")==0;
+            }
+          else if ((NULL != n) && (strcmp(r->var,"new_type")==0))
+            {
+             n->new_type=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if ((NULL != n) && (strcmp(r->var,"new_num_children")==0))
+            {
+             n->new_num_children=atoi(r->v.cstr);
+            }
+          // type_changed="false" is the default
+         }
+       r=r->next;
+      }
+    if (n)
+      {/* Add to the list*/
+       if (last)
+          last->next=n;
+       else
+          *changed=n;
+       last=n;
+       count++;
+      }
+   }
+ mi_free_results(res);
+
+ return count;
+}
+
+int mi_get_children(mi_results *ch, mi_gvar *v)
+{
+ mi_gvar *cur=NULL, *aux;
+ int i=0, count=v->numchild, l;
+
+ while (ch)
+   {
+    if (strcmp(ch->var,"child")==0 && ch->type==t_tuple && i<count)
+      {
+       mi_results *r=ch->v.rs;
+       aux=mi_alloc_gvar();
+       if (!aux)
+          return 0;
+       if (!v->child)
+          v->child=aux;
+       else if (NULL != cur)
+          cur->next=aux;
+       cur=aux;
+       cur->parent=v;
+       cur->depth=v->depth+1;
+
+       while (r)
+         {
+          if (r->type==t_const)
+            {
+             if (strcmp(r->var,"name")==0)
+               {
+                cur->name=r->v.cstr;
+                r->v.cstr=NULL;
+               }
+             else if (strcmp(r->var,"exp")==0)
+               {
+                cur->exp=r->v.cstr;
+                r->v.cstr=NULL;
+               }
+             else if (strcmp(r->var,"type")==0)
+               {
+                cur->type=r->v.cstr;
+                r->v.cstr=NULL;
+                l=strlen(cur->type);
+                if (l && cur->type[l-1]=='*')
+                   cur->ispointer=1;
+               }
+             else if (strcmp(r->var,"value")==0)
+               {
+                cur->value=r->v.cstr;
+                r->v.cstr=NULL;
+               }                     
+             else if (strcmp(r->var,"numchild")==0)
+               {
+                cur->numchild=atoi(r->v.cstr);
+               }
+            }
+          r=r->next;
+         }
+       i++;
+      }
+    ch=ch->next;
+   }
+ v->vischild=i;
+ v->opened=1;
+ return i==v->numchild;
+}
+
+int mi_res_children(mi_h *h, mi_gvar *v)
+{
+ mi_output *r, *res;
+ int ok=0;
+
+ r=mi_get_response_blk(h);
+ res=mi_get_rrecord(r);
+ if (res && res->tclass==MI_CL_DONE)
+   {
+    mi_results *num=mi_get_var(res,"numchild");
+    if (num && num->type==t_const)
+      {
+       v->numchild=atoi(num->v.cstr);
+       if (v->child)
+         {
+          mi_free_gvar(v->child);
+          v->child=NULL;
+         }
+       if (v->numchild)
+         {
+          mi_results *ch =mi_get_var(res,"children");
+          if (ch && ch->type!=t_const) /* MI v1 tuple, MI v2 list */
+             ok=mi_get_children(ch->v.rs,v);
+         }
+       else
+          ok=1;
+      }
+   }
+ mi_free_output(r);
+ return ok;
+}
+
+mi_bkpt *mi_get_bkpt(mi_results *p)
+{
+ mi_bkpt *res;
+ char *end;
+
+ res=mi_alloc_bkpt();
+ if (!res)
+    return NULL;
+ while (p)
+   {
+    if (p->type==t_const && p->var)
+      {
+       if (strcmp(p->var,"number")==0)
+          res->number=atoi(p->v.cstr);
+       else if (strcmp(p->var,"type")==0)
+         {
+          if (strcmp(p->v.cstr,"breakpoint")==0)
+             res->type=t_breakpoint;
+          else
+             res->type=t_unknown;
+         }
+       else if (strcmp(p->var,"disp")==0)
+         {
+          if (strcmp(p->v.cstr,"keep")==0)
+             res->disp=d_keep;
+          else if (strcmp(p->v.cstr,"del")==0)
+             res->disp=d_del;
+          else
+             res->disp=d_unknown;
+         }
+       else if (strcmp(p->var,"enabled")==0)
+          res->enabled=p->v.cstr[0]=='y';
+       else if (strcmp(p->var,"addr")==0)
+          res->addr=(void *)strtoul(p->v.cstr,&end,0);
+       else if (strcmp(p->var,"func")==0)
+         {
+          res->func=p->v.cstr;
+          p->v.cstr=NULL;
+         }
+       else if (strcmp(p->var,"file")==0)
+         {
+          res->file=p->v.cstr;
+          p->v.cstr=NULL;
+         }
+       else if (strcmp(p->var,"line")==0)
+          res->line=atoi(p->v.cstr);
+       else if (strcmp(p->var,"times")==0)
+          res->times=atoi(p->v.cstr);
+       else if (strcmp(p->var,"ignore")==0)
+          res->ignore=atoi(p->v.cstr);
+       else if (strcmp(p->var,"cond")==0)
+         {
+          res->cond=p->v.cstr;
+          p->v.cstr=NULL;
+         }
+      }
+    p=p->next;
+   }
+ return res;
+}
+
+mi_bkpt *mi_res_bkpt(mi_h *h)
+{
+ mi_results *r=mi_res_done_var(h,"bkpt");
+ mi_bkpt *b=NULL;
+
+ if (r && r->type==t_tuple)
+    b=mi_get_bkpt(r->v.rs);
+ mi_free_results(r);
+ return b;
+}
+
+mi_wp *mi_get_wp(mi_results *p, enum mi_wp_mode m)
+{
+ mi_wp *res=mi_alloc_wp();
+
+ if (res)
+   {
+    res->mode=m;
+    while (p)
+      {
+       if (p->type==t_const && p->var)
+         {
+          if (strcmp(p->var,"number")==0)
+            {
+             res->number=atoi(p->v.cstr);
+             res->enabled=1;
+            }
+          else if (strcmp(p->var,"exp")==0)
+            {
+             res->exp=p->v.cstr;
+             p->v.cstr=NULL;
+            }
+         }
+       p=p->next;
+      }
+   }
+ return res;
+}
+
+mi_wp *mi_parse_wp_res(mi_output *r)
+{
+ mi_results *p;
+ enum mi_wp_mode m=wm_unknown;
+
+ /* The info is in a result wpt=... */
+ p=r->c;
+ while (p)
+   {
+    if (p->var)
+      {
+       if (strcmp(p->var,"wpt")==0)
+          m=wm_write;
+       else if (strcmp(p->var,"hw-rwpt")==0)
+          m=wm_read;
+       else if (strcmp(p->var,"hw-awpt")==0)
+          m=wm_rw;
+       if (m!=wm_unknown)
+          break;
+      }
+    p=p->next;
+   }
+ if (!p || p->type!=t_tuple)
+    return NULL;
+ /* Scan the values inside it. */
+ return mi_get_wp(p->v.rs,m);
+}
+
+mi_wp *mi_res_wp(mi_h *h)
+{
+ mi_output *r, *res;
+ mi_wp *ret=NULL;
+
+ r=mi_get_response_blk(h);
+ res=mi_get_rrecord(r);
+
+ if (res)
+    ret=mi_parse_wp_res(res);
+
+ mi_free_output(r);
+ return ret;
+}
+
+char *mi_res_value(mi_h *h)
+{
+ mi_results *r=mi_res_done_var(h,"value");
+ char *s=NULL;
+
+ if (r && r->type==t_const)
+   {
+    s=r->v.cstr;
+    r->v.rs=NULL;
+   }
+ mi_free_results(r);
+ return s;
+}
+
+mi_output *mi_get_stop_record(mi_output *r)
+{
+ while (r)
+   {
+    if (r->type==MI_T_OUT_OF_BAND && r->stype==MI_ST_ASYNC &&
+        r->sstype==MI_SST_EXEC && r->tclass==MI_CL_STOPPED)
+       return r;
+    r=r->next;
+   }
+ return r;
+}
+
+static
+char *reason_names[]=
+{
+ "breakpoint-hit",
+ "watchpoint-trigger",
+ "read-watchpoint-trigger",
+ "access-watchpoint-trigger",
+ "watchpoint-scope",
+ "function-finished",
+ "location-reached",
+ "end-stepping-range",
+ "exited-signalled",
+ "exited",
+ "exited-normally",
+ "signal-received"
+};
+
+static
+enum mi_stop_reason reason_values[]=
+{
+ sr_bkpt_hit,
+ sr_wp_trigger, sr_read_wp_trigger, sr_access_wp_trigger, sr_wp_scope,
+ sr_function_finished, sr_location_reached, sr_end_stepping_range,
+ sr_exited_signalled, sr_exited, sr_exited_normally,
+ sr_signal_received
+};
+
+static
+char *reason_expl[]=
+{
+ "Hit a breakpoint",
+ "Write watchpoint",
+ "Read watchpoint",
+ "Access watchpoint",
+ "Watchpoint out of scope",
+ "Function finished",
+ "Location reached",
+ "End of stepping",
+ "Exited signalled",
+ "Exited with error",
+ "Exited normally",
+ "Signal received"
+};
+
+enum mi_stop_reason mi_reason_str_to_enum(const char *s)
+{
+ int i;
+
+ for (i=0; i<sizeof(reason_names)/sizeof(char *); i++)
+     if (strcmp(reason_names[i],s)==0)
+        return reason_values[i];
+ return sr_unknown;
+}
+
+const char *mi_reason_enum_to_str(enum mi_stop_reason r)
+{
+ int i;
+
+ if (r==sr_unknown)
+    return "Unknown (temp bkp?)";
+ for (i=0; i<sizeof(reason_values)/sizeof(char *); i++)
+     if (reason_values[i]==r)
+        return reason_expl[i];
+ return NULL;
+}
+
+mi_stop *mi_get_stopped(mi_results *r)
+{
+ mi_stop *res=mi_alloc_stop();
+
+ if (res)
+   {
+    while (r)
+      {
+       if (r->type==t_const)
+         {
+          if (strcmp(r->var,"reason")==0)
+             res->reason=mi_reason_str_to_enum(r->v.cstr);
+          else if (!res->have_thread_id && strcmp(r->var,"thread-id")==0)
+            {
+             res->have_thread_id=1;
+             res->thread_id=atoi(r->v.cstr);
+            }
+          else if (!res->have_bkptno && strcmp(r->var,"bkptno")==0)
+            {
+             res->have_bkptno=1;
+             res->bkptno=atoi(r->v.cstr);
+            }
+          else if (!res->have_bkptno && strcmp(r->var,"wpnum")==0)
+            {
+             res->have_wpno=1;
+             res->wpno=atoi(r->v.cstr);
+            }
+          else if (strcmp(r->var,"gdb-result-var")==0)
+            {
+             res->gdb_result_var=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if (strcmp(r->var,"return-value")==0)
+            {
+             res->return_value=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if (strcmp(r->var,"signal-name")==0)
+            {
+             res->signal_name=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if (strcmp(r->var,"signal-meaning")==0)
+            {
+             res->signal_meaning=r->v.cstr;
+             r->v.cstr=NULL;
+            }
+          else if (!res->have_exit_code && strcmp(r->var,"exit-code")==0)
+            {
+             res->have_exit_code=1;
+             res->exit_code=atoi(r->v.cstr);
+            }
+         }
+       else // tuple or list
+         {
+          if (strcmp(r->var,"frame")==0)
+             res->frame=mi_parse_frame(r->v.rs);
+          else if (!res->wp && strcmp(r->var,"wpt")==0)
+             res->wp=mi_get_wp(r->v.rs,wm_write);
+          else if (!res->wp && strcmp(r->var,"hw-rwpt")==0)
+             res->wp=mi_get_wp(r->v.rs,wm_read);
+          else if (!res->wp && strcmp(r->var,"hw-awpt")==0)
+             res->wp=mi_get_wp(r->v.rs,wm_rw);
+          else if (!(res->wp_old || res->wp_val) && strcmp(r->var,"value")==0)
+             {
+              mi_results *p=r->v.rs;
+              while (p)
+                {
+                 if (strcmp(p->var,"value")==0 || strcmp(p->var,"new")==0)
+                   {
+                    res->wp_val=p->v.cstr;
+                    p->v.cstr=NULL;
+                   }
+                 else if (strcmp(p->var,"old")==0)
+                   {
+                    res->wp_old=p->v.cstr;
+                    p->v.cstr=NULL;
+                   }
+                 p=p->next;
+                }
+             }
+         }
+       r=r->next;
+      }
+   }
+ return res;
+}
+
+mi_stop *mi_res_stop(mi_h *h)
+{
+ mi_output *o=mi_retire_response(h);
+ mi_stop *stop=NULL;
+
+ if (o)
+   {
+    mi_output *sr=mi_get_stop_record(o);
+    if (sr)
+       stop=mi_get_stopped(sr->c);
+   }
+ mi_free_output(o);
+
+ return stop;
+}
+
+int mi_get_read_memory(mi_h *h, unsigned char *dest, unsigned ws, int *na,
+                       unsigned long *addr)
+{
+ char *end;
+ mi_results *res=mi_res_done_var(h,"memory"), *r;
+ int ok=0;
+
+ *na=0;
+ r=res;
+ if (r && r->type==t_list && ws==1)
+   {
+    r=r->v.rs;
+    if (r->type!=t_tuple)
+      {
+       mi_free_results(res);
+       return 0;
+      }
+    r=r->v.rs;
+    while (r)
+      {
+       if (r->type==t_list && strcmp(r->var,"data")==0)
+         {
+          mi_results *data=r->v.rs;
+          ok++;
+          if (data && data->type==t_const &&
+              strcmp(data->v.cstr,"N/A")==0)
+             *na=1;
+          else
+             while (data)
+               {
+                if (data->type==t_const)
+                   *(dest++)=strtol(data->v.cstr,&end,0);
+                data=data->next;
+               }
+         }
+       else if (r->type==t_const && strcmp(r->var,"addr")==0)
+         {
+          ok++;
+          if (addr)
+             *addr=strtoul(r->v.cstr,&end,0);
+         }
+       r=r->next;
+      }
+
+   }
+ mi_free_results(res);
+ return ok==2;
+}
+
+mi_asm_insn *mi_parse_insn(mi_results *c)
+{
+ mi_asm_insn *res=NULL, *cur=NULL;
+ mi_results *sub;
+ char *end;
+
+ while (c)
+   {
+    if (c->type==t_tuple)
+      {
+       if (!res)
+          res=cur=mi_alloc_asm_insn();
+       else
+         {
+          cur->next=mi_alloc_asm_insn();
+          cur=cur->next;
+         }
+       if (!cur)
+         {
+          mi_free_asm_insn(res);
+          return NULL;
+         }
+       sub=c->v.rs;
+       while (sub)
+         {
+          if (sub->type==t_const)
+            {
+             if (strcmp(sub->var,"address")==0)
+                cur->addr=(void *)strtoul(sub->v.cstr,&end,0);
+             else if (strcmp(sub->var,"func-name")==0)
+               {
+                cur->func=sub->v.cstr;
+                sub->v.cstr=NULL;
+               }
+             else if (strcmp(sub->var,"offset")==0)
+                cur->offset=atoi(sub->v.cstr);
+             else if (strcmp(sub->var,"inst")==0)
+               {
+                cur->inst=sub->v.cstr;
+                sub->v.cstr=NULL;
+               }
+            }
+          sub=sub->next;
+         }
+      }
+    c=c->next;
+   }
+ return res;
+}
+
+mi_asm_insns *mi_parse_insns(mi_results *c)
+{
+ mi_asm_insns *res=NULL, *cur=NULL;
+ mi_results *sub;
+
+ while (c)
+   {
+    if (c->var)
+      {
+       if (strcmp(c->var,"src_and_asm_line")==0 && c->type==t_tuple)
+         {
+          if (!res)
+             res=cur=mi_alloc_asm_insns();
+          else
+            {
+             cur->next=mi_alloc_asm_insns();
+             cur=cur->next;
+            }
+          if (!cur)
+            {
+             mi_free_asm_insns(res);
+             return NULL;
+            }
+          sub=c->v.rs;
+          while (sub)
+            {
+             if (sub->var)
+               {
+                if (sub->type==t_const)
+                  {
+                   if (strcmp(sub->var,"line")==0)
+                      cur->line=atoi(sub->v.cstr);
+                   else if (strcmp(sub->var,"file")==0)
+                     {
+                      cur->file=sub->v.cstr;
+                      sub->v.cstr=NULL;
+                     }
+                  }
+                else if (sub->type==t_list)
+                  {
+                   if (strcmp(sub->var,"line_asm_insn")==0)
+                      cur->ins=mi_parse_insn(sub->v.rs);
+                  }
+               }
+             sub=sub->next;
+            }
+         }
+      }
+    else
+      {/* No source line, just instructions */
+       res=mi_alloc_asm_insns();
+       res->ins=mi_parse_insn(c);
+       break;
+      }
+    c=c->next;
+   }
+ return res;
+}
+
+
+mi_asm_insns *mi_get_asm_insns(mi_h *h)
+{
+ mi_results *r=mi_res_done_var(h,"asm_insns");
+ mi_asm_insns *f=NULL;
+
+ if (r && r->type==t_list)
+    f=mi_parse_insns(r->v.rs);
+ mi_free_results(r);
+ return f;
+}
+
+mi_chg_reg *mi_parse_list_regs(mi_results *r, int *how_many)
+{
+ mi_results *c=r;
+ int cregs=0;
+ mi_chg_reg *first=NULL, *cur=NULL;
+
+ /* Create the list. */
+ while (c)
+   {
+    if (c->type==t_const && !c->var)
+      {
+       if (first)
+          cur=cur->next=mi_alloc_chg_reg();
+       else
+          first=cur=mi_alloc_chg_reg();
+       
+       if (NULL != cur) {
+               cur->name=c->v.cstr;
+               cur->reg=cregs++;
+               c->v.cstr=NULL;
+       }
+      }
+    c=c->next;
+   }
+ if (how_many)
+    *how_many=cregs;
+
+ return first;
+}
+
+mi_chg_reg *mi_get_list_registers(mi_h *h, int *how_many)
+{
+ mi_results *r=mi_res_done_var(h,"register-names");
+ mi_chg_reg *l=NULL;
+
+ if (r && r->type==t_list)
+    l=mi_parse_list_regs(r->v.rs,how_many);
+ mi_free_results(r);
+ return l;
+}
+
+mi_chg_reg *mi_parse_list_changed_regs(mi_results *r)
+{
+ mi_results *c=r;
+ mi_chg_reg *first=NULL, *cur=NULL;
+
+ /* Create the list. */
+ while (c)
+   {
+    if (c->type==t_const && !c->var)
+      {
+       if (first)
+          cur=cur->next=mi_alloc_chg_reg();
+       else
+          first=cur=mi_alloc_chg_reg();
+       cur->reg=atoi(c->v.cstr);
+      }
+    c=c->next;
+   }
+
+ return first;
+}
+
+mi_chg_reg *mi_get_list_changed_regs(mi_h *h)
+{
+ mi_results *r=mi_res_done_var(h,"changed-registers");
+ mi_chg_reg *changed=NULL;
+
+ if (r && r->type==t_list)
+    changed=mi_parse_list_changed_regs(r->v.rs);
+ mi_free_results(r);
+ return changed;
+}
+
+int mi_parse_reg_values(mi_results *r, mi_chg_reg *l)
+{
+ mi_results *c;
+
+ while (r && l)
+   {
+    if (r->type==t_tuple && !r->var)
+      {
+       c=r->v.rs;
+       while (c)
+         {
+          if (c->type==t_const && c->var)
+            {
+             if (strcmp(c->var,"number")==0)
+               {
+                if (atoi(c->v.cstr)!=l->reg)
+                  {
+                   mi_error=MI_PARSER;
+                   return 0;
+                  }
+               }
+             else if (strcmp(c->var,"value")==0)
+               {
+                l->val=c->v.cstr;
+                c->v.cstr=NULL;
+               }
+            }
+          c=c->next;
+         }
+      }
+    r=r->next;
+    l=l->next;
+   }
+
+ return !l && !r;
+}
+
+int mi_get_reg_values(mi_h *h, mi_chg_reg *l)
+{
+ mi_results *r=mi_res_done_var(h,"register-values");
+ int ok=0;
+
+ if (r && r->type==t_list)
+    ok=mi_parse_reg_values(r->v.rs,l);
+ mi_free_results(r);
+ return ok;
+}
+
+int mi_parse_list_regs_l(mi_results *r, mi_chg_reg *l)
+{
+ while (r && l)
+   {
+    if (r->type==t_const && !r->var)
+      {
+       free(l->name);
+       l->name=r->v.cstr;
+       r->v.cstr=NULL;
+       l=l->next;
+      }
+    r=r->next;
+   }
+
+ return !l && !r;
+}
+
+int mi_get_list_registers_l(mi_h *h, mi_chg_reg *l)
+{
+ mi_results *r=mi_res_done_var(h,"register-names");
+ int ok=0;
+
+ if (r && r->type==t_list)
+    ok=mi_parse_list_regs_l(r->v.rs,l);
+ mi_free_results(r);
+ return ok;
+}
+
+mi_chg_reg *mi_parse_reg_values_l(mi_results *r, int *how_many)
+{
+ mi_results *c;
+ mi_chg_reg *first=NULL, *cur=NULL;
+ *how_many=0;
+
+ while (r)
+   {
+    if (r->type==t_tuple && !r->var)
+      {
+       c=r->v.rs;
+       if (first)
+          cur=cur->next=mi_alloc_chg_reg();
+       else
+          first=cur=mi_alloc_chg_reg();
+       while (c)
+         {
+          if (c->type==t_const && c->var)
+            {
+             if (strcmp(c->var,"number")==0)
+               {
+                if (NULL != cur) 
+                        cur->reg=atoi(c->v.cstr);
+                (*how_many)++;
+               }
+             else if (strcmp(c->var,"value")==0)
+               {
+                if (NULL != cur)
+                         cur->val=c->v.cstr;
+                c->v.cstr=NULL;
+               }
+            }
+          c=c->next;
+         }
+      }
+    r=r->next;
+   }
+
+ return first;
+}
+
+mi_chg_reg *mi_get_reg_values_l(mi_h *h, int *how_many)
+{
+ mi_results *r=mi_res_done_var(h,"register-values");
+ mi_chg_reg *rgs=NULL;
+
+ if (r && r->type==t_list)
+    rgs=mi_parse_reg_values_l(r->v.rs,how_many);
+ mi_free_results(r);
+ return rgs;
+}
+
+
diff --git a/pathologist/src/mi/gdbmi_prg_control.c b/pathologist/src/mi/gdbmi_prg_control.c
new file mode 100644
index 0000000..80ac7af
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_prg_control.c
@@ -0,0 +1,598 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Program control.
+  Comments:
+  GDB/MI commands for the "Program Control" section.  @<p>
+
+@<pre>
+gdb command:                   Implemented?
+
+-exec-abort                    N.A. (*) (kill, but with non-interactive options)
+-exec-arguments                Yes
+-exec-continue                 Yes  ASYNC
+-exec-finish                   Yes  ASYNC
+-exec-interrupt                Yes  ASYNC
+-exec-next                     Yes  ASYNC
+-exec-next-instruction         Yes  ASYNC
+-exec-return                   Yes
+-exec-run                      Yes  ASYNC
+-exec-show-arguments           N.A. (show args) see gmi_stack_info_frame
+-exec-step                     Yes  ASYNC
+-exec-step-instruction         Yes  ASYNC
+-exec-until                    Yes  ASYNC
+-file-exec-and-symbols         Yes
+-file-exec-file                No
+-file-list-exec-sections       N.A. (info file)
+-file-list-exec-source-files   N.A.
+-file-list-shared-libraries    N.A.
+-file-list-symbol-files        N.A.
+-file-symbol-file              Yes
+@</pre>
+
+(*)  gmi_exec_kill implements it, but you should ensure that
+gmi_gdb_set("confirm","off") was called.  @<p>
+
+GDB Bug workaround for -file-exec-and-symbols and -file-symbol-file: This
+is complex, but a real bug. When you set a breakpoint you never know the
+name of the file as it appears in the debug info. So you can be specifying
+an absolute file name or a relative file name. The reference point could be
+different than the one used in the debug info. To solve all the combinations
+gdb does a search trying various combinations. GDB isn't very smart so you
+must at least specify the working directory and the directory where the
+binary is located to get a good chance (+ user options to solve the rest).
+Once you did it gdb can find the file by doing transformations to the
+"canonical" filename. This search works OK for already loaded symtabs
+(symbol tables), but it have a bug when the search is done for psymtabs
+(partial symtabs). The bug is in the use of source_full_path_of (source.c).
+This function calls openp indicating try_cwd_first. It makes the search file
+if the psymtab file name have at least one dirseparator. It means that
+psymtabs for files compiled with relative paths will fail. The search for
+symtabs uses symtab_to_filename, it calls open_source_file which finally
+calls openp without try_cwd_first.@*
+To workaround this bug we must ensure gdb loads *all* the symtabs to memory.
+And here comes another problem -file-exec-and-symbols doesn't support it
+according to docs. In real life that's a wrapper for "file", but as nobody
+can say it won't change we must use the CLI command.
+  
+***************************************************************************/
+
+#include <signal.h>
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_file_exec_and_symbols(mi_h *h, const char *file)
+{
+ if (mi_get_workaround(MI_PSYM_SEARCH))
+    mi_send(h,"file %s -readnow\n",file);
+ else
+    mi_send(h,"-file-exec-and-symbols %s\n",file);
+}
+
+void mi_set_unwind_on_signal_on(mi_h *h)
+{
+        mi_send(h, "set unwindonsignal on\n");
+}
+
+void mi_exec_arguments(mi_h *h, const char *args)
+{
+ mi_send(h,"-exec-arguments %s\n",args);
+}
+
+void mi_exec_run(mi_h *h)
+{
+ mi_send(h,"-exec-run\n");
+}
+
+void mi_exec_continue(mi_h *h)
+{
+ mi_send(h,"-exec-continue\n");
+}
+
+void mi_exec_continue_reverse(mi_h *h)
+{
+ mi_send(h, "-exec-continue --reverse\n");
+}
+
+void mi_target_terminal(mi_h *h, const char *tty_name)
+{
+ mi_send(h,"tty %s\n",tty_name);
+}
+
+void mi_file_symbol_file(mi_h *h, const char *file)
+{
+ if (mi_get_workaround(MI_PSYM_SEARCH))
+    mi_send(h,"symbol-file %s -readnow\n",file);
+ else
+    mi_send(h,"-file-symbol-file %s\n",file);
+}
+
+void mi_exec_finish(mi_h *h)
+{
+ mi_send(h,"-exec-finish\n");
+}
+
+void mi_exec_finish_reverse(mi_h * h)
+{
+ mi_send(h, "-exec-finish --reverse\n");
+}
+void mi_exec_interrupt(mi_h *h)
+{
+ mi_send(h,"-exec-interrupt\n");
+}
+
+void mi_exec_record_process(mi_h *h)
+{
+mi_send(h, "-interpreter-exec mi record\n");
+}
+
+void mi_exec_record_stop(mi_h *h)
+{
+mi_send(h, "-interpreter-exec mi record stop\n");
+}
+
+void mi_exec_next(mi_h *h, int count)
+{
+ if (count>1)
+    mi_send(h,"-exec-next %d\n",count);
+ else
+    mi_send(h,"-exec-next\n");
+}
+
+void mi_exec_next_instruction(mi_h *h)
+{
+ mi_send(h,"-exec-next-instruction\n");
+}
+
+void mi_exec_step(mi_h *h, int count)
+{
+ if (count>1)
+    mi_send(h,"-exec-step %d\n",count);
+ else
+    mi_send(h,"-exec-step\n");
+}
+
+
+void mi_exec_step_back(mi_h *h, int count)
+{
+        if (count>1)
+                mi_send(h, "-exec-step %d --reverse\n", count);
+        else
+                mi_send(h, "-exec-step --reverse\n");
+}
+
+
+void mi_exec_next_reverse(mi_h *h, int count)
+{
+        if (count>1)
+                mi_send(h, "-exec-next %d --reverse\n", count);
+        else
+                mi_send(h, "-exec-next --reverse\n");
+}
+
+
+void mi_exec_step_instruction(mi_h *h)
+{
+ mi_send(h,"-exec-step-instruction\n");
+}
+
+void mi_exec_until(mi_h *h, const char *file, int line)
+{
+ if (!file)
+    mi_send(h,"-exec-until\n");
+ else
+    mi_send(h,"-exec-until %s:%d\n",file,line);
+}
+
+void mi_exec_until_addr(mi_h *h, void *addr)
+{
+ mi_send(h,"-exec-until *%p\n",addr);
+}
+
+void mi_exec_return(mi_h *h)
+{
+ mi_send(h,"-exec-return\n");
+}
+
+void mi_exec_kill(mi_h *h)
+{
+ mi_send(h,"kill\n");
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  Specify the executable and arguments for local debug.
+
+  Command: -file-exec-and-symbols + -exec-arguments
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_set_exec(mi_h *h, const char *file, const char *args)
+{
+ mi_file_exec_and_symbols(h,file);
+ if (!mi_res_simple_done(h))
+    return 0;
+ if (!args)
+    return 1;
+ mi_exec_arguments(h,args);
+ return mi_res_simple_done(h);
+}
+
+int gmi_set_unwind_on_signal_on(mi_h * h)
+{
+        mi_set_unwind_on_signal_on(h);
+        return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Start running the executable. Remote sessions starts running.
+
+  Command: -exec-run
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_run(mi_h *h)
+{
+ mi_exec_run(h);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Continue the execution after a "stop".
+
+  Command: -exec-continue
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_continue(mi_h *h)
+{
+ mi_exec_continue(h);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Continue the execution in reverse order after a "stop".
+
+  Command: -exec-continue --reverse
+  Return: !=0 OK
+
+***************************************************************************/
+int gmi_exec_continue_reverse(mi_h *h)
+{
+        mi_exec_continue_reverse(h);
+        return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Indicate which terminal will use the target program. For local sessions.
+
+  Command: tty
+  Return: !=0 OK
+  Example: 
+  
+***************************************************************************/
+
+int gmi_target_terminal(mi_h *h, const char *tty_name)
+{
+ mi_target_terminal(h,tty_name);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Specify what's the local copy that have debug info. For remote sessions.
+
+  Command: -file-symbol-file
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_file_symbol_file(mi_h *h, const char *file)
+{
+ mi_file_symbol_file(h,file);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Continue until function return, the return value is included in the async
+response.
+
+  Command: -exec-finish
+  Return: !=0 OK.
+  
+***************************************************************************/
+
+int gmi_exec_finish(mi_h *h)
+{
+ mi_exec_finish(h);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Continue backwardly until function return, the return value is included in
+  the async response.
+
+  Command: -exec-finish --reverse
+  Return: !=0 OK.
+
+***************************************************************************/
+int gmi_exec_finish_reverse(mi_h *h)
+{
+ mi_exec_finish_reverse(h);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Stop the program using SIGINT. The corresponding command should be
+-exec-interrupt but not even gdb 6.1.1 can do it because the "async" mode
+isn't really working.
+
+  Command: -exec-interrupt [replacement]
+  Return: Always 1
+  Example: 
+  
+***************************************************************************/
+
+int gmi_exec_interrupt(mi_h *h)
+{
+ // **** IMPORTANT!!! **** Not even gdb 6.1.1 can do it because the "async"
+ // mode isn't really working.
+ //mi_exec_interrupt(h);
+ //return mi_res_simple_running(h);
+
+ kill(h->pid,SIGINT);
+ return 1; // How can I know?
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Next line of code.
+
+  Command: -exec-next
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_next(mi_h *h)
+{
+ mi_exec_next(h,1);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Start recording a process
+
+  Command: -interpreter-exec mi record
+  Return: !=0 OK
+
+***************************************************************************/
+int gmi_exec_record_process(mi_h *h)
+{
+        mi_exec_record_process(h);
+        return 1;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Start recording a process
+
+  Command: -interpreter-exec mi record stop
+  Return: !=0 OK
+
+***************************************************************************/
+int gmi_exec_record_stop(mi_h *h)
+{
+        mi_exec_record_stop(h);
+        return 1;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Skip count lines of code.
+
+  Command: -exec-next count
+  Return: !=0 OK
+
+***************************************************************************/
+
+int gmi_exec_next_cnt(mi_h *h, int count)
+{
+ mi_exec_next(h,count);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Next line of assembler code.
+
+  Command: -exec-next-instruction
+  Return: !=0 OK
+
+***************************************************************************/
+
+int gmi_exec_next_instruction(mi_h *h)
+{
+ mi_exec_next_instruction(h);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Next line of code. Get inside functions.
+
+  Command: -exec-step
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_step(mi_h *h)
+{
+ mi_exec_step(h,1);
+ return mi_res_simple_running(h);
+}
+
+
+
+/**[txh]********************************************************************
+
+  Description:
+  Previous line of code. Get inside functions.
+
+  Command: -exec-step --reverse
+  Return: !=0 OK
+
+***************************************************************************/
+int gmi_exec_step_back(mi_h *h)
+{
+        mi_exec_step_back(h,1);
+        return mi_res_simple_running(h);
+}
+
+
+/**[txh]********************************************************************
+
+  Description:
+  Previous line of code (do not step into).
+
+  Command: -exec-next --reverse
+  Return: !=0 OK
+
+***************************************************************************/
+int gmi_exec_next_reverse(mi_h *h)
+{
+        mi_exec_next_reverse(h,1);
+        return mi_res_simple_running(h);
+}
+
+
+/**[txh]********************************************************************
+
+  Description:
+  Next count lines of code. Get inside functions.
+
+  Command: -exec-step count
+  Return: !=0 OK
+
+***************************************************************************/
+
+int gmi_exec_step_cnt(mi_h *h, int count)
+{
+ mi_exec_step(h,count);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Next line of assembler code. Get inside calls.
+
+  Command: -exec-step-instruction
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_step_instruction(mi_h *h)
+{
+ mi_exec_step_instruction(h);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Execute until location is reached. If file is NULL then is until next
+line.
+
+  Command: -exec-until
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_until(mi_h *h, const char *file, int line)
+{
+ mi_exec_until(h,file,line);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Execute until location is reached.
+
+  Command: -exec-until (using *address)
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_until_addr(mi_h *h, void *addr)
+{
+ mi_exec_until_addr(h,addr);
+ return mi_res_simple_running(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Return to previous frame inmediatly.
+
+  Command: -exec-return
+  Return: A pointer to a new mi_frames structure indicating the current
+location. NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_exec_return(mi_h *h)
+{
+ mi_exec_return(h);
+ return mi_res_frame(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Just kill the program. That's what -exec-abort should do, but it isn't
+implemented by gdb. This implementation only works if the interactive mode
+is disabled (gmi_gdb_set("confirm","off")).
+
+  Command: -exec-abort [using kill]
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_exec_kill(mi_h *h)
+{
+ mi_exec_kill(h);
+ return mi_res_simple_done(h);
+}
+
diff --git a/pathologist/src/mi/gdbmi_stack_man.c b/pathologist/src/mi/gdbmi_stack_man.c
new file mode 100644
index 0000000..977ea5e
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_stack_man.c
@@ -0,0 +1,222 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Stack manipulation.
+  Comments:
+  GDB/MI commands for the "Stack Manipulation" section.  @<p>
+
+@<pre>
+gdb command:              Implemented?
+
+-stack-info-frame         Yes, implemented as "frame"
+-stack-info-depth         Yes
+-stack-list-arguments     Yes
+-stack-list-frames        Yes
+-stack-list-locals        Yes
+-stack-select-frame       Yes
+@</pre>
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_stack_list_frames(mi_h *h, int from, int to)
+{
+ if (from<0)
+    mi_send(h,"-stack-list-frames\n");
+ else
+    mi_send(h,"-stack-list-frames %d %d\n",from,to);
+}
+
+void mi_stack_list_arguments(mi_h *h, int show, int from, int to)
+{
+ if (from<0)
+    mi_send(h,"-stack-list-arguments %d\n",show);
+ else
+    mi_send(h,"-stack-list-arguments %d %d %d\n",show,from,to);
+}
+
+void mi_stack_info_frame(mi_h *h)
+{
+ mi_send(h,"frame\n");
+}
+
+void mi_stack_info_depth(mi_h *h, int depth)
+{
+ if (depth<0)
+    mi_send(h,"-stack-info-depth\n");
+ else
+    mi_send(h,"-stack-info-depth %d\n",depth);
+}
+
+void mi_stack_select_frame(mi_h *h, int framenum)
+{
+ mi_send(h,"-stack-select-frame %d\n",framenum);
+}
+
+void mi_stack_list_locals(mi_h *h, int show)
+{
+ mi_send(h,"-stack-list-locals %d\n",show);
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  List of frames. Arguments aren't filled.
+
+  Command: -stack-list-frames
+  Return:  A new list of mi_frames or NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_stack_list_frames(mi_h *h)
+{
+ mi_stack_list_frames(h,-1,-1);
+ return mi_res_frames_array(h,"stack");
+}
+
+/**[txh]********************************************************************
+
+  Description: 
+  List of frames. Arguments aren't filled. Only the frames in the from
+ - to range are returned.
+  
+  Command: -stack-list-frames
+  Return:  A new list of mi_frames or NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_stack_list_frames_r(mi_h *h, int from, int to)
+{
+ mi_stack_list_frames(h,from,to);
+ return mi_res_frames_array(h,"stack");
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  List arguments. Only level and args filled.
+  
+  Command: -stack-list-arguments
+  Return:  A new list of mi_frames or NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_stack_list_arguments(mi_h *h, int show)
+{
+ mi_stack_list_arguments(h,show,-1,-1);
+ return mi_res_frames_array(h,"stack-args");
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  List arguments. Only level and args filled. Only for the
+frames in the from - to range.
+  
+  Command: -stack-list-arguments
+  Return:  A new list of mi_frames or NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_stack_list_arguments_r(mi_h *h, int show, int from, int to)
+{
+ mi_stack_list_arguments(h,show,from,to);
+ return mi_res_frames_array(h,"stack-args");
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Information about the current frame, including args.
+
+  Command: -stack-info-frame [using frame]
+  Return: A new mi_frames or NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_stack_info_frame(mi_h *h)
+{
+ mi_stack_info_frame(h);
+ return mi_res_frame(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Stack info depth.
+
+  Command: -stack-info-depth
+  Return: The depth or -1 on error.
+  
+***************************************************************************/
+
+int gmi_stack_info_depth(mi_h *h, int max_depth)
+{
+ mi_results *r;
+ int ret=-1;
+
+ mi_stack_info_depth(h,max_depth);
+ r=mi_res_done_var(h,"depth");
+ if (r && r->type==t_const)
+   {
+    ret=atoi(r->v.cstr);
+    mi_free_results(r);
+   }
+ return ret;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Set stack info depth.
+
+  Command: -stack-info-depth [no args]
+  Return: The depth or -1 on error.
+  Example: 
+  
+***************************************************************************/
+
+int gmi_stack_info_depth_get(mi_h *h)
+{
+ return gmi_stack_info_depth(h,-1);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Change current frame.
+
+  Command: -stack-select-frame
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_stack_select_frame(mi_h *h, int framenum)
+{
+ mi_stack_select_frame(h,framenum);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  List of local vars.
+
+  Command: -stack-list-locals
+  Return: A new mi_results tree containing the variables or NULL on error.
+  
+***************************************************************************/
+
+mi_results *gmi_stack_list_locals(mi_h *h, int show)
+{
+ mi_stack_list_locals(h,show);
+ return mi_res_done_var(h,"locals");
+}
+
diff --git a/pathologist/src/mi/gdbmi_symbol_query.c b/pathologist/src/mi/gdbmi_symbol_query.c
new file mode 100644
index 0000000..8910517
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_symbol_query.c
@@ -0,0 +1,32 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Symbol query.
+  Comments:
+  GDB/MI commands for the "Symbol Query" section.@p
+
+@<pre>
+gdb command:              Implemented?
+-symbol-info-address      N.A. (info address, human readable)
+-symbol-info-file         N.A.
+-symbol-info-function     N.A.
+-symbol-info-line         N.A. (info line, human readable)
+-symbol-info-symbol       N.A. (info symbol, human readable)
+-symbol-list-functions    N.A. (info functions, human readable)
+-symbol-list-types        N.A. (info types, human readable)
+-symbol-list-variables    N.A. (info variables, human readable)
+-symbol-list-lines        No (gdb 6.x)
+-symbol-locate            N.A.
+-symbol-type              N.A. (ptype, human readable)
+@</pre>
+
+Note:@p
+
+Only one is implemented and not in gdb 5.x.@p
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
diff --git a/pathologist/src/mi/gdbmi_target_man.c b/pathologist/src/mi/gdbmi_target_man.c
new file mode 100644
index 0000000..bbb2b98
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_target_man.c
@@ -0,0 +1,119 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004-2007 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Target manipulation.
+  Comments:
+  GDB/MI commands for the "Target Manipulation" section.  @<p>
+
+@<pre>
+-target-attach                  Yes (implemented using attach)
+-target-compare-sections        N.A. (compare-sections)
+-target-detach                  Yes
+-target-download                Yes
+-target-exec-status             N.A.
+-target-list-available-targets  N.A. (help target)
+-target-list-current-targets    N.A. (info file among other things)
+-target-list-parameters         N.A.
+-target-select                  Yes
+@</pre>
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_target_select(mi_h *h, const char *type, const char *params)
+{
+ mi_send(h,"-target-select %s %s\n",type,params);
+}
+
+/* Note: -target-attach isn't currently implemented :-( (gdb 6.1.1) */
+void mi_target_attach(mi_h *h, pid_t pid)
+{
+ mi_send(h,"attach %d\n",pid);
+}
+
+void mi_target_detach(mi_h *h)
+{
+ mi_send(h,"-target-detach\n");
+}
+
+void mi_target_download(mi_h *h)
+{
+ mi_send(h,"-target-download\n");
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  Connect to a remote gdbserver using the specified methode.
+
+  Command: -target-select
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_target_select(mi_h *h, const char *type, const char *params)
+{
+ mi_target_select(h,type,params);
+ if (!mi_res_simple_connected(h))
+    return 0;
+ mi_send_target_commands(h);
+ return 1;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Attach to an already running process.
+
+  Command: -target-attach [using attach]
+  Return: The frame of the current location, NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_target_attach(mi_h *h, pid_t pid)
+{
+ mi_target_attach(h,pid);
+ //return mi_res_simple_done(h);
+ return mi_res_frame(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Detach from an attached process.
+
+  Command: -target-detach
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_target_detach(mi_h *h)
+{
+ mi_target_detach(h);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Loads the executable onto the remote target.
+
+  Command: -target-download
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_target_download(mi_h *h)
+{
+ mi_target_download(h);
+ // TODO: this response have some data
+ return mi_res_simple_done(h);
+}
+
diff --git a/pathologist/src/mi/gdbmi_thread.c b/pathologist/src/mi/gdbmi_thread.c
new file mode 100644
index 0000000..b8fa63d
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_thread.c
@@ -0,0 +1,89 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Thread commands.
+  Comments:
+  GDB/MI commands for the "Thread Commands" section.  @<p>
+
+@<pre>
+gdb command:              Implemented?
+-thread-info              N.A.
+-thread-list-all-threads  Yes, implemented as "info threads"
+-thread-list-ids          Yes
+-thread-select            Yes
+@</pre>
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_thread_list_ids(mi_h *h)
+{
+ mi_send(h,"-thread-list-ids\n");
+}
+
+void mi_thread_select(mi_h *h, int id)
+{
+ mi_send(h,"-thread-select %d\n",id);
+}
+
+void mi_thread_list_all_threads(mi_h *h)
+{
+ mi_send(h,"info threads\n");
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  List available thread ids.
+
+  Command: -thread-list-ids
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_thread_list_ids(mi_h *h, int **list)
+{
+ mi_thread_list_ids(h);
+ return mi_res_thread_ids(h,list);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Select a thread.
+
+  Command: -thread-select
+  Return: A new mi_frames or NULL on error.
+  
+***************************************************************************/
+
+mi_frames *gmi_thread_select(mi_h *h, int id)
+{
+ mi_thread_select(h,id);
+ return mi_res_frame(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Get a list of frames for each available thread. Implemented using "info
+thread".
+
+  Command: -thread-list-all-threads
+  Return: A kist of frames, NULL on error
+  
+***************************************************************************/
+
+mi_frames *gmi_thread_list_all_threads(mi_h *h)
+{
+ mi_thread_list_all_threads(h);
+ return mi_res_frames_list(h);
+}
+
diff --git a/pathologist/src/mi/gdbmi_var_obj.c b/pathologist/src/mi/gdbmi_var_obj.c
new file mode 100644
index 0000000..435feec
--- /dev/null
+++ b/pathologist/src/mi/gdbmi_var_obj.c
@@ -0,0 +1,371 @@
+/**[txh]********************************************************************
+
+  Copyright (c) 2004 by Salvador E. Tropea.
+  Covered by the GPL license.
+
+  Module: Variable objects.
+  Comments:
+  GDB/MI commands for the "Variable Objects" section.
+    @<p>
+
+@<pre>
+gdb command:              Imp? Description:
+-var-create               Yes  create a variable object
+-var-delete               Yes  delete the variable object and its children
+-var-set-format           Yes  set the display format of this variable
+-var-show-format          Yes  show the display format of this variable
+-var-info-num-children    Yes  tells how many children this object has
+-var-list-children        Yes* return a list of the object's children
+-var-info-type            Yes  show the type of this variable object
+-var-info-expression      Yes  print what this variable object represents
+-var-show-attributes      Yes  is this variable editable?
+-var-evaluate-expression  Yes  get the value of this variable
+-var-assign               Yes  set the value of this variable
+-var-update               Yes* update the variable and its children
+@</pre>
+
+Notes:  @<p>
+1) I suggest letting gdb to choose the names for the variables.@*
+2) -var-list-children supports an optional "show values" argument in MI v2.
+It isn't implemented.@*
+
+  @<p>
+
+* MI v1 and v2 result formats supported.  @<p>
+
+***************************************************************************/
+
+#include "gdbmi.h"
+
+/* Low level versions. */
+
+void mi_var_create(mi_h *h, const char *name, int frame, const char *exp)
+{
+ const char *n=name ? name : "-";
+
+ if (frame<0)
+    mi_send(h,"-var-create %s * %s\n",n,exp);
+ else
+    mi_send(h,"-var-create %s %d %s\n",n,frame,exp);
+}
+
+void mi_var_delete(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-delete %s\n",name);
+}
+
+void mi_var_set_format(mi_h *h, const char *name, const char *format)
+{
+ mi_send(h,"-var-set-format \"%s\" %s\n",name,format);
+}
+
+void mi_var_show_format(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-show-format \"%s\"\n",name);
+}
+
+void mi_var_info_num_children(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-info-num-children \"%s\"\n",name);
+}
+
+void mi_var_info_type(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-info-type \"%s\"\n",name);
+}
+
+void mi_var_info_expression(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-info-expression \"%s\"\n",name);
+}
+
+void mi_var_show_attributes(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-show-attributes \"%s\"\n",name);
+}
+
+void mi_var_update(mi_h *h, const char *name)
+{
+ if (name)
+    mi_send(h,"-var-update %s\n",name);
+ else
+    mi_send(h,"-var-update *\n");
+}
+
+void mi_var_assign(mi_h *h, const char *name, const char *expression)
+{
+ mi_send(h,"-var-assign \"%s\" \"%s\"\n",name,expression);
+}
+
+void mi_var_evaluate_expression(mi_h *h, const char *name)
+{
+ mi_send(h,"-var-evaluate-expression \"%s\"\n",name);
+}
+
+void mi_var_list_children(mi_h *h, const char *name)
+{
+ if (h->version>=MI_VERSION2U(2,0,0))
+    mi_send(h,"-var-list-children --all-values \"%s\"\n",name);
+ else
+    mi_send(h,"-var-list-children \"%s\"\n",name);
+}
+
+/* High level versions. */
+
+/**[txh]********************************************************************
+
+  Description:
+  Create a variable object. I recommend using gmi_var_create and letting
+gdb choose the names.
+
+  Command: -var-create
+  Return: A new mi_gvar strcture or NULL on error.
+  
+***************************************************************************/
+
+mi_gvar *gmi_var_create_nm(mi_h *h, const char *name, int frame, const char *exp)
+{
+ mi_var_create(h,name,frame,exp);
+ return mi_res_gvar(h,NULL,exp);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Create a variable object. The name is selected by gdb. Alternative:
+  gmi_full_var_create.
+
+  Command: -var-create [auto name]
+  Return: A new mi_gvar strcture or NULL on error.
+  
+***************************************************************************/
+
+mi_gvar *gmi_var_create(mi_h *h, int frame, const char *exp)
+{
+ return gmi_var_create_nm(h,NULL,frame,exp);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Delete a variable object. Doesn't free the mi_gvar data.
+
+  Command: -var-delete
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_delete(mi_h *h, mi_gvar *var)
+{
+ mi_var_delete(h,var->name);
+ return mi_res_simple_done(h);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Set the format used to represent the result.
+
+  Command: -var-set-format
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_set_format(mi_h *h, mi_gvar *var, enum mi_gvar_fmt format)
+{
+ int ret;
+
+ mi_var_set_format(h,var->name,mi_format_enum_to_str(format));
+ ret=mi_res_simple_done(h);
+ if (ret)
+    var->format=format;
+ return ret;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Fill the format field with info from gdb.
+
+  Command: -var-show-format
+  Return: !=0 OK.
+  
+***************************************************************************/
+
+int gmi_var_show_format(mi_h *h, mi_gvar *var)
+{
+ mi_var_show_format(h,var->name);
+ return mi_res_gvar(h,var,NULL)!=NULL;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Fill the numchild field with info from gdb.
+
+  Command: -var-info-num-children
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_info_num_children(mi_h *h, mi_gvar *var)
+{
+ mi_var_info_num_children(h,var->name);
+ return mi_res_gvar(h,var,NULL)!=NULL;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Fill the type field with info from gdb.
+
+  Command: -var-info-type
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_info_type(mi_h *h, mi_gvar *var)
+{
+ mi_var_info_type(h,var->name);
+ return mi_res_gvar(h,var,NULL)!=NULL;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Fill the expression and lang fields with info from gdb. Note that lang
+isn't filled during creation.
+
+  Command: -var-info-expression
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_info_expression(mi_h *h, mi_gvar *var)
+{
+ mi_var_info_expression(h,var->name);
+ return mi_res_gvar(h,var,NULL)!=NULL;
+}
+
+
+/**[txh]********************************************************************
+
+  Description:
+  Fill the attr field with info from gdb. Note that attr isn't filled
+during creation.
+
+  Command: -var-show-attributes
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_show_attributes(mi_h *h, mi_gvar *var)
+{
+ mi_var_show_attributes(h,var->name);
+ return mi_res_gvar(h,var,NULL)!=NULL;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Create the variable and also fill the lang and attr fields. The name is
+selected by gdb.
+
+  Command: -var-create + -var-info-expression + -var-show-attributes
+  Return: A new mi_gvar strcture or NULL on error.
+  
+***************************************************************************/
+
+mi_gvar *gmi_full_var_create(mi_h *h, int frame, const char *exp)
+{
+ mi_gvar *var=gmi_var_create_nm(h,NULL,frame,exp);
+ if (var)
+   {/* What if it fails? */
+    gmi_var_info_expression(h,var);
+    gmi_var_show_attributes(h,var);
+   }
+ return var;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Update variable. Use NULL for all. Note that *changed can be NULL if none
+updated.
+
+  Command: -var-update
+  Return: !=0 OK. The changed list contains the list of changed vars.
+  
+***************************************************************************/
+
+int gmi_var_update(mi_h *h, mi_gvar *var, mi_gvar_chg **changed)
+{
+ mi_var_update(h,var ? var->name : NULL);
+ return mi_res_changelist(h,changed);
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Change variable. The new value replaces the value field.
+
+  Command: -var-assign
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_assign(mi_h *h, mi_gvar *var, const char *expression)
+{
+ char *res;
+ mi_var_assign(h,var->name,expression);
+ res=mi_res_value(h);
+ if (res)
+   {
+    free(var->value);
+    var->value=res;
+    return 1;
+   }
+ return 0;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  Fill the value field getting the current value for a variable.
+
+  Command: -var-evaluate-expression
+  Return: !=0 OK, value contains the result.
+  
+***************************************************************************/
+
+int gmi_var_evaluate_expression(mi_h *h, mi_gvar *var)
+{
+ char *s;
+
+ mi_var_evaluate_expression(h,var->name);
+ s=mi_res_value(h);
+ if (s)
+   {
+    free(var->value);
+    var->value=s;
+   }
+ return s!=NULL;
+}
+
+/**[txh]********************************************************************
+
+  Description:
+  List children. It ONLY returns the first level information. :-(@*
+  On success the child field contains the list of children.
+
+  Command: -var-list-children
+  Return: !=0 OK
+  
+***************************************************************************/
+
+int gmi_var_list_children(mi_h *h, mi_gvar *var)
+{
+ mi_var_list_children(h,var->name);
+ return mi_res_children(h,var);
+}
+
diff --git a/pathologist/src/minixml/Makefile.am b/pathologist/src/minixml/Makefile.am
new file mode 100644
index 0000000..423fbdc
--- /dev/null
+++ b/pathologist/src/minixml/Makefile.am
@@ -0,0 +1,27 @@
+INCLUDES = -I$(top_srcdir)/src/include -I$(top_builddir)/src/include
+
+if MINGW
+ WINFLAGS = -Wl,--no-undefined -Wl,--export-all-symbols 
+endif
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+  XLIB = -lgcov
+endif
+
+lib_LTLIBRARIES = libminixml.la
+
+libminixml_la_SOURCES = \
+         mxml-attr.c \
+         mxmldoc.c \
+         mxml-entity.c \
+         mxml-file.c \
+         mxml-get.c \
+         mxml-index.c \
+         mxml-node.c \
+         mxml-private.c \
+         mxml-private.h \
+         mxml-search.c \
+         mxml-set.c \
+         mxml-string.c \
+         config.h
\ No newline at end of file
diff --git a/pathologist/src/minixml/config.h b/pathologist/src/minixml/config.h
new file mode 100644
index 0000000..8bae4bf
--- /dev/null
+++ b/pathologist/src/minixml/config.h
@@ -0,0 +1,95 @@
+/*
+ * "$Id: config.h.in 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Configuration file for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+
+/*
+ * Version number...
+ */
+
+#define MXML_VERSION    ""
+
+
+/*
+ * Inline function support...
+ */
+
+#define inline
+
+
+/*
+ * Long long support...
+ */
+
+#undef HAVE_LONG_LONG
+
+
+/*
+ * Do we have the snprintf() and vsnprintf() functions?
+ */
+
+#undef HAVE_SNPRINTF
+#undef HAVE_VSNPRINTF
+
+
+/*
+ * Do we have the strXXX() functions?
+ */
+
+#undef HAVE_STRDUP
+
+
+/*
+ * Do we have threading support?
+ */
+
+#undef HAVE_PTHREAD_H
+
+
+/*
+ * Define prototypes for string functions as needed...
+ */
+
+#  ifndef HAVE_STRDUP
+extern char     *_mxml_strdup(const char *);
+#    define strdup _mxml_strdup
+#  endif /* !HAVE_STRDUP */
+
+extern char     *_mxml_strdupf(const char *, ...);
+extern char     *_mxml_vstrdupf(const char *, va_list);
+
+#  ifndef HAVE_SNPRINTF
+extern int      _mxml_snprintf(char *, size_t, const char *, ...);
+#    define snprintf _mxml_snprintf
+#  endif /* !HAVE_SNPRINTF */
+
+#  ifndef HAVE_VSNPRINTF
+extern int      _mxml_vsnprintf(char *, size_t, const char *, va_list);
+#    define vsnprintf _mxml_vsnprintf
+#  endif /* !HAVE_VSNPRINTF */
+
+/*
+ * End of "$Id: config.h.in 408 2010-09-19 05:26:46Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-attr.c b/pathologist/src/minixml/mxml-attr.c
new file mode 100644
index 0000000..c9950f5
--- /dev/null
+++ b/pathologist/src/minixml/mxml-attr.c
@@ -0,0 +1,319 @@
+/*
+ * "$Id: mxml-attr.c 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Attribute support code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlElementDeleteAttr() - Delete an attribute.
+ *   mxmlElementGetAttr()    - Get an attribute.
+ *   mxmlElementSetAttr()    - Set an attribute.
+ *   mxmlElementSetAttrf()   - Set an attribute with a formatted value.
+ *   mxml_set_attr()         - Set or add an attribute name/value pair.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Local functions...
+ */
+
+static int      mxml_set_attr(mxml_node_t *node, const char *name,
+                              char *value);
+
+
+/*
+ * 'mxmlElementDeleteAttr()' - Delete an attribute.
+ *
+ * @since Mini-XML 2.4@
+ */
+
+void
+mxmlElementDeleteAttr(mxml_node_t *node,/* I - Element */
+                      const char  *name)/* I - Attribute name */
+{
+  int           i;                      /* Looping var */
+  mxml_attr_t   *attr;                  /* Cirrent attribute */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlElementDeleteAttr(node=%p, name=\"%s\")\n",
+          node, name ? name : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name)
+    return;
+
+ /*
+  * Look for the attribute...
+  */
+
+  for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+       i > 0;
+       i --, attr ++)
+  {
+#ifdef DEBUG
+    printf("    %s=\"%s\"\n", attr->name, attr->value);
+#endif /* DEBUG */
+
+    if (!strcmp(attr->name, name))
+    {
+     /*
+      * Delete this attribute...
+      */
+
+      free(attr->name);
+      free(attr->value);
+
+      i --;
+      if (i > 0)
+        memmove(attr, attr + 1, i * sizeof(mxml_attr_t));
+
+      node->value.element.num_attrs --;
+      return;
+    }
+  }
+}
+
+
+/*
+ * 'mxmlElementGetAttr()' - Get an attribute.
+ *
+ * This function returns NULL if the node is not an element or the
+ * named attribute does not exist.
+ */
+
+const char *                            /* O - Attribute value or NULL */
+mxmlElementGetAttr(mxml_node_t *node,   /* I - Element node */
+                   const char  *name)   /* I - Name of attribute */
+{
+  int           i;                      /* Looping var */
+  mxml_attr_t   *attr;                  /* Cirrent attribute */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlElementGetAttr(node=%p, name=\"%s\")\n",
+          node, name ? name : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name)
+    return (NULL);
+
+ /*
+  * Look for the attribute...
+  */
+
+  for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+       i > 0;
+       i --, attr ++)
+  {
+#ifdef DEBUG
+    printf("    %s=\"%s\"\n", attr->name, attr->value);
+#endif /* DEBUG */
+
+    if (!strcmp(attr->name, name))
+    {
+#ifdef DEBUG
+      printf("    Returning \"%s\"!\n", attr->value);
+#endif /* DEBUG */
+      return (attr->value);
+    }
+  }
+
+ /*
+  * Didn't find attribute, so return NULL...
+  */
+
+#ifdef DEBUG
+  puts("    Returning NULL!\n");
+#endif /* DEBUG */
+
+  return (NULL);
+}
+
+
+/*
+ * 'mxmlElementSetAttr()' - Set an attribute.
+ *
+ * If the named attribute already exists, the value of the attribute
+ * is replaced by the new string value. The string value is copied
+ * into the element node. This function does nothing if the node is
+ * not an element.
+ */
+
+void
+mxmlElementSetAttr(mxml_node_t *node,   /* I - Element node */
+                   const char  *name,   /* I - Name of attribute */
+                   const char  *value)  /* I - Attribute value */
+{
+  char  *valuec;                        /* Copy of value */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlElementSetAttr(node=%p, name=\"%s\", value=\"%s\")\n",
+          node, name ? name : "(null)", value ? value : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name)
+    return;
+
+  if (value)
+    valuec = strdup(value);
+  else
+    valuec = NULL;
+
+  if (mxml_set_attr(node, name, valuec))
+    free(valuec);
+}
+
+
+/*
+ * 'mxmlElementSetAttrf()' - Set an attribute with a formatted value.
+ *
+ * If the named attribute already exists, the value of the attribute
+ * is replaced by the new formatted string. The formatted string value is
+ * copied into the element node. This function does nothing if the node
+ * is not an element.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+void
+mxmlElementSetAttrf(mxml_node_t *node,  /* I - Element node */
+                    const char  *name,  /* I - Name of attribute */
+                    const char  *format,/* I - Printf-style attribute value */
+                    ...)                /* I - Additional arguments as needed */
+{
+  va_list       ap;                     /* Argument pointer */
+  char          *value;                 /* Value */
+
+
+#ifdef DEBUG
+  fprintf(stderr,
+          "mxmlElementSetAttrf(node=%p, name=\"%s\", format=\"%s\", ...)\n",
+          node, name ? name : "(null)", format ? format : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name || !format)
+    return;
+
+ /*
+  * Format the value...
+  */
+
+  va_start(ap, format);
+  value = _mxml_vstrdupf(format, ap);
+  va_end(ap);
+
+  if (!value)
+    mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
+               name, node->value.element.name);
+  else if (mxml_set_attr(node, name, value))
+    free(value);
+}
+
+
+/*
+ * 'mxml_set_attr()' - Set or add an attribute name/value pair.
+ */
+
+static int                              /* O - 0 on success, -1 on failure */
+mxml_set_attr(mxml_node_t *node,        /* I - Element node */
+              const char  *name,        /* I - Attribute name */
+              char        *value)       /* I - Attribute value */
+{
+  int           i;                      /* Looping var */
+  mxml_attr_t   *attr;                  /* New attribute */
+
+
+ /*
+  * Look for the attribute...
+  */
+
+  for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+       i > 0;
+       i --, attr ++)
+    if (!strcmp(attr->name, name))
+    {
+     /*
+      * Free the old value as needed...
+      */
+
+      if (attr->value)
+        free(attr->value);
+
+      attr->value = value;
+
+      return (0);
+    }
+
+ /*
+  * Add a new attribute...
+  */
+
+  if (node->value.element.num_attrs == 0)
+    attr = malloc(sizeof(mxml_attr_t));
+  else
+    attr = realloc(node->value.element.attrs,
+                   (node->value.element.num_attrs + 1) * sizeof(mxml_attr_t));
+
+  if (!attr)
+  {
+    mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
+               name, node->value.element.name);
+    return (-1);
+  }
+
+  node->value.element.attrs = attr;
+  attr += node->value.element.num_attrs;
+
+  if ((attr->name = strdup(name)) == NULL)
+  {
+    mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
+               name, node->value.element.name);
+    return (-1);
+  }
+
+  attr->value = value;
+
+  node->value.element.num_attrs ++;
+
+  return (0);
+}
+
+
+/*
+ * End of "$Id: mxml-attr.c 408 2010-09-19 05:26:46Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-entity.c b/pathologist/src/minixml/mxml-entity.c
new file mode 100644
index 0000000..c5c9f61
--- /dev/null
+++ b/pathologist/src/minixml/mxml-entity.c
@@ -0,0 +1,460 @@
+/*
+ * "$Id: mxml-entity.c 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Character entity support code for Mini-XML, a small XML-like
+ * file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlEntityAddCallback()    - Add a callback to convert entities to
+ *                                Unicode.
+ *   mxmlEntityGetName()        - Get the name that corresponds to the
+ *                                character value.
+ *   mxmlEntityGetValue()       - Get the character corresponding to a named
+ *                                entity.
+ *   mxmlEntityRemoveCallback() - Remove a callback.
+ *   _mxml_entity_cb()          - Lookup standard (X)HTML entities.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "mxml-private.h"
+
+
+/*
+ * 'mxmlEntityAddCallback()' - Add a callback to convert entities to Unicode.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlEntityAddCallback(
+    mxml_entity_cb_t cb)                /* I - Callback function to add */
+{
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+  if (global->num_entity_cbs < (int)(sizeof(global->entity_cbs) / sizeof(global->entity_cbs[0])))
+  {
+    global->entity_cbs[global->num_entity_cbs] = cb;
+    global->num_entity_cbs ++;
+
+    return (0);
+  }
+  else
+  {
+    mxml_error("Unable to add entity callback!");
+
+    return (-1);
+  }
+}
+
+
+/*
+ * 'mxmlEntityGetName()' - Get the name that corresponds to the character value.
+ *
+ * If val does not need to be represented by a named entity, NULL is returned.
+ */
+
+const char *                            /* O - Entity name or NULL */
+mxmlEntityGetName(int val)              /* I - Character value */
+{
+  switch (val)
+  {
+    case '&' :
+        return ("amp");
+
+    case '<' :
+        return ("lt");
+
+    case '>' :
+        return ("gt");
+
+    case '\"' :
+        return ("quot");
+
+    default :
+        return (NULL);
+  }
+}
+
+
+/*
+ * 'mxmlEntityGetValue()' - Get the character corresponding to a named entity.
+ *
+ * The entity name can also be a numeric constant. -1 is returned if the
+ * name is not known.
+ */
+
+int                                     /* O - Character value or -1 on error */
+mxmlEntityGetValue(const char *name)    /* I - Entity name */
+{
+  int           i;                      /* Looping var */
+  int           ch;                     /* Character value */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+  for (i = 0; i < global->num_entity_cbs; i ++)
+    if ((ch = (global->entity_cbs[i])(name)) >= 0)
+      return (ch);
+
+  return (-1);
+}
+
+
+/*
+ * 'mxmlEntityRemoveCallback()' - Remove a callback.
+ */
+
+void
+mxmlEntityRemoveCallback(
+    mxml_entity_cb_t cb)                /* I - Callback function to remove */
+{
+  int           i;                      /* Looping var */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+  for (i = 0; i < global->num_entity_cbs; i ++)
+    if (cb == global->entity_cbs[i])
+    {
+     /*
+      * Remove the callback...
+      */
+
+      global->num_entity_cbs --;
+
+      if (i < global->num_entity_cbs)
+        memmove(global->entity_cbs + i, global->entity_cbs + i + 1,
+                (global->num_entity_cbs - i) * sizeof(global->entity_cbs[0]));
+
+      return;
+    }
+}
+
+
+/*
+ * '_mxml_entity_cb()' - Lookup standard (X)HTML entities.
+ */
+
+int                                     /* O - Unicode value or -1 */
+_mxml_entity_cb(const char *name)       /* I - Entity name */
+{
+  int   diff,                           /* Difference between names */
+        current,                        /* Current entity in search */
+        first,                          /* First entity in search */
+        last;                           /* Last entity in search */
+  static const struct
+  {
+    const char  *name;                  /* Entity name */
+    int         val;                    /* Character value */
+  }     entities[] =
+  {
+    { "AElig",          198 },
+    { "Aacute",         193 },
+    { "Acirc",          194 },
+    { "Agrave",         192 },
+    { "Alpha",          913 },
+    { "Aring",          197 },
+    { "Atilde",         195 },
+    { "Auml",           196 },
+    { "Beta",           914 },
+    { "Ccedil",         199 },
+    { "Chi",            935 },
+    { "Dagger",         8225 },
+    { "Delta",          916 },
+    { "Dstrok",         208 },
+    { "ETH",            208 },
+    { "Eacute",         201 },
+    { "Ecirc",          202 },
+    { "Egrave",         200 },
+    { "Epsilon",        917 },
+    { "Eta",            919 },
+    { "Euml",           203 },
+    { "Gamma",          915 },
+    { "Iacute",         205 },
+    { "Icirc",          206 },
+    { "Igrave",         204 },
+    { "Iota",           921 },
+    { "Iuml",           207 },
+    { "Kappa",          922 },
+    { "Lambda",         923 },
+    { "Mu",             924 },
+    { "Ntilde",         209 },
+    { "Nu",             925 },
+    { "OElig",          338 },
+    { "Oacute",         211 },
+    { "Ocirc",          212 },
+    { "Ograve",         210 },
+    { "Omega",          937 },
+    { "Omicron",        927 },
+    { "Oslash",         216 },
+    { "Otilde",         213 },
+    { "Ouml",           214 },
+    { "Phi",            934 },
+    { "Pi",             928 },
+    { "Prime",          8243 },
+    { "Psi",            936 },
+    { "Rho",            929 },
+    { "Scaron",         352 },
+    { "Sigma",          931 },
+    { "THORN",          222 },
+    { "Tau",            932 },
+    { "Theta",          920 },
+    { "Uacute",         218 },
+    { "Ucirc",          219 },
+    { "Ugrave",         217 },
+    { "Upsilon",        933 },
+    { "Uuml",           220 },
+    { "Xi",             926 },
+    { "Yacute",         221 },
+    { "Yuml",           376 },
+    { "Zeta",           918 },
+    { "aacute",         225 },
+    { "acirc",          226 },
+    { "acute",          180 },
+    { "aelig",          230 },
+    { "agrave",         224 },
+    { "alefsym",        8501 },
+    { "alpha",          945 },
+    { "amp",            '&' },
+    { "and",            8743 },
+    { "ang",            8736 },
+    { "apos",           '\'' },
+    { "aring",          229 },
+    { "asymp",          8776 },
+    { "atilde",         227 },
+    { "auml",           228 },
+    { "bdquo",          8222 },
+    { "beta",           946 },
+    { "brkbar",         166 },
+    { "brvbar",         166 },
+    { "bull",           8226 },
+    { "cap",            8745 },
+    { "ccedil",         231 },
+    { "cedil",          184 },
+    { "cent",           162 },
+    { "chi",            967 },
+    { "circ",           710 },
+    { "clubs",          9827 },
+    { "cong",           8773 },
+    { "copy",           169 },
+    { "crarr",          8629 },
+    { "cup",            8746 },
+    { "curren",         164 },
+    { "dArr",           8659 },
+    { "dagger",         8224 },
+    { "darr",           8595 },
+    { "deg",            176 },
+    { "delta",          948 },
+    { "diams",          9830 },
+    { "die",            168 },
+    { "divide",         247 },
+    { "eacute",         233 },
+    { "ecirc",          234 },
+    { "egrave",         232 },
+    { "empty",          8709 },
+    { "emsp",           8195 },
+    { "ensp",           8194 },
+    { "epsilon",        949 },
+    { "equiv",          8801 },
+    { "eta",            951 },
+    { "eth",            240 },
+    { "euml",           235 },
+    { "euro",           8364 },
+    { "exist",          8707 },
+    { "fnof",           402 },
+    { "forall",         8704 },
+    { "frac12",         189 },
+    { "frac14",         188 },
+    { "frac34",         190 },
+    { "frasl",          8260 },
+    { "gamma",          947 },
+    { "ge",             8805 },
+    { "gt",             '>' },
+    { "hArr",           8660 },
+    { "harr",           8596 },
+    { "hearts",         9829 },
+    { "hellip",         8230 },
+    { "hibar",          175 },
+    { "iacute",         237 },
+    { "icirc",          238 },
+    { "iexcl",          161 },
+    { "igrave",         236 },
+    { "image",          8465 },
+    { "infin",          8734 },
+    { "int",            8747 },
+    { "iota",           953 },
+    { "iquest",         191 },
+    { "isin",           8712 },
+    { "iuml",           239 },
+    { "kappa",          954 },
+    { "lArr",           8656 },
+    { "lambda",         955 },
+    { "lang",           9001 },
+    { "laquo",          171 },
+    { "larr",           8592 },
+    { "lceil",          8968 },
+    { "ldquo",          8220 },
+    { "le",             8804 },
+    { "lfloor",         8970 },
+    { "lowast",         8727 },
+    { "loz",            9674 },
+    { "lrm",            8206 },
+    { "lsaquo",         8249 },
+    { "lsquo",          8216 },
+    { "lt",             '<' },
+    { "macr",           175 },
+    { "mdash",          8212 },
+    { "micro",          181 },
+    { "middot",         183 },
+    { "minus",          8722 },
+    { "mu",             956 },
+    { "nabla",          8711 },
+    { "nbsp",           160 },
+    { "ndash",          8211 },
+    { "ne",             8800 },
+    { "ni",             8715 },
+    { "not",            172 },
+    { "notin",          8713 },
+    { "nsub",           8836 },
+    { "ntilde",         241 },
+    { "nu",             957 },
+    { "oacute",         243 },
+    { "ocirc",          244 },
+    { "oelig",          339 },
+    { "ograve",         242 },
+    { "oline",          8254 },
+    { "omega",          969 },
+    { "omicron",        959 },
+    { "oplus",          8853 },
+    { "or",             8744 },
+    { "ordf",           170 },
+    { "ordm",           186 },
+    { "oslash",         248 },
+    { "otilde",         245 },
+    { "otimes",         8855 },
+    { "ouml",           246 },
+    { "para",           182 },
+    { "part",           8706 },
+    { "permil",         8240 },
+    { "perp",           8869 },
+    { "phi",            966 },
+    { "pi",             960 },
+    { "piv",            982 },
+    { "plusmn",         177 },
+    { "pound",          163 },
+    { "prime",          8242 },
+    { "prod",           8719 },
+    { "prop",           8733 },
+    { "psi",            968 },
+    { "quot",           '\"' },
+    { "rArr",           8658 },
+    { "radic",          8730 },
+    { "rang",           9002 },
+    { "raquo",          187 },
+    { "rarr",           8594 },
+    { "rceil",          8969 },
+    { "rdquo",          8221 },
+    { "real",           8476 },
+    { "reg",            174 },
+    { "rfloor",         8971 },
+    { "rho",            961 },
+    { "rlm",            8207 },
+    { "rsaquo",         8250 },
+    { "rsquo",          8217 },
+    { "sbquo",          8218 },
+    { "scaron",         353 },
+    { "sdot",           8901 },
+    { "sect",           167 },
+    { "shy",            173 },
+    { "sigma",          963 },
+    { "sigmaf",         962 },
+    { "sim",            8764 },
+    { "spades",         9824 },
+    { "sub",            8834 },
+    { "sube",           8838 },
+    { "sum",            8721 },
+    { "sup",            8835 },
+    { "sup1",           185 },
+    { "sup2",           178 },
+    { "sup3",           179 },
+    { "supe",           8839 },
+    { "szlig",          223 },
+    { "tau",            964 },
+    { "there4",         8756 },
+    { "theta",          952 },
+    { "thetasym",       977 },
+    { "thinsp",         8201 },
+    { "thorn",          254 },
+    { "tilde",          732 },
+    { "times",          215 },
+    { "trade",          8482 },
+    { "uArr",           8657 },
+    { "uacute",         250 },
+    { "uarr",           8593 },
+    { "ucirc",          251 },
+    { "ugrave",         249 },
+    { "uml",            168 },
+    { "upsih",          978 },
+    { "upsilon",        965 },
+    { "uuml",           252 },
+    { "weierp",         8472 },
+    { "xi",             958 },
+    { "yacute",         253 },
+    { "yen",            165 },
+    { "yuml",           255 },
+    { "zeta",           950 },
+    { "zwj",            8205 },
+    { "zwnj",           8204 }
+  };
+
+
+ /*
+  * Do a binary search for the named entity...
+  */
+
+  first = 0;
+  last  = (int)(sizeof(entities) / sizeof(entities[0]) - 1);
+
+  while ((last - first) > 1)
+  {
+    current = (first + last) / 2;
+
+    if ((diff = strcmp(name, entities[current].name)) == 0)
+      return (entities[current].val);
+    else if (diff < 0)
+      last = current;
+    else
+      first = current;
+  }
+
+ /*
+  * If we get here, there is a small chance that there is still
+  * a match; check first and last...
+  */
+
+  if (!strcmp(name, entities[first].name))
+    return (entities[first].val);
+  else if (!strcmp(name, entities[last].name))
+    return (entities[last].val);
+  else
+    return (-1);
+}
+
+
+/*
+ * End of "$Id: mxml-entity.c 408 2010-09-19 05:26:46Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-file.c b/pathologist/src/minixml/mxml-file.c
new file mode 100644
index 0000000..9927040
--- /dev/null
+++ b/pathologist/src/minixml/mxml-file.c
@@ -0,0 +1,3080 @@
+/*
+ * "$Id: mxml-file.c 438 2011-03-24 05:47:51Z mike $"
+ *
+ * File loading code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlLoadFd()            - Load a file descriptor into an XML node tree.
+ *   mxmlLoadFile()          - Load a file into an XML node tree.
+ *   mxmlLoadString()        - Load a string into an XML node tree.
+ *   mxmlSaveAllocString()   - Save an XML tree to an allocated string.
+ *   mxmlSaveFd()            - Save an XML tree to a file descriptor.
+ *   mxmlSaveFile()          - Save an XML tree to a file.
+ *   mxmlSaveString()        - Save an XML node tree to a string.
+ *   mxmlSAXLoadFd()         - Load a file descriptor into an XML node tree
+ *                             using a SAX callback.
+ *   mxmlSAXLoadFile()       - Load a file into an XML node tree
+ *                             using a SAX callback.
+ *   mxmlSAXLoadString()     - Load a string into an XML node tree
+ *                             using a SAX callback.
+ *   mxmlSetCustomHandlers() - Set the handling functions for custom data.
+ *   mxmlSetErrorCallback()  - Set the error message callback.
+ *   mxmlSetWrapMargin()     - Set the wrap margin when saving XML data.
+ *   mxml_add_char()         - Add a character to a buffer, expanding as needed.
+ *   mxml_fd_getc()          - Read a character from a file descriptor.
+ *   mxml_fd_putc()          - Write a character to a file descriptor.
+ *   mxml_fd_read()          - Read a buffer of data from a file descriptor.
+ *   mxml_fd_write()         - Write a buffer of data to a file descriptor.
+ *   mxml_file_getc()        - Get a character from a file.
+ *   mxml_file_putc()        - Write a character to a file.
+ *   mxml_get_entity()       - Get the character corresponding to an entity...
+ *   mxml_load_data()        - Load data into an XML node tree.
+ *   mxml_parse_element()    - Parse an element for any attributes...
+ *   mxml_string_getc()      - Get a character from a string.
+ *   mxml_string_putc()      - Write a character to a string.
+ *   mxml_write_name()       - Write a name string.
+ *   mxml_write_node()       - Save an XML node to a file.
+ *   mxml_write_string()     - Write a string, escaping & and < as needed.
+ *   mxml_write_ws()         - Do whitespace callback...
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#ifndef WIN32
+#  include <unistd.h>
+#endif /* !WIN32 */
+#include "mxml-private.h"
+
+
+/*
+ * Character encoding...
+ */
+
+#define ENCODE_UTF8     0               /* UTF-8 */
+#define ENCODE_UTF16BE  1               /* UTF-16 Big-Endian */
+#define ENCODE_UTF16LE  2               /* UTF-16 Little-Endian */
+
+
+/*
+ * Macro to test for a bad XML character...
+ */
+
+#define mxml_bad_char(ch) ((ch) < ' ' && (ch) != '\n' && (ch) != '\r' && (ch) != '\t')
+
+
+/*
+ * Types and structures...
+ */
+
+typedef int (*_mxml_getc_cb_t)(void *, int *);
+typedef int (*_mxml_putc_cb_t)(int, void *);
+
+typedef struct _mxml_fdbuf_s            /**** File descriptor buffer ****/
+{
+  int           fd;                     /* File descriptor */
+  unsigned char *current,               /* Current position in buffer */
+                *end,                   /* End of buffer */
+                buffer[8192];           /* Character buffer */
+} _mxml_fdbuf_t;
+
+
+/*
+ * Local functions...
+ */
+
+static int              mxml_add_char(int ch, char **ptr, char **buffer,
+                                      int *bufsize);
+static int              mxml_fd_getc(void *p, int *encoding);
+static int              mxml_fd_putc(int ch, void *p);
+static int              mxml_fd_read(_mxml_fdbuf_t *buf);
+static int              mxml_fd_write(_mxml_fdbuf_t *buf);
+static int              mxml_file_getc(void *p, int *encoding);
+static int              mxml_file_putc(int ch, void *p);
+static int              mxml_get_entity(mxml_node_t *parent, void *p,
+                                        int *encoding,
+                                        _mxml_getc_cb_t getc_cb);
+static inline int       mxml_isspace(int ch)
+                        {
+                          return (ch == ' ' || ch == '\t' || ch == '\r' ||
+                                  ch == '\n');
+                        }
+static mxml_node_t      *mxml_load_data(mxml_node_t *top, void *p,
+                                        mxml_load_cb_t cb,
+                                        _mxml_getc_cb_t getc_cb,
+                                        mxml_sax_cb_t sax_cb, void *sax_data);
+static int              mxml_parse_element(mxml_node_t *node, void *p,
+                                           int *encoding,
+                                           _mxml_getc_cb_t getc_cb);
+static int              mxml_string_getc(void *p, int *encoding);
+static int              mxml_string_putc(int ch, void *p);
+static int              mxml_write_name(const char *s, void *p,
+                                        _mxml_putc_cb_t putc_cb);
+static int              mxml_write_node(mxml_node_t *node, void *p,
+                                        mxml_save_cb_t cb, int col,
+                                        _mxml_putc_cb_t putc_cb,
+                                        _mxml_global_t *global);
+static int              mxml_write_string(const char *s, void *p,
+                                          _mxml_putc_cb_t putc_cb);
+static int              mxml_write_ws(mxml_node_t *node, void *p, 
+                                      mxml_save_cb_t cb, int ws,
+                                      int col, _mxml_putc_cb_t putc_cb);
+
+
+/*
+ * 'mxmlLoadFd()' - Load a file descriptor into an XML node tree.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ */
+
+mxml_node_t *                           /* O - First node or NULL if the file could not be read. */
+mxmlLoadFd(mxml_node_t    *top,         /* I - Top node */
+           int            fd,           /* I - File descriptor to read from */
+           mxml_load_cb_t cb)           /* I - Callback function or MXML_NO_CALLBACK */
+{
+  _mxml_fdbuf_t buf;                    /* File descriptor buffer */
+
+
+ /*
+  * Initialize the file descriptor buffer...
+  */
+
+  buf.fd      = fd;
+  buf.current = buf.buffer;
+  buf.end     = buf.buffer;
+
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, &buf, cb, mxml_fd_getc, MXML_NO_CALLBACK, NULL));
+}
+
+
+/*
+ * 'mxmlLoadFile()' - Load a file into an XML node tree.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ */
+
+mxml_node_t *                           /* O - First node or NULL if the file could not be read. */
+mxmlLoadFile(mxml_node_t    *top,       /* I - Top node */
+             FILE           *fp,        /* I - File to read from */
+             mxml_load_cb_t cb)         /* I - Callback function or MXML_NO_CALLBACK */
+{
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, fp, cb, mxml_file_getc, MXML_NO_CALLBACK, NULL));
+}
+
+
+/*
+ * 'mxmlLoadString()' - Load a string into an XML node tree.
+ *
+ * The nodes in the specified string are added to the specified top node.
+ * If no top node is provided, the XML string MUST be well-formed with a
+ * single parent node like <?xml> for the entire string. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ */
+
+mxml_node_t *                           /* O - First node or NULL if the string has errors. */
+mxmlLoadString(mxml_node_t    *top,     /* I - Top node */
+               const char     *s,       /* I - String to load */
+               mxml_load_cb_t cb)       /* I - Callback function or MXML_NO_CALLBACK */
+{
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, (void *)&s, cb, mxml_string_getc, MXML_NO_CALLBACK,
+                         NULL));
+}
+
+
+/*
+ * 'mxmlSaveAllocString()' - Save an XML tree to an allocated string.
+ *
+ * This function returns a pointer to a string containing the textual
+ * representation of the XML node tree.  The string should be freed
+ * using the free() function when you are done with it.  NULL is returned
+ * if the node would produce an empty string or if the string cannot be
+ * allocated.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+char *                                  /* O - Allocated string or NULL */
+mxmlSaveAllocString(
+    mxml_node_t    *node,               /* I - Node to write */
+    mxml_save_cb_t cb)                  /* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+  int   bytes;                          /* Required bytes */
+  char  buffer[8192];                   /* Temporary buffer */
+  char  *s;                             /* Allocated string */
+
+
+ /*
+  * Write the node to the temporary buffer...
+  */
+
+  bytes = mxmlSaveString(node, buffer, sizeof(buffer), cb);
+
+  if (bytes <= 0)
+    return (NULL);
+
+  if (bytes < (int)(sizeof(buffer) - 1))
+  {
+   /*
+    * Node fit inside the buffer, so just duplicate that string and
+    * return...
+    */
+
+    return (strdup(buffer));
+  }
+
+ /*
+  * Allocate a buffer of the required size and save the node to the
+  * new buffer...
+  */
+
+  if ((s = malloc(bytes + 1)) == NULL)
+    return (NULL);
+
+  mxmlSaveString(node, s, bytes + 1, cb);
+
+ /*
+  * Return the allocated string...
+  */
+
+  return (s);
+}
+
+
+/*
+ * 'mxmlSaveFd()' - Save an XML tree to a file descriptor.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+int                                     /* O - 0 on success, -1 on error. */
+mxmlSaveFd(mxml_node_t    *node,        /* I - Node to write */
+           int            fd,           /* I - File descriptor to write to */
+           mxml_save_cb_t cb)           /* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+  int           col;                    /* Final column */
+  _mxml_fdbuf_t buf;                    /* File descriptor buffer */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+ /*
+  * Initialize the file descriptor buffer...
+  */
+
+  buf.fd      = fd;
+  buf.current = buf.buffer;
+  buf.end     = buf.buffer + sizeof(buf.buffer);
+
+ /*
+  * Write the node...
+  */
+
+  if ((col = mxml_write_node(node, &buf, cb, 0, mxml_fd_putc, global)) < 0)
+    return (-1);
+
+  if (col > 0)
+    if (mxml_fd_putc('\n', &buf) < 0)
+      return (-1);
+
+ /*
+  * Flush and return...
+  */
+
+  return (mxml_fd_write(&buf));
+}
+
+
+/*
+ * 'mxmlSaveFile()' - Save an XML tree to a file.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+int                                     /* O - 0 on success, -1 on error. */
+mxmlSaveFile(mxml_node_t    *node,      /* I - Node to write */
+             FILE           *fp,        /* I - File to write to */
+             mxml_save_cb_t cb)         /* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+  int   col;                            /* Final column */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+ /*
+  * Write the node...
+  */
+
+  if ((col = mxml_write_node(node, fp, cb, 0, mxml_file_putc, global)) < 0)
+    return (-1);
+
+  if (col > 0)
+    if (putc('\n', fp) < 0)
+      return (-1);
+
+ /*
+  * Return 0 (success)...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSaveString()' - Save an XML node tree to a string.
+ *
+ * This function returns the total number of bytes that would be
+ * required for the string but only copies (bufsize - 1) characters
+ * into the specified buffer.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+int                                     /* O - Size of string */
+mxmlSaveString(mxml_node_t    *node,    /* I - Node to write */
+               char           *buffer,  /* I - String buffer */
+               int            bufsize,  /* I - Size of string buffer */
+               mxml_save_cb_t cb)       /* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+  int   col;                            /* Final column */
+  char  *ptr[2];                        /* Pointers for putc_cb */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+ /*
+  * Write the node...
+  */
+
+  ptr[0] = buffer;
+  ptr[1] = buffer + bufsize;
+
+  if ((col = mxml_write_node(node, ptr, cb, 0, mxml_string_putc, global)) < 0)
+    return (-1);
+
+  if (col > 0)
+    mxml_string_putc('\n', ptr);
+
+ /*
+  * Nul-terminate the buffer...
+  */
+
+  if (ptr[0] >= ptr[1])
+    buffer[bufsize - 1] = '\0';
+  else
+    ptr[0][0] = '\0';
+
+ /*
+  * Return the number of characters...
+  */
+
+  return (ptr[0] - buffer);
+}
+
+
+/*
+ * 'mxmlSAXLoadFd()' - Load a file descriptor into an XML node tree
+ *                     using a SAX callback.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ *
+ * The SAX callback must call mxmlRetain() for any nodes that need to
+ * be kept for later use. Otherwise, nodes are deleted when the parent
+ * node is closed or after each data, comment, CDATA, or directive node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *                           /* O - First node or NULL if the file could not be read. */
+mxmlSAXLoadFd(mxml_node_t    *top,      /* I - Top node */
+              int            fd,        /* I - File descriptor to read from */
+              mxml_load_cb_t cb,        /* I - Callback function or MXML_NO_CALLBACK */
+              mxml_sax_cb_t  sax_cb,    /* I - SAX callback or MXML_NO_CALLBACK */
+              void           *sax_data) /* I - SAX user data */
+{
+  _mxml_fdbuf_t buf;                    /* File descriptor buffer */
+
+
+ /*
+  * Initialize the file descriptor buffer...
+  */
+
+  buf.fd      = fd;
+  buf.current = buf.buffer;
+  buf.end     = buf.buffer;
+
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, &buf, cb, mxml_fd_getc, sax_cb, sax_data));
+}
+
+
+/*
+ * 'mxmlSAXLoadFile()' - Load a file into an XML node tree
+ *                       using a SAX callback.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ *
+ * The SAX callback must call mxmlRetain() for any nodes that need to
+ * be kept for later use. Otherwise, nodes are deleted when the parent
+ * node is closed or after each data, comment, CDATA, or directive node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *                           /* O - First node or NULL if the file could not be read. */
+mxmlSAXLoadFile(
+    mxml_node_t    *top,                /* I - Top node */
+    FILE           *fp,                 /* I - File to read from */
+    mxml_load_cb_t cb,                  /* I - Callback function or MXML_NO_CALLBACK */
+    mxml_sax_cb_t  sax_cb,              /* I - SAX callback or MXML_NO_CALLBACK */
+    void           *sax_data)           /* I - SAX user data */
+{
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, fp, cb, mxml_file_getc, sax_cb, sax_data));
+}
+
+
+/*
+ * 'mxmlSAXLoadString()' - Load a string into an XML node tree
+ *                         using a SAX callback.
+ *
+ * The nodes in the specified string are added to the specified top node.
+ * If no top node is provided, the XML string MUST be well-formed with a
+ * single parent node like <?xml> for the entire string. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ *
+ * The SAX callback must call mxmlRetain() for any nodes that need to
+ * be kept for later use. Otherwise, nodes are deleted when the parent
+ * node is closed or after each data, comment, CDATA, or directive node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *                           /* O - First node or NULL if the string has errors. */
+mxmlSAXLoadString(
+    mxml_node_t    *top,                /* I - Top node */
+    const char     *s,                  /* I - String to load */
+    mxml_load_cb_t cb,                  /* I - Callback function or MXML_NO_CALLBACK */
+    mxml_sax_cb_t  sax_cb,              /* I - SAX callback or MXML_NO_CALLBACK */
+    void           *sax_data)           /* I - SAX user data */
+{
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, (void *)&s, cb, mxml_string_getc, sax_cb, sax_data));
+}
+
+
+/*
+ * 'mxmlSetCustomHandlers()' - Set the handling functions for custom data.
+ *
+ * The load function accepts a node pointer and a data string and must
+ * return 0 on success and non-zero on error.
+ *
+ * The save function accepts a node pointer and must return a malloc'd
+ * string on success and NULL on error.
+ * 
+ */
+
+void
+mxmlSetCustomHandlers(
+    mxml_custom_load_cb_t load,         /* I - Load function */
+    mxml_custom_save_cb_t save)         /* I - Save function */
+{
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+  global->custom_load_cb = load;
+  global->custom_save_cb = save;
+}
+
+
+/*
+ * 'mxmlSetErrorCallback()' - Set the error message callback.
+ */
+
+void
+mxmlSetErrorCallback(mxml_error_cb_t cb)/* I - Error callback function */
+{
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+  global->error_cb = cb;
+}
+
+
+/*
+ * 'mxmlSetWrapMargin()' - Set the wrap margin when saving XML data.
+ *
+ * Wrapping is disabled when "column" is 0.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+void
+mxmlSetWrapMargin(int column)           /* I - Column for wrapping, 0 to disable wrapping */
+{
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+  global->wrap = column;
+}
+
+
+/*
+ * 'mxml_add_char()' - Add a character to a buffer, expanding as needed.
+ */
+
+static int                              /* O  - 0 on success, -1 on error */
+mxml_add_char(int  ch,                  /* I  - Character to add */
+              char **bufptr,            /* IO - Current position in buffer */
+              char **buffer,            /* IO - Current buffer */
+              int  *bufsize)            /* IO - Current buffer size */
+{
+  char  *newbuffer;                     /* New buffer value */
+
+
+  if (*bufptr >= (*buffer + *bufsize - 4))
+  {
+   /*
+    * Increase the size of the buffer...
+    */
+
+    if (*bufsize < 1024)
+      (*bufsize) *= 2;
+    else
+      (*bufsize) += 1024;
+
+    if ((newbuffer = realloc(*buffer, *bufsize)) == NULL)
+    {
+      free(*buffer);
+
+      mxml_error("Unable to expand string buffer to %d bytes!", *bufsize);
+
+      return (-1);
+    }
+
+    *bufptr = newbuffer + (*bufptr - *buffer);
+    *buffer = newbuffer;
+  }
+
+  if (ch < 0x80)
+  {
+   /*
+    * Single byte ASCII...
+    */
+
+    *(*bufptr)++ = ch;
+  }
+  else if (ch < 0x800)
+  {
+   /*
+    * Two-byte UTF-8...
+    */
+
+    *(*bufptr)++ = 0xc0 | (ch >> 6);
+    *(*bufptr)++ = 0x80 | (ch & 0x3f);
+  }
+  else if (ch < 0x10000)
+  {
+   /*
+    * Three-byte UTF-8...
+    */
+
+    *(*bufptr)++ = 0xe0 | (ch >> 12);
+    *(*bufptr)++ = 0x80 | ((ch >> 6) & 0x3f);
+    *(*bufptr)++ = 0x80 | (ch & 0x3f);
+  }
+  else
+  {
+   /*
+    * Four-byte UTF-8...
+    */
+
+    *(*bufptr)++ = 0xf0 | (ch >> 18);
+    *(*bufptr)++ = 0x80 | ((ch >> 12) & 0x3f);
+    *(*bufptr)++ = 0x80 | ((ch >> 6) & 0x3f);
+    *(*bufptr)++ = 0x80 | (ch & 0x3f);
+  }
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_fd_getc()' - Read a character from a file descriptor.
+ */
+
+static int                              /* O  - Character or EOF */
+mxml_fd_getc(void *p,                   /* I  - File descriptor buffer */
+             int  *encoding)            /* IO - Encoding */
+{
+  _mxml_fdbuf_t *buf;                   /* File descriptor buffer */
+  int           ch,                     /* Current character */
+                temp;                   /* Temporary character */
+
+
+ /*
+  * Grab the next character in the buffer...
+  */
+
+  buf = (_mxml_fdbuf_t *)p;
+
+  if (buf->current >= buf->end)
+    if (mxml_fd_read(buf) < 0)
+      return (EOF);
+
+  ch = *(buf->current)++;
+
+  switch (*encoding)
+  {
+    case ENCODE_UTF8 :
+       /*
+        * Got a UTF-8 character; convert UTF-8 to Unicode and return...
+        */
+
+        if (!(ch & 0x80))
+        {
+#if DEBUG > 1
+          printf("mxml_fd_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+          if (mxml_bad_char(ch))
+          {
+            mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                       ch);
+            return (EOF);
+          }
+
+          return (ch);
+        }
+        else if (ch == 0xfe)
+        {
+         /*
+          * UTF-16 big-endian BOM?
+          */
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          ch = *(buf->current)++;
+          
+          if (ch != 0xff)
+            return (EOF);
+
+          *encoding = ENCODE_UTF16BE;
+
+          return (mxml_fd_getc(p, encoding));
+        }
+        else if (ch == 0xff)
+        {
+         /*
+          * UTF-16 little-endian BOM?
+          */
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          ch = *(buf->current)++;
+          
+          if (ch != 0xfe)
+            return (EOF);
+
+          *encoding = ENCODE_UTF16LE;
+
+          return (mxml_fd_getc(p, encoding));
+        }
+        else if ((ch & 0xe0) == 0xc0)
+        {
+         /*
+          * Two-byte value...
+          */
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          if ((temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = ((ch & 0x1f) << 6) | (temp & 0x3f);
+
+          if (ch < 0x80)
+          {
+            mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+            return (EOF);
+          }
+        }
+        else if ((ch & 0xf0) == 0xe0)
+        {
+         /*
+          * Three-byte value...
+          */
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          if ((temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = ((ch & 0x0f) << 6) | (temp & 0x3f);
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          if ((temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = (ch << 6) | (temp & 0x3f);
+
+          if (ch < 0x800)
+          {
+            mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+            return (EOF);
+          }
+
+         /*
+          * Ignore (strip) Byte Order Mark (BOM)...
+          */
+
+          if (ch == 0xfeff)
+            return (mxml_fd_getc(p, encoding));
+        }
+        else if ((ch & 0xf8) == 0xf0)
+        {
+         /*
+          * Four-byte value...
+          */
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          if ((temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = ((ch & 0x07) << 6) | (temp & 0x3f);
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          if ((temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = (ch << 6) | (temp & 0x3f);
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          if ((temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = (ch << 6) | (temp & 0x3f);
+
+          if (ch < 0x10000)
+          {
+            mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+            return (EOF);
+          }
+        }
+        else
+          return (EOF);
+        break;
+
+    case ENCODE_UTF16BE :
+       /*
+        * Read UTF-16 big-endian char...
+        */
+
+        if (buf->current >= buf->end)
+          if (mxml_fd_read(buf) < 0)
+            return (EOF);
+
+        temp = *(buf->current)++;
+
+        ch = (ch << 8) | temp;
+
+        if (mxml_bad_char(ch))
+        {
+          mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                     ch);
+          return (EOF);
+        }
+        else if (ch >= 0xd800 && ch <= 0xdbff)
+        {
+         /*
+          * Multi-word UTF-16 char...
+          */
+
+          int lch;
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          lch = *(buf->current)++;
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          lch = (lch << 8) | temp;
+
+          if (lch < 0xdc00 || lch >= 0xdfff)
+            return (EOF);
+
+          ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+        }
+        break;
+
+    case ENCODE_UTF16LE :
+       /*
+        * Read UTF-16 little-endian char...
+        */
+
+        if (buf->current >= buf->end)
+          if (mxml_fd_read(buf) < 0)
+            return (EOF);
+
+        temp = *(buf->current)++;
+
+        ch |= (temp << 8);
+
+        if (mxml_bad_char(ch))
+        {
+          mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                     ch);
+          return (EOF);
+        }
+        else if (ch >= 0xd800 && ch <= 0xdbff)
+        {
+         /*
+          * Multi-word UTF-16 char...
+          */
+
+          int lch;
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          lch = *(buf->current)++;
+
+          if (buf->current >= buf->end)
+            if (mxml_fd_read(buf) < 0)
+              return (EOF);
+
+          temp = *(buf->current)++;
+
+          lch |= (temp << 8);
+
+          if (lch < 0xdc00 || lch >= 0xdfff)
+            return (EOF);
+
+          ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+        }
+        break;
+  }
+
+#if DEBUG > 1
+  printf("mxml_fd_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+  return (ch);
+}
+
+
+/*
+ * 'mxml_fd_putc()' - Write a character to a file descriptor.
+ */
+
+static int                              /* O - 0 on success, -1 on error */
+mxml_fd_putc(int  ch,                   /* I - Character */
+             void *p)                   /* I - File descriptor buffer */
+{
+  _mxml_fdbuf_t *buf;                   /* File descriptor buffer */
+
+
+ /*
+  * Flush the write buffer as needed...
+  */
+
+  buf = (_mxml_fdbuf_t *)p;
+
+  if (buf->current >= buf->end)
+    if (mxml_fd_write(buf) < 0)
+      return (-1);
+
+  *(buf->current)++ = ch;
+
+ /*
+  * Return successfully...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_fd_read()' - Read a buffer of data from a file descriptor.
+ */
+
+static int                              /* O - 0 on success, -1 on error */
+mxml_fd_read(_mxml_fdbuf_t *buf)                /* I - File descriptor buffer */
+{
+  int   bytes;                          /* Bytes read... */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!buf)
+    return (-1);
+
+ /*
+  * Read from the file descriptor...
+  */
+
+  while ((bytes = read(buf->fd, buf->buffer, sizeof(buf->buffer))) < 0)
+#ifdef EINTR
+    if (errno != EAGAIN && errno != EINTR)
+#else
+    if (errno != EAGAIN)
+#endif /* EINTR */
+      return (-1);
+
+  if (bytes == 0)
+    return (-1);
+
+ /*
+  * Update the pointers and return success...
+  */
+
+  buf->current = buf->buffer;
+  buf->end     = buf->buffer + bytes;
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_fd_write()' - Write a buffer of data to a file descriptor.
+ */
+
+static int                              /* O - 0 on success, -1 on error */
+mxml_fd_write(_mxml_fdbuf_t *buf)       /* I - File descriptor buffer */
+{
+  int           bytes;                  /* Bytes written */
+  unsigned char *ptr;                   /* Pointer into buffer */
+
+
+ /*
+  * Range check...
+  */
+
+  if (!buf)
+    return (-1);
+
+ /*
+  * Return 0 if there is nothing to write...
+  */
+
+  if (buf->current == buf->buffer)
+    return (0);
+
+ /*
+  * Loop until we have written everything...
+  */
+
+  for (ptr = buf->buffer; ptr < buf->current; ptr += bytes)
+    if ((bytes = write(buf->fd, ptr, buf->current - ptr)) < 0)
+      return (-1);
+
+ /*
+  * All done, reset pointers and return success...
+  */
+
+  buf->current = buf->buffer;
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_file_getc()' - Get a character from a file.
+ */
+
+static int                              /* O  - Character or EOF */
+mxml_file_getc(void *p,                 /* I  - Pointer to file */
+               int  *encoding)          /* IO - Encoding */
+{
+  int   ch,                             /* Character from file */
+        temp;                           /* Temporary character */
+  FILE  *fp;                            /* Pointer to file */
+
+
+ /*
+  * Read a character from the file and see if it is EOF or ASCII...
+  */
+
+  fp = (FILE *)p;
+  ch = getc(fp);
+
+  if (ch == EOF)
+    return (EOF);
+
+  switch (*encoding)
+  {
+    case ENCODE_UTF8 :
+       /*
+        * Got a UTF-8 character; convert UTF-8 to Unicode and return...
+        */
+
+        if (!(ch & 0x80))
+        {
+          if (mxml_bad_char(ch))
+          {
+            mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                       ch);
+            return (EOF);
+          }
+
+#if DEBUG > 1
+          printf("mxml_file_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+          return (ch);
+        }
+        else if (ch == 0xfe)
+        {
+         /*
+          * UTF-16 big-endian BOM?
+          */
+
+          ch = getc(fp);
+          if (ch != 0xff)
+            return (EOF);
+
+          *encoding = ENCODE_UTF16BE;
+
+          return (mxml_file_getc(p, encoding));
+        }
+        else if (ch == 0xff)
+        {
+         /*
+          * UTF-16 little-endian BOM?
+          */
+
+          ch = getc(fp);
+          if (ch != 0xfe)
+            return (EOF);
+
+          *encoding = ENCODE_UTF16LE;
+
+          return (mxml_file_getc(p, encoding));
+        }
+        else if ((ch & 0xe0) == 0xc0)
+        {
+         /*
+          * Two-byte value...
+          */
+
+          if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = ((ch & 0x1f) << 6) | (temp & 0x3f);
+
+          if (ch < 0x80)
+          {
+            mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+            return (EOF);
+          }
+        }
+        else if ((ch & 0xf0) == 0xe0)
+        {
+         /*
+          * Three-byte value...
+          */
+
+          if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = ((ch & 0x0f) << 6) | (temp & 0x3f);
+
+          if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = (ch << 6) | (temp & 0x3f);
+
+          if (ch < 0x800)
+          {
+            mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+            return (EOF);
+          }
+
+         /*
+          * Ignore (strip) Byte Order Mark (BOM)...
+          */
+
+          if (ch == 0xfeff)
+            return (mxml_file_getc(p, encoding));
+        }
+        else if ((ch & 0xf8) == 0xf0)
+        {
+         /*
+          * Four-byte value...
+          */
+
+          if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = ((ch & 0x07) << 6) | (temp & 0x3f);
+
+          if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = (ch << 6) | (temp & 0x3f);
+
+          if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+            return (EOF);
+
+          ch = (ch << 6) | (temp & 0x3f);
+
+          if (ch < 0x10000)
+          {
+            mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+            return (EOF);
+          }
+        }
+        else
+          return (EOF);
+        break;
+
+    case ENCODE_UTF16BE :
+       /*
+        * Read UTF-16 big-endian char...
+        */
+
+        ch = (ch << 8) | getc(fp);
+
+        if (mxml_bad_char(ch))
+        {
+          mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                     ch);
+          return (EOF);
+        }
+        else if (ch >= 0xd800 && ch <= 0xdbff)
+        {
+         /*
+          * Multi-word UTF-16 char...
+          */
+
+          int lch = (getc(fp) << 8) | getc(fp);
+
+          if (lch < 0xdc00 || lch >= 0xdfff)
+            return (EOF);
+
+          ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+        }
+        break;
+
+    case ENCODE_UTF16LE :
+       /*
+        * Read UTF-16 little-endian char...
+        */
+
+        ch |= (getc(fp) << 8);
+
+        if (mxml_bad_char(ch))
+        {
+          mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                     ch);
+          return (EOF);
+        }
+        else if (ch >= 0xd800 && ch <= 0xdbff)
+        {
+         /*
+          * Multi-word UTF-16 char...
+          */
+
+          int lch = getc(fp) | (getc(fp) << 8);
+
+          if (lch < 0xdc00 || lch >= 0xdfff)
+            return (EOF);
+
+          ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+        }
+        break;
+  }
+
+#if DEBUG > 1
+  printf("mxml_file_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+  return (ch);
+}
+
+
+/*
+ * 'mxml_file_putc()' - Write a character to a file.
+ */
+
+static int                              /* O - 0 on success, -1 on failure */
+mxml_file_putc(int  ch,                 /* I - Character to write */
+               void *p)                 /* I - Pointer to file */
+{
+  return (putc(ch, (FILE *)p) == EOF ? -1 : 0);
+}
+
+
+/*
+ * 'mxml_get_entity()' - Get the character corresponding to an entity...
+ */
+
+static int                              /* O  - Character value or EOF on error */
+mxml_get_entity(mxml_node_t *parent,    /* I  - Parent node */
+                void        *p,         /* I  - Pointer to source */
+                int         *encoding,  /* IO - Character encoding */
+                int         (*getc_cb)(void *, int *))
+                                        /* I  - Get character function */
+{
+  int   ch;                             /* Current character */
+  char  entity[64],                     /* Entity string */
+        *entptr;                        /* Pointer into entity */
+
+
+  entptr = entity;
+
+  while ((ch = (*getc_cb)(p, encoding)) != EOF)
+    if (ch > 126 || (!isalnum(ch) && ch != '#'))
+      break;
+    else if (entptr < (entity + sizeof(entity) - 1))
+      *entptr++ = ch;
+    else
+    {
+      mxml_error("Entity name too long under parent <%s>!",
+                 parent ? parent->value.element.name : "null");
+      break;
+    }
+
+  *entptr = '\0';
+
+  if (ch != ';')
+  {
+    mxml_error("Character entity \"%s\" not terminated under parent <%s>!",
+               entity, parent ? parent->value.element.name : "null");
+    return (EOF);
+  }
+
+  if (entity[0] == '#')
+  {
+    if (entity[1] == 'x')
+      ch = strtol(entity + 2, NULL, 16);
+    else
+      ch = strtol(entity + 1, NULL, 10);
+  }
+  else if ((ch = mxmlEntityGetValue(entity)) < 0)
+    mxml_error("Entity name \"%s;\" not supported under parent <%s>!",
+               entity, parent ? parent->value.element.name : "null");
+
+  if (mxml_bad_char(ch))
+  {
+    mxml_error("Bad control character 0x%02x under parent <%s> not allowed by XML standard!",
+               ch, parent ? parent->value.element.name : "null");
+    return (EOF);
+  }
+
+  return (ch);
+}
+
+
+/*
+ * 'mxml_load_data()' - Load data into an XML node tree.
+ */
+
+static mxml_node_t *                    /* O - First node or NULL if the file could not be read. */
+mxml_load_data(
+    mxml_node_t     *top,               /* I - Top node */
+    void            *p,                 /* I - Pointer to data */
+    mxml_load_cb_t  cb,                 /* I - Callback function or MXML_NO_CALLBACK */
+    _mxml_getc_cb_t getc_cb,            /* I - Read function */
+    mxml_sax_cb_t   sax_cb,             /* I - SAX callback or MXML_NO_CALLBACK */
+    void            *sax_data)          /* I - SAX user data */
+{
+  mxml_node_t   *node,                  /* Current node */
+                *first,                 /* First node added */
+                *parent;                /* Current parent node */
+  int           ch,                     /* Character from file */
+                whitespace;             /* Non-zero if whitespace seen */
+  char          *buffer,                /* String buffer */
+                *bufptr;                /* Pointer into buffer */
+  int           bufsize;                /* Size of buffer */
+  mxml_type_t   type;                   /* Current node type */
+  int           encoding;               /* Character encoding */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+  static const char * const types[] =   /* Type strings... */
+                {
+                  "MXML_ELEMENT",       /* XML element with attributes */
+                  "MXML_INTEGER",       /* Integer value */
+                  "MXML_OPAQUE",        /* Opaque string */
+                  "MXML_REAL",          /* Real value */
+                  "MXML_TEXT",          /* Text fragment */
+                  "MXML_CUSTOM"         /* Custom data */
+                };
+
+
+ /*
+  * Read elements and other nodes from the file...
+  */
+
+  if ((buffer = malloc(64)) == NULL)
+  {
+    mxml_error("Unable to allocate string buffer!");
+    return (NULL);
+  }
+
+  bufsize    = 64;
+  bufptr     = buffer;
+  parent     = top;
+  first      = NULL;
+  whitespace = 0;
+  encoding   = ENCODE_UTF8;
+
+  if (cb && parent)
+    type = (*cb)(parent);
+  else
+    type = MXML_TEXT;
+
+  while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+  {
+    if ((ch == '<' ||
+         (mxml_isspace(ch) && type != MXML_OPAQUE && type != MXML_CUSTOM)) &&
+        bufptr > buffer)
+    {
+     /*
+      * Add a new value node...
+      */
+
+      *bufptr = '\0';
+
+      switch (type)
+      {
+        case MXML_INTEGER :
+            node = mxmlNewInteger(parent, strtol(buffer, &bufptr, 0));
+            break;
+
+        case MXML_OPAQUE :
+            node = mxmlNewOpaque(parent, buffer);
+            break;
+
+        case MXML_REAL :
+            node = mxmlNewReal(parent, strtod(buffer, &bufptr));
+            break;
+
+        case MXML_TEXT :
+            node = mxmlNewText(parent, whitespace, buffer);
+            break;
+
+        case MXML_CUSTOM :
+            if (global->custom_load_cb)
+            {
+             /*
+              * Use the callback to fill in the custom data...
+              */
+
+              node = mxmlNewCustom(parent, NULL, NULL);
+
+              if ((*global->custom_load_cb)(node, buffer))
+              {
+                mxml_error("Bad custom value '%s' in parent <%s>!",
+                           buffer, parent ? parent->value.element.name : "null");
+                mxmlDelete(node);
+                node = NULL;
+              }
+              break;
+            }
+
+        default : /* Ignore... */
+            node = NULL;
+            break;
+      }   
+
+      if (*bufptr)
+      {
+       /*
+        * Bad integer/real number value...
+        */
+
+        mxml_error("Bad %s value '%s' in parent <%s>!",
+                   type == MXML_INTEGER ? "integer" : "real", buffer,
+                   parent ? parent->value.element.name : "null");
+        break;
+      }
+
+      bufptr     = buffer;
+      whitespace = mxml_isspace(ch) && type == MXML_TEXT;
+
+      if (!node && type != MXML_IGNORE)
+      {
+       /*
+        * Print error and return...
+        */
+
+        mxml_error("Unable to add value node of type %s to parent <%s>!",
+                   types[type], parent ? parent->value.element.name : "null");
+        goto error;
+      }
+
+      if (sax_cb)
+      {
+        (*sax_cb)(node, MXML_SAX_DATA, sax_data);
+
+        if (!mxmlRelease(node))
+          node = NULL;
+      }
+
+      if (!first && node)
+        first = node;
+    }
+    else if (mxml_isspace(ch) && type == MXML_TEXT)
+      whitespace = 1;
+
+   /*
+    * Add lone whitespace node if we have an element and existing
+    * whitespace...
+    */
+
+    if (ch == '<' && whitespace && type == MXML_TEXT)
+    {
+      if (parent)
+      {
+        node = mxmlNewText(parent, whitespace, "");
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_DATA, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+        if (!first && node)
+          first = node;
+      }
+
+      whitespace = 0;
+    }
+
+    if (ch == '<')
+    {
+     /*
+      * Start of open/close tag...
+      */
+
+      bufptr = buffer;
+
+      while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+        if (mxml_isspace(ch) || ch == '>' || (ch == '/' && bufptr > buffer))
+          break;
+        else if (ch == '<')
+        {
+          mxml_error("Bare < in element!");
+          goto error;
+        }
+        else if (ch == '&')
+        {
+          if ((ch = mxml_get_entity(parent, p, &encoding, getc_cb)) == EOF)
+            goto error;
+
+          if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+            goto error;
+        }
+        else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+          goto error;
+        else if (((bufptr - buffer) == 1 && buffer[0] == '?') ||
+                 ((bufptr - buffer) == 3 && !strncmp(buffer, "!--", 3)) ||
+                 ((bufptr - buffer) == 8 && !strncmp(buffer, "![CDATA[", 8)))
+          break;
+
+      *bufptr = '\0';
+
+      if (!strcmp(buffer, "!--"))
+      {
+       /*
+        * Gather rest of comment...
+        */
+
+        while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+        {
+          if (ch == '>' && bufptr > (buffer + 4) &&
+              bufptr[-3] != '-' && bufptr[-2] == '-' && bufptr[-1] == '-')
+            break;
+          else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+            goto error;
+        }
+
+       /*
+        * Error out if we didn't get the whole comment...
+        */
+
+        if (ch != '>')
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Early EOF in comment node!");
+          goto error;
+        }
+
+
+       /*
+        * Otherwise add this as an element under the current parent...
+        */
+
+        *bufptr = '\0';
+
+        if (!parent && first)
+        {
+         /*
+          * There can only be one root element!
+          */
+
+          mxml_error("<%s> cannot be a second root node after <%s>", 
+                     buffer, first->value.element.name);
+          goto error;                
+        }
+
+        if ((node = mxmlNewElement(parent, buffer)) == NULL)
+        {
+         /*
+          * Just print error for now...
+          */
+
+          mxml_error("Unable to add comment node to parent <%s>!",
+                     parent ? parent->value.element.name : "null");
+          break;
+        }
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_COMMENT, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+        if (node && !first)
+          first = node;
+      }
+      else if (!strcmp(buffer, "![CDATA["))
+      {
+       /*
+        * Gather CDATA section...
+        */
+
+        while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+        {
+          if (ch == '>' && !strncmp(bufptr - 2, "]]", 2))
+            break;
+          else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+            goto error;
+        }
+
+       /*
+        * Error out if we didn't get the whole comment...
+        */
+
+        if (ch != '>')
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Early EOF in CDATA node!");
+          goto error;
+        }
+
+
+       /*
+        * Otherwise add this as an element under the current parent...
+        */
+
+        *bufptr = '\0';
+
+        if (!parent && first)
+        {
+         /*
+          * There can only be one root element!
+          */
+
+          mxml_error("<%s> cannot be a second root node after <%s>", 
+                     buffer, first->value.element.name);
+          goto error;                
+        }
+
+        if ((node = mxmlNewElement(parent, buffer)) == NULL)
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Unable to add CDATA node to parent <%s>!",
+                     parent ? parent->value.element.name : "null");
+          goto error;
+        }
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_CDATA, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+        if (node && !first)
+          first = node;
+      }
+      else if (buffer[0] == '?')
+      {
+       /*
+        * Gather rest of processing instruction...
+        */
+
+        while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+        {
+          if (ch == '>' && bufptr > buffer && bufptr[-1] == '?')
+            break;
+          else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+            goto error;
+        }
+
+       /*
+        * Error out if we didn't get the whole processing instruction...
+        */
+
+        if (ch != '>')
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Early EOF in processing instruction node!");
+          goto error;
+        }
+
+       /*
+        * Otherwise add this as an element under the current parent...
+        */
+
+        *bufptr = '\0';
+
+        if (!parent && first)
+        {
+         /*
+          * There can only be one root element!
+          */
+
+          mxml_error("<%s> cannot be a second root node after <%s>", 
+                     buffer, first->value.element.name);
+          goto error;                
+        }
+
+        if ((node = mxmlNewElement(parent, buffer)) == NULL)
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Unable to add processing instruction node to parent <%s>!",
+                     parent ? parent->value.element.name : "null");
+          goto error;
+        }
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_DIRECTIVE, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+        if (node)
+        {
+          if (!first)
+            first = node;
+
+          if (!parent)
+          {
+            parent = node;
+
+            if (cb)
+              type = (*cb)(parent);
+          }
+        }
+      }
+      else if (buffer[0] == '!')
+      {
+       /*
+        * Gather rest of declaration...
+        */
+
+        do
+        {
+          if (ch == '>')
+            break;
+          else
+          {
+            if (ch == '&')
+              if ((ch = mxml_get_entity(parent, p, &encoding, getc_cb)) == EOF)
+                goto error;
+
+            if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+              goto error;
+          }
+        }
+        while ((ch = (*getc_cb)(p, &encoding)) != EOF);
+
+       /*
+        * Error out if we didn't get the whole declaration...
+        */
+
+        if (ch != '>')
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Early EOF in declaration node!");
+          goto error;
+        }
+
+       /*
+        * Otherwise add this as an element under the current parent...
+        */
+
+        *bufptr = '\0';
+
+        if (!parent && first)
+        {
+         /*
+          * There can only be one root element!
+          */
+
+          mxml_error("<%s> cannot be a second root node after <%s>", 
+                     buffer, first->value.element.name);
+          goto error;                
+        }
+
+        if ((node = mxmlNewElement(parent, buffer)) == NULL)
+        {
+         /*
+          * Print error and return...
+          */
+
+          mxml_error("Unable to add declaration node to parent <%s>!",
+                     parent ? parent->value.element.name : "null");
+          goto error;
+        }
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_DIRECTIVE, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+        if (node)
+        {
+          if (!first)
+            first = node;
+
+          if (!parent)
+          {
+            parent = node;
+
+            if (cb)
+              type = (*cb)(parent);
+          }
+        }
+      }
+      else if (buffer[0] == '/')
+      {
+       /*
+        * Handle close tag...
+        */
+
+        if (!parent || strcmp(buffer + 1, parent->value.element.name))
+        {
+         /*
+          * Close tag doesn't match tree; print an error for now...
+          */
+
+          mxml_error("Mismatched close tag <%s> under parent <%s>!",
+                     buffer, parent ? parent->value.element.name : "(null)");
+          goto error;
+        }
+
+       /*
+        * Keep reading until we see >...
+        */
+
+        while (ch != '>' && ch != EOF)
+          ch = (*getc_cb)(p, &encoding);
+
+        node   = parent;
+        parent = parent->parent;
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_ELEMENT_CLOSE, sax_data);
+
+          if (!mxmlRelease(node) && first == node)
+            first = NULL;
+        }
+
+       /*
+        * Ascend into the parent and set the value type as needed...
+        */
+
+        if (cb && parent)
+          type = (*cb)(parent);
+      }
+      else
+      {
+       /*
+        * Handle open tag...
+        */
+
+        if (!parent && first)
+        {
+         /*
+          * There can only be one root element!
+          */
+
+          mxml_error("<%s> cannot be a second root node after <%s>", 
+                     buffer, first->value.element.name);
+          goto error;                
+        }
+
+        if ((node = mxmlNewElement(parent, buffer)) == NULL)
+        {
+         /*
+          * Just print error for now...
+          */
+
+          mxml_error("Unable to add element node to parent <%s>!",
+                     parent ? parent->value.element.name : "null");
+          goto error;
+        }
+
+        if (mxml_isspace(ch))
+        {
+          if ((ch = mxml_parse_element(node, p, &encoding, getc_cb)) == EOF)
+            goto error;
+        }
+        else if (ch == '/')
+        {
+          if ((ch = (*getc_cb)(p, &encoding)) != '>')
+          {
+            mxml_error("Expected > but got '%c' instead for element <%s/>!",
+                       ch, buffer);
+            mxmlDelete(node);
+            goto error;
+          }
+
+          ch = '/';
+        }
+
+        if (sax_cb)
+          (*sax_cb)(node, MXML_SAX_ELEMENT_OPEN, sax_data);
+
+        if (!first)
+          first = node;
+
+        if (ch == EOF)
+          break;
+
+        if (ch != '/')
+        {
+         /*
+          * Descend into this node, setting the value type as needed...
+          */
+
+          parent = node;
+
+          if (cb && parent)
+            type = (*cb)(parent);
+        }
+        else if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_ELEMENT_CLOSE, sax_data);
+
+          if (!mxmlRelease(node) && first == node)
+            first = NULL;
+        }
+      }
+
+      bufptr  = buffer;
+    }
+    else if (ch == '&')
+    {
+     /*
+      * Add character entity to current buffer...
+      */
+
+      if ((ch = mxml_get_entity(parent, p, &encoding, getc_cb)) == EOF)
+        goto error;
+
+      if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+        goto error;
+    }
+    else if (type == MXML_OPAQUE || type == MXML_CUSTOM || !mxml_isspace(ch))
+    {
+     /*
+      * Add character to current buffer...
+      */
+
+      if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+        goto error;
+    }
+  }
+
+ /*
+  * Free the string buffer - we don't need it anymore...
+  */
+
+  free(buffer);
+
+ /*
+  * Find the top element and return it...
+  */
+
+  if (parent)
+  {
+    node = parent;
+
+    while (parent->parent != top && parent->parent)
+      parent = parent->parent;
+
+    if (node != parent)
+    {
+      mxml_error("Missing close tag </%s> under parent <%s>!",
+                 node->value.element.name,
+                 node->parent ? node->parent->value.element.name : "(null)");
+
+      mxmlDelete(first);
+
+      return (NULL);
+    }
+  }
+
+  if (parent)
+    return (parent);
+  else
+    return (first);
+
+ /*
+  * Common error return...
+  */
+
+error:
+
+  mxmlDelete(first);
+
+  free(buffer);
+
+  return (NULL);
+}
+
+
+/*
+ * 'mxml_parse_element()' - Parse an element for any attributes...
+ */
+
+static int                              /* O  - Terminating character */
+mxml_parse_element(
+    mxml_node_t     *node,              /* I  - Element node */
+    void            *p,                 /* I  - Data to read from */
+    int             *encoding,          /* IO - Encoding */
+    _mxml_getc_cb_t getc_cb)            /* I  - Data callback */
+{
+  int   ch,                             /* Current character in file */
+        quote;                          /* Quoting character */
+  char  *name,                          /* Attribute name */
+        *value,                         /* Attribute value */
+        *ptr;                           /* Pointer into name/value */
+  int   namesize,                       /* Size of name string */
+        valsize;                        /* Size of value string */
+
+
+ /*
+  * Initialize the name and value buffers...
+  */
+
+  if ((name = malloc(64)) == NULL)
+  {
+    mxml_error("Unable to allocate memory for name!");
+    return (EOF);
+  }
+
+  namesize = 64;
+
+  if ((value = malloc(64)) == NULL)
+  {
+    free(name);
+    mxml_error("Unable to allocate memory for value!");
+    return (EOF);
+  }
+
+  valsize = 64;
+
+ /*
+  * Loop until we hit a >, /, ?, or EOF...
+  */
+
+  while ((ch = (*getc_cb)(p, encoding)) != EOF)
+  {
+#if DEBUG > 1
+    fprintf(stderr, "parse_element: ch='%c'\n", ch);
+#endif /* DEBUG > 1 */
+
+   /*
+    * Skip leading whitespace...
+    */
+
+    if (mxml_isspace(ch))
+      continue;
+
+   /*
+    * Stop at /, ?, or >...
+    */
+
+    if (ch == '/' || ch == '?')
+    {
+     /*
+      * Grab the > character and print an error if it isn't there...
+      */
+
+      quote = (*getc_cb)(p, encoding);
+
+      if (quote != '>')
+      {
+        mxml_error("Expected '>' after '%c' for element %s, but got '%c'!",
+                   ch, node->value.element.name, quote);
+        goto error;
+      }
+
+      break;
+    }
+    else if (ch == '<')
+    {
+      mxml_error("Bare < in element %s!", node->value.element.name);
+      goto error;
+    }
+    else if (ch == '>')
+      break;
+
+   /*
+    * Read the attribute name...
+    */
+
+    name[0] = ch;
+    ptr     = name + 1;
+
+    if (ch == '\"' || ch == '\'')
+    {
+     /*
+      * Name is in quotes, so get a quoted string...
+      */
+
+      quote = ch;
+
+      while ((ch = (*getc_cb)(p, encoding)) != EOF)
+      {
+        if (ch == '&')
+          if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+            goto error;
+
+        if (mxml_add_char(ch, &ptr, &name, &namesize))
+          goto error;
+
+        if (ch == quote)
+          break;
+      }
+    }
+    else
+    {
+     /*
+      * Grab an normal, non-quoted name...
+      */
+
+      while ((ch = (*getc_cb)(p, encoding)) != EOF)
+        if (mxml_isspace(ch) || ch == '=' || ch == '/' || ch == '>' ||
+            ch == '?')
+          break;
+        else
+        {
+          if (ch == '&')
+            if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+              goto error;
+
+          if (mxml_add_char(ch, &ptr, &name, &namesize))
+            goto error;
+        }
+    }
+
+    *ptr = '\0';
+
+    if (mxmlElementGetAttr(node, name))
+      goto error;
+
+    while (ch != EOF && mxml_isspace(ch))
+      ch = (*getc_cb)(p, encoding);
+
+    if (ch == '=')
+    {
+     /*
+      * Read the attribute value...
+      */
+
+      while ((ch = (*getc_cb)(p, encoding)) != EOF && mxml_isspace(ch));
+
+      if (ch == EOF)
+      {
+        mxml_error("Missing value for attribute '%s' in element %s!",
+                   name, node->value.element.name);
+        goto error;
+      }
+
+      if (ch == '\'' || ch == '\"')
+      {
+       /*
+        * Read quoted value...
+        */
+
+        quote = ch;
+        ptr   = value;
+
+        while ((ch = (*getc_cb)(p, encoding)) != EOF)
+          if (ch == quote)
+            break;
+          else
+          {
+            if (ch == '&')
+              if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+                goto error;
+              
+            if (mxml_add_char(ch, &ptr, &value, &valsize))
+              goto error;
+          }
+
+        *ptr = '\0';
+      }
+      else
+      {
+       /*
+        * Read unquoted value...
+        */
+
+        value[0] = ch;
+        ptr      = value + 1;
+
+        while ((ch = (*getc_cb)(p, encoding)) != EOF)
+          if (mxml_isspace(ch) || ch == '=' || ch == '/' || ch == '>')
+            break;
+          else
+          {
+            if (ch == '&')
+              if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+                goto error;
+              
+            if (mxml_add_char(ch, &ptr, &value, &valsize))
+              goto error;
+          }
+
+        *ptr = '\0';
+      }
+
+     /*
+      * Set the attribute with the given string value...
+      */
+
+      mxmlElementSetAttr(node, name, value);
+    }
+    else
+    {
+      mxml_error("Missing value for attribute '%s' in element %s!",
+                 name, node->value.element.name);
+      goto error;
+    }
+
+   /*
+    * Check the end character...
+    */
+
+    if (ch == '/' || ch == '?')
+    {
+     /*
+      * Grab the > character and print an error if it isn't there...
+      */
+
+      quote = (*getc_cb)(p, encoding);
+
+      if (quote != '>')
+      {
+        mxml_error("Expected '>' after '%c' for element %s, but got '%c'!",
+                   ch, node->value.element.name, quote);
+        ch = EOF;
+      }
+
+      break;
+    }
+    else if (ch == '>')
+      break;
+  }
+
+ /*
+  * Free the name and value buffers and return...
+  */
+
+  free(name);
+  free(value);
+
+  return (ch);
+
+ /*
+  * Common error return point...
+  */
+
+error:
+
+  free(name);
+  free(value);
+
+  return (EOF);
+}
+
+
+/*
+ * 'mxml_string_getc()' - Get a character from a string.
+ */
+
+static int                              /* O  - Character or EOF */
+mxml_string_getc(void *p,               /* I  - Pointer to file */
+                 int  *encoding)        /* IO - Encoding */
+{
+  int           ch;                     /* Character */
+  const char    **s;                    /* Pointer to string pointer */
+
+
+  s = (const char **)p;
+
+  if ((ch = (*s)[0] & 255) != 0 || *encoding == ENCODE_UTF16LE)
+  {
+   /*
+    * Got character; convert UTF-8 to integer and return...
+    */
+
+    (*s)++;
+
+    switch (*encoding)
+    {
+      case ENCODE_UTF8 :
+          if (!(ch & 0x80))
+          {
+#if DEBUG > 1
+            printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+            if (mxml_bad_char(ch))
+            {
+              mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                         ch);
+              return (EOF);
+            }
+
+            return (ch);
+          }
+          else if (ch == 0xfe)
+          {
+           /*
+            * UTF-16 big-endian BOM?
+            */
+
+            if (((*s)[0] & 255) != 0xff)
+              return (EOF);
+
+            *encoding = ENCODE_UTF16BE;
+            (*s)++;
+
+            return (mxml_string_getc(p, encoding));
+          }
+          else if (ch == 0xff)
+          {
+           /*
+            * UTF-16 little-endian BOM?
+            */
+
+            if (((*s)[0] & 255) != 0xfe)
+              return (EOF);
+
+            *encoding = ENCODE_UTF16LE;
+            (*s)++;
+
+            return (mxml_string_getc(p, encoding));
+          }
+          else if ((ch & 0xe0) == 0xc0)
+          {
+           /*
+            * Two-byte value...
+            */
+
+            if (((*s)[0] & 0xc0) != 0x80)
+              return (EOF);
+
+            ch = ((ch & 0x1f) << 6) | ((*s)[0] & 0x3f);
+
+            (*s)++;
+
+            if (ch < 0x80)
+            {
+              mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+              return (EOF);
+            }
+
+#if DEBUG > 1
+            printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+            return (ch);
+          }
+          else if ((ch & 0xf0) == 0xe0)
+          {
+           /*
+            * Three-byte value...
+            */
+
+            if (((*s)[0] & 0xc0) != 0x80 ||
+                ((*s)[1] & 0xc0) != 0x80)
+              return (EOF);
+
+            ch = ((((ch & 0x0f) << 6) | ((*s)[0] & 0x3f)) << 6) | ((*s)[1] & 0x3f);
+
+            (*s) += 2;
+
+            if (ch < 0x800)
+            {
+              mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+              return (EOF);
+            }
+
+           /*
+            * Ignore (strip) Byte Order Mark (BOM)...
+            */
+
+            if (ch == 0xfeff)
+              return (mxml_string_getc(p, encoding));
+
+#if DEBUG > 1
+            printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+            return (ch);
+          }
+          else if ((ch & 0xf8) == 0xf0)
+          {
+           /*
+            * Four-byte value...
+            */
+
+            if (((*s)[0] & 0xc0) != 0x80 ||
+                ((*s)[1] & 0xc0) != 0x80 ||
+                ((*s)[2] & 0xc0) != 0x80)
+              return (EOF);
+
+            ch = ((((((ch & 0x07) << 6) | ((*s)[0] & 0x3f)) << 6) |
+                   ((*s)[1] & 0x3f)) << 6) | ((*s)[2] & 0x3f);
+
+            (*s) += 3;
+
+            if (ch < 0x10000)
+            {
+              mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+              return (EOF);
+            }
+
+#if DEBUG > 1
+            printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+            return (ch);
+          }
+          else
+            return (EOF);
+
+      case ENCODE_UTF16BE :
+         /*
+          * Read UTF-16 big-endian char...
+          */
+
+          ch = (ch << 8) | ((*s)[0] & 255);
+          (*s) ++;
+
+          if (mxml_bad_char(ch))
+          {
+            mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                       ch);
+            return (EOF);
+          }
+          else if (ch >= 0xd800 && ch <= 0xdbff)
+          {
+           /*
+            * Multi-word UTF-16 char...
+            */
+
+            int lch;                    /* Lower word */
+
+
+            if (!(*s)[0])
+              return (EOF);
+
+            lch = (((*s)[0] & 255) << 8) | ((*s)[1] & 255);
+            (*s) += 2;
+
+            if (lch < 0xdc00 || lch >= 0xdfff)
+              return (EOF);
+
+            ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+          }
+
+#if DEBUG > 1
+          printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+          return (ch);
+
+      case ENCODE_UTF16LE :
+         /*
+          * Read UTF-16 little-endian char...
+          */
+
+          ch = ch | (((*s)[0] & 255) << 8);
+
+          if (!ch)
+          {
+            (*s) --;
+            return (EOF);
+          }
+
+          (*s) ++;
+
+          if (mxml_bad_char(ch))
+          {
+            mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+                       ch);
+            return (EOF);
+          }
+          else if (ch >= 0xd800 && ch <= 0xdbff)
+          {
+           /*
+            * Multi-word UTF-16 char...
+            */
+
+            int lch;                    /* Lower word */
+
+
+            if (!(*s)[1])
+              return (EOF);
+
+            lch = (((*s)[1] & 255) << 8) | ((*s)[0] & 255);
+            (*s) += 2;
+
+            if (lch < 0xdc00 || lch >= 0xdfff)
+              return (EOF);
+
+            ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+          }
+
+#if DEBUG > 1
+          printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+          return (ch);
+    }
+  }
+
+  return (EOF);
+}
+
+
+/*
+ * 'mxml_string_putc()' - Write a character to a string.
+ */
+
+static int                              /* O - 0 on success, -1 on failure */
+mxml_string_putc(int  ch,               /* I - Character to write */
+                 void *p)               /* I - Pointer to string pointers */
+{
+  char  **pp;                           /* Pointer to string pointers */
+
+
+  pp = (char **)p;
+
+  if (pp[0] < pp[1])
+    pp[0][0] = ch;
+
+  pp[0] ++;
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_write_name()' - Write a name string.
+ */
+
+static int                              /* O - 0 on success, -1 on failure */
+mxml_write_name(const char *s,          /* I - Name to write */
+                void       *p,          /* I - Write pointer */
+                int        (*putc_cb)(int, void *))
+                                        /* I - Write callback */
+{
+  char          quote;                  /* Quote character */
+  const char    *name;                  /* Entity name */
+
+
+  if (*s == '\"' || *s == '\'')
+  {
+   /*
+    * Write a quoted name string...
+    */
+
+    if ((*putc_cb)(*s, p) < 0)
+      return (-1);
+
+    quote = *s++;
+
+    while (*s && *s != quote)
+    {
+      if ((name = mxmlEntityGetName(*s)) != NULL)
+      {
+        if ((*putc_cb)('&', p) < 0)
+          return (-1);
+
+        while (*name)
+        {
+          if ((*putc_cb)(*name, p) < 0)
+            return (-1);
+
+          name ++;
+        }
+
+        if ((*putc_cb)(';', p) < 0)
+          return (-1);
+      }
+      else if ((*putc_cb)(*s, p) < 0)
+        return (-1);
+
+      s ++;
+    }
+
+   /*
+    * Write the end quote...
+    */
+
+    if ((*putc_cb)(quote, p) < 0)
+      return (-1);
+  }
+  else
+  {
+   /*
+    * Write a non-quoted name string...
+    */
+
+    while (*s)
+    {
+      if ((*putc_cb)(*s, p) < 0)
+        return (-1);
+
+      s ++;
+    }
+  }
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_write_node()' - Save an XML node to a file.
+ */
+
+static int                              /* O - Column or -1 on error */
+mxml_write_node(mxml_node_t     *node,  /* I - Node to write */
+                void            *p,     /* I - File to write to */
+                mxml_save_cb_t  cb,     /* I - Whitespace callback */
+                int             col,    /* I - Current column */
+                _mxml_putc_cb_t putc_cb,/* I - Output callback */
+                _mxml_global_t  *global)/* I - Global data */
+{
+  int           i,                      /* Looping var */
+                width;                  /* Width of attr + value */
+  mxml_attr_t   *attr;                  /* Current attribute */
+  char          s[255];                 /* Temporary string */
+
+
+ /*
+  * Print the node value...
+  */
+
+  switch (node->type)
+  {
+    case MXML_ELEMENT :
+        col = mxml_write_ws(node, p, cb, MXML_WS_BEFORE_OPEN, col, putc_cb);
+
+        if ((*putc_cb)('<', p) < 0)
+          return (-1);
+        if (node->value.element.name[0] == '?' ||
+            !strncmp(node->value.element.name, "!--", 3) ||
+            !strncmp(node->value.element.name, "![CDATA[", 8))
+        {
+         /*
+          * Comments, CDATA, and processing instructions do not
+          * use character entities.
+          */
+
+          const char    *ptr;           /* Pointer into name */
+
+
+          for (ptr = node->value.element.name; *ptr; ptr ++)
+            if ((*putc_cb)(*ptr, p) < 0)
+              return (-1);
+        }
+        else if (mxml_write_name(node->value.element.name, p, putc_cb) < 0)
+          return (-1);
+
+        col += strlen(node->value.element.name) + 1;
+
+        for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+             i > 0;
+             i --, attr ++)
+        {
+          width = strlen(attr->name);
+
+          if (attr->value)
+            width += strlen(attr->value) + 3;
+
+          if (global->wrap > 0 && (col + width) > global->wrap)
+          {
+            if ((*putc_cb)('\n', p) < 0)
+              return (-1);
+
+            col = 0;
+          }
+          else
+          {
+            if ((*putc_cb)(' ', p) < 0)
+              return (-1);
+
+            col ++;
+          }
+
+          if (mxml_write_name(attr->name, p, putc_cb) < 0)
+            return (-1);
+
+          if (attr->value)
+          {
+            if ((*putc_cb)('=', p) < 0)
+              return (-1);
+            if ((*putc_cb)('\"', p) < 0)
+              return (-1);
+            if (mxml_write_string(attr->value, p, putc_cb) < 0)
+              return (-1);
+            if ((*putc_cb)('\"', p) < 0)
+              return (-1);
+          }
+
+          col += width;
+        }
+
+        if (node->child)
+        {
+         /*
+          * Write children...
+          */
+
+          mxml_node_t *child;           /* Current child */
+
+
+          if ((*putc_cb)('>', p) < 0)
+            return (-1);
+          else
+            col ++;
+
+          col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb);
+
+          for (child = node->child; child; child = child->next)
+          {
+            if ((col = mxml_write_node(child, p, cb, col, putc_cb, global)) < 0)
+              return (-1);
+          }
+
+         /*
+          * The ? and ! elements are special-cases and have no end tags...
+          */
+
+          if (node->value.element.name[0] != '!' &&
+              node->value.element.name[0] != '?')
+          {
+            col = mxml_write_ws(node, p, cb, MXML_WS_BEFORE_CLOSE, col, putc_cb);
+
+            if ((*putc_cb)('<', p) < 0)
+              return (-1);
+            if ((*putc_cb)('/', p) < 0)
+              return (-1);
+            if (mxml_write_string(node->value.element.name, p, putc_cb) < 0)
+              return (-1);
+            if ((*putc_cb)('>', p) < 0)
+              return (-1);
+
+            col += strlen(node->value.element.name) + 3;
+
+            col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_CLOSE, col, putc_cb);
+          }
+        }
+        else if (node->value.element.name[0] == '!' ||
+                 node->value.element.name[0] == '?')
+        {
+         /*
+          * The ? and ! elements are special-cases...
+          */
+
+          if ((*putc_cb)('>', p) < 0)
+            return (-1);
+          else
+            col ++;
+
+          col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb);
+        }
+        else
+        {
+          if ((*putc_cb)(' ', p) < 0)
+            return (-1);
+          if ((*putc_cb)('/', p) < 0)
+            return (-1);
+          if ((*putc_cb)('>', p) < 0)
+            return (-1);
+
+          col += 3;
+
+          col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb);
+        }
+        break;
+
+    case MXML_INTEGER :
+        if (node->prev)
+        {
+          if (global->wrap > 0 && col > global->wrap)
+          {
+            if ((*putc_cb)('\n', p) < 0)
+              return (-1);
+
+            col = 0;
+          }
+          else if ((*putc_cb)(' ', p) < 0)
+            return (-1);
+          else
+            col ++;
+        }
+
+        sprintf(s, "%d", node->value.integer);
+        if (mxml_write_string(s, p, putc_cb) < 0)
+          return (-1);
+
+        col += strlen(s);
+        break;
+
+    case MXML_OPAQUE :
+        if (mxml_write_string(node->value.opaque, p, putc_cb) < 0)
+          return (-1);
+
+        col += strlen(node->value.opaque);
+        break;
+
+    case MXML_REAL :
+        if (node->prev)
+        {
+          if (global->wrap > 0 && col > global->wrap)
+          {
+            if ((*putc_cb)('\n', p) < 0)
+              return (-1);
+
+            col = 0;
+          }
+          else if ((*putc_cb)(' ', p) < 0)
+            return (-1);
+          else
+            col ++;
+        }
+
+        sprintf(s, "%f", node->value.real);
+        if (mxml_write_string(s, p, putc_cb) < 0)
+          return (-1);
+
+        col += strlen(s);
+        break;
+
+    case MXML_TEXT :
+        if (node->value.text.whitespace && col > 0)
+        {
+          if (global->wrap > 0 && col > global->wrap)
+          {
+            if ((*putc_cb)('\n', p) < 0)
+              return (-1);
+
+            col = 0;
+          }
+          else if ((*putc_cb)(' ', p) < 0)
+            return (-1);
+          else
+            col ++;
+        }
+
+        if (mxml_write_string(node->value.text.string, p, putc_cb) < 0)
+          return (-1);
+
+        col += strlen(node->value.text.string);
+        break;
+
+    case MXML_CUSTOM :
+        if (global->custom_save_cb)
+        {
+          char  *data;          /* Custom data string */
+          const char    *newline;       /* Last newline in string */
+
+
+          if ((data = (*global->custom_save_cb)(node)) == NULL)
+            return (-1);
+
+          if (mxml_write_string(data, p, putc_cb) < 0)
+            return (-1);
+
+          if ((newline = strrchr(data, '\n')) == NULL)
+            col += strlen(data);
+          else
+            col = strlen(newline);
+
+          free(data);
+          break;
+        }
+
+    default : /* Should never happen */
+        return (-1);
+  }
+
+  return (col);
+}
+
+
+/*
+ * 'mxml_write_string()' - Write a string, escaping & and < as needed.
+ */
+
+static int                              /* O - 0 on success, -1 on failure */
+mxml_write_string(
+    const char      *s,                 /* I - String to write */
+    void            *p,                 /* I - Write pointer */
+    _mxml_putc_cb_t putc_cb)            /* I - Write callback */
+{
+  const char    *name;                  /* Entity name, if any */
+
+
+  while (*s)
+  {
+    if ((name = mxmlEntityGetName(*s)) != NULL)
+    {
+      if ((*putc_cb)('&', p) < 0)
+        return (-1);
+
+      while (*name)
+      {
+        if ((*putc_cb)(*name, p) < 0)
+          return (-1);
+        name ++;
+      }
+
+      if ((*putc_cb)(';', p) < 0)
+        return (-1);
+    }
+    else if ((*putc_cb)(*s, p) < 0)
+      return (-1);
+
+    s ++;
+  }
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_write_ws()' - Do whitespace callback...
+ */
+
+static int                              /* O - New column */
+mxml_write_ws(mxml_node_t     *node,    /* I - Current node */
+              void            *p,       /* I - Write pointer */
+              mxml_save_cb_t  cb,       /* I - Callback function */
+              int             ws,       /* I - Where value */
+              int             col,      /* I - Current column */
+              _mxml_putc_cb_t putc_cb)  /* I - Write callback */
+{
+  const char    *s;                     /* Whitespace string */
+
+
+  if (cb && (s = (*cb)(node, ws)) != NULL)
+  {
+    while (*s)
+    {
+      if ((*putc_cb)(*s, p) < 0)
+        return (-1);
+      else if (*s == '\n')
+        col = 0;
+      else if (*s == '\t')
+      {
+        col += MXML_TAB;
+        col = col - (col % MXML_TAB);
+      }
+      else
+        col ++;
+
+      s ++;
+    }
+  }
+
+  return (col);
+}
+
+
+/*
+ * End of "$Id: mxml-file.c 438 2011-03-24 05:47:51Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-get.c b/pathologist/src/minixml/mxml-get.c
new file mode 100644
index 0000000..a5356d5
--- /dev/null
+++ b/pathologist/src/minixml/mxml-get.c
@@ -0,0 +1,471 @@
+/*
+ * "$Id: mxml-get.c 427 2011-01-03 02:03:29Z mike $"
+ *
+ * Node get functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlGetCDATA()       - Get the value for a CDATA node.
+ *   mxmlGetCustom()      - Get the value for a custom node.
+ *   mxmlGetElement()     - Get the name for an element node.
+ *   mxmlGetFirstChild()  - Get the first child of an element node.
+ *   mxmlGetInteger()     - Get the integer value from the specified node or its
+ *                          first child.
+ *   mxmlGetLastChild()   - Get the last child of an element node.
+ *   mxmlGetNextSibling() - Get the next node for the current parent.
+ *   mxmlGetOpaque()      - Get an opaque string value for a node or its first
+ *                          child.
+ *   mxmlGetParent()      - Get the parent node.
+ *   mxmlGetPrevSibling() - Get the previous node for the current parent.
+ *   mxmlGetReal()        - Get the real value for a node or its first child.
+ *   mxmlGetText()        - Get the text value for a node or its first child.
+ *   mxmlGetType()        - Get the node type.
+ *   mxmlGetUserData()    - Get the user data pointer for a node.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * 'mxmlGetCDATA()' - Get the value for a CDATA node.
+ *
+ * @code NULL@ is returned if the node is not a CDATA element.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const char *                            /* O - CDATA value or NULL */
+mxmlGetCDATA(mxml_node_t *node)         /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT ||
+      strncmp(node->value.element.name, "![CDATA[", 8))
+    return (NULL);
+
+ /*
+  * Return the text following the CDATA declaration...
+  */
+
+  return (node->value.element.name + 8);
+}
+
+
+/*
+ * 'mxmlGetCustom()' - Get the value for a custom node.
+ *
+ * @code NULL@ is returned if the node (or its first child) is not a custom
+ * value node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const void *                            /* O - Custom value or NULL */
+mxmlGetCustom(mxml_node_t *node)        /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_CUSTOM)
+    return (node->value.custom.data);
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+           node->child->type == MXML_CUSTOM)
+    return (node->child->value.custom.data);
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'mxmlGetElement()' - Get the name for an element node.
+ *
+ * @code NULL@ is returned if the node is not an element node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const char *                            /* O - Element name or NULL */
+mxmlGetElement(mxml_node_t *node)       /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT)
+    return (NULL);
+
+ /*
+  * Return the element name...
+  */
+
+  return (node->value.element.name);
+}
+
+
+/*
+ * 'mxmlGetFirstChild()' - Get the first child of an element node.
+ *
+ * @code NULL@ is returned if the node is not an element node or if the node
+ * has no children.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *                           /* O - First child or NULL */
+mxmlGetFirstChild(mxml_node_t *node)    /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT)
+    return (NULL);
+
+ /*
+  * Return the first child node...
+  */
+
+  return (node->child);
+}
+
+
+/*
+ * 'mxmlGetInteger()' - Get the integer value from the specified node or its
+ *                      first child.
+ *
+ * 0 is returned if the node (or its first child) is not an integer value node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+int                                     /* O - Integer value or 0 */
+mxmlGetInteger(mxml_node_t *node)       /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (0);
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_INTEGER)
+    return (node->value.integer);
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+           node->child->type == MXML_INTEGER)
+    return (node->child->value.integer);
+  else
+    return (0);
+}
+
+
+/*
+ * 'mxmlGetLastChild()' - Get the last child of an element node.
+ *
+ * @code NULL@ is returned if the node is not an element node or if the node
+ * has no children.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *                           /* O - Last child or NULL */
+mxmlGetLastChild(mxml_node_t *node)     /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT)
+    return (NULL);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->last_child);
+}
+
+
+/*
+ * 'mxmlGetNextSibling()' - Get the next node for the current parent.
+ *
+ * @code NULL@ is returned if this is the last child for the current parent.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *
+mxmlGetNextSibling(mxml_node_t *node)   /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->next);
+}
+
+
+/*
+ * 'mxmlGetOpaque()' - Get an opaque string value for a node or its first child.
+ *
+ * @code NULL@ is returned if the node (or its first child) is not an opaque
+ * value node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const char *                            /* O - Opaque string or NULL */
+mxmlGetOpaque(mxml_node_t *node)        /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_OPAQUE)
+    return (node->value.opaque);
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+           node->child->type == MXML_OPAQUE)
+    return (node->child->value.opaque);
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'mxmlGetParent()' - Get the parent node.
+ *
+ * @code NULL@ is returned for a root node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *                           /* O - Parent node or NULL */
+mxmlGetParent(mxml_node_t *node)        /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->parent);
+}
+
+
+/*
+ * 'mxmlGetPrevSibling()' - Get the previous node for the current parent.
+ *
+ * @code NULL@ is returned if this is the first child for the current parent.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *                           /* O - Previous node or NULL */
+mxmlGetPrevSibling(mxml_node_t *node)   /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->prev);
+}
+
+
+/*
+ * 'mxmlGetReal()' - Get the real value for a node or its first child.
+ *
+ * 0.0 is returned if the node (or its first child) is not a real value node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+double                                  /* O - Real value or 0.0 */
+mxmlGetReal(mxml_node_t *node)          /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (0.0);
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_REAL)
+    return (node->value.real);
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+           node->child->type == MXML_REAL)
+    return (node->child->value.real);
+  else
+    return (0.0);
+}
+
+
+/*
+ * 'mxmlGetText()' - Get the text value for a node or its first child.
+ *
+ * @code NULL@ is returned if the node (or its first child) is not a text node.
+ * The "whitespace" argument can be NULL.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const char *                            /* O - Text string or NULL */
+mxmlGetText(mxml_node_t *node,          /* I - Node to get */
+            int         *whitespace)    /* O - 1 if string is preceded by whitespace, 0 otherwise */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+  {
+    if (whitespace)
+      *whitespace = 0;
+
+    return (NULL);
+  }
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_TEXT)
+  {
+    if (whitespace)
+      *whitespace = node->value.text.whitespace;
+
+    return (node->value.text.string);
+  }
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+           node->child->type == MXML_TEXT)
+  {
+    if (whitespace)
+      *whitespace = node->child->value.text.whitespace;
+
+    return (node->child->value.text.string);
+  }
+  else
+  {
+    if (whitespace)
+      *whitespace = 0;
+
+    return (NULL);
+  }
+}
+
+
+/*
+ * 'mxmlGetType()' - Get the node type.
+ *
+ * @code MXML_IGNORE@ is returned if "node" is @code NULL@.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_type_t                             /* O - Type of node */
+mxmlGetType(mxml_node_t *node)          /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (MXML_IGNORE);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->type);
+}
+
+
+/*
+ * 'mxmlGetUserData()' - Get the user data pointer for a node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+void *                                  /* O - User data pointer */
+mxmlGetUserData(mxml_node_t *node)      /* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the user data pointer...
+  */
+
+  return (node->user_data);
+}
+
+
+/*
+ * End of "$Id: mxml-get.c 427 2011-01-03 02:03:29Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-index.c b/pathologist/src/minixml/mxml-index.c
new file mode 100644
index 0000000..b6efc66
--- /dev/null
+++ b/pathologist/src/minixml/mxml-index.c
@@ -0,0 +1,662 @@
+/*
+ * "$Id: mxml-index.c 426 2011-01-01 23:42:17Z mike $"
+ *
+ * Index support code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Sort functions...
+ */
+
+static int      index_compare(mxml_index_t *ind, mxml_node_t *first,
+                              mxml_node_t *second);
+static int      index_find(mxml_index_t *ind, const char *element,
+                           const char *value, mxml_node_t *node);
+static void     index_sort(mxml_index_t *ind, int left, int right);
+
+
+/*
+ * 'mxmlIndexDelete()' - Delete an index.
+ */
+
+void
+mxmlIndexDelete(mxml_index_t *ind)      /* I - Index to delete */
+{
+ /*
+  * Range check input..
+  */
+
+  if (!ind)
+    return;
+
+ /*
+  * Free memory...
+  */
+
+  if (ind->attr)
+    free(ind->attr);
+
+  if (ind->alloc_nodes)
+    free(ind->nodes);
+
+  free(ind);
+}
+
+
+/*
+ * 'mxmlIndexEnum()' - Return the next node in the index.
+ *
+ * Nodes are returned in the sorted order of the index.
+ */
+
+mxml_node_t *                           /* O - Next node or NULL if there is none */
+mxmlIndexEnum(mxml_index_t *ind)        /* I - Index to enumerate */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!ind)
+    return (NULL);
+
+ /*
+  * Return the next node...
+  */
+
+  if (ind->cur_node < ind->num_nodes)
+    return (ind->nodes[ind->cur_node ++]);
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'mxmlIndexFind()' - Find the next matching node.
+ *
+ * You should call mxmlIndexReset() prior to using this function for
+ * the first time with a particular set of "element" and "value"
+ * strings. Passing NULL for both "element" and "value" is equivalent
+ * to calling mxmlIndexEnum().
+ */
+
+mxml_node_t *                           /* O - Node or NULL if none found */
+mxmlIndexFind(mxml_index_t *ind,        /* I - Index to search */
+              const char   *element,    /* I - Element name to find, if any */
+              const char   *value)      /* I - Attribute value, if any */
+{
+  int           diff,                   /* Difference between names */
+                current,                /* Current entity in search */
+                first,                  /* First entity in search */
+                last;                   /* Last entity in search */
+
+
+#ifdef DEBUG
+  printf("mxmlIndexFind(ind=%p, element=\"%s\", value=\"%s\")\n",
+         ind, element ? element : "(null)", value ? value : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!ind || (!ind->attr && value))
+  {
+#ifdef DEBUG
+    puts("    returning NULL...");
+    printf("    ind->attr=\"%s\"\n", ind->attr ? ind->attr : "(null)");
+#endif /* DEBUG */
+
+    return (NULL);
+  }
+
+ /*
+  * If both element and value are NULL, just enumerate the nodes in the
+  * index...
+  */
+
+  if (!element && !value)
+    return (mxmlIndexEnum(ind));
+
+ /*
+  * If there are no nodes in the index, return NULL...
+  */
+
+  if (!ind->num_nodes)
+  {
+#ifdef DEBUG
+    puts("    returning NULL...");
+    puts("    no nodes!");
+#endif /* DEBUG */
+
+    return (NULL);
+  }
+
+ /*
+  * If cur_node == 0, then find the first matching node...
+  */
+
+  if (ind->cur_node == 0)
+  {
+   /*
+    * Find the first node using a modified binary search algorithm...
+    */
+
+    first = 0;
+    last  = ind->num_nodes - 1;
+
+#ifdef DEBUG
+    printf("    find first time, num_nodes=%d...\n", ind->num_nodes);
+#endif /* DEBUG */
+
+    while ((last - first) > 1)
+    {
+      current = (first + last) / 2;
+
+#ifdef DEBUG
+      printf("    first=%d, last=%d, current=%d\n", first, last, current);
+#endif /* DEBUG */
+
+      if ((diff = index_find(ind, element, value, ind->nodes[current])) == 0)
+      {
+       /*
+        * Found a match, move back to find the first...
+        */
+
+#ifdef DEBUG
+        puts("    match!");
+#endif /* DEBUG */
+
+        while (current > 0 &&
+               !index_find(ind, element, value, ind->nodes[current - 1]))
+          current --;
+
+#ifdef DEBUG
+        printf("    returning first match=%d\n", current);
+#endif /* DEBUG */
+
+       /*
+        * Return the first match and save the index to the next...
+        */
+
+        ind->cur_node = current + 1;
+
+        return (ind->nodes[current]);
+      }
+      else if (diff < 0)
+        last = current;
+      else
+        first = current;
+
+#ifdef DEBUG
+      printf("    diff=%d\n", diff);
+#endif /* DEBUG */
+    }
+
+   /*
+    * If we get this far, then we found exactly 0 or 1 matches...
+    */
+
+    for (current = first; current <= last; current ++)
+      if (!index_find(ind, element, value, ind->nodes[current]))
+      {
+       /*
+        * Found exactly one (or possibly two) match...
+        */
+
+#ifdef DEBUG
+        printf("    returning only match %d...\n", current);
+#endif /* DEBUG */
+
+        ind->cur_node = current + 1;
+
+        return (ind->nodes[current]);
+      }
+
+   /*
+    * No matches...
+    */
+
+    ind->cur_node = ind->num_nodes;
+
+#ifdef DEBUG
+    puts("    returning NULL...");
+#endif /* DEBUG */
+
+    return (NULL);
+  }
+  else if (ind->cur_node < ind->num_nodes &&
+           !index_find(ind, element, value, ind->nodes[ind->cur_node]))
+  {
+   /*
+    * Return the next matching node...
+    */
+
+#ifdef DEBUG
+    printf("    returning next match %d...\n", ind->cur_node);
+#endif /* DEBUG */
+
+    return (ind->nodes[ind->cur_node ++]);
+  }
+
+ /*
+  * If we get this far, then we have no matches...
+  */
+
+  ind->cur_node = ind->num_nodes;
+
+#ifdef DEBUG
+  puts("    returning NULL...");
+#endif /* DEBUG */
+
+  return (NULL);
+}
+
+
+/*
+ * 'mxmlIndexGetCount()' - Get the number of nodes in an index.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+int                                     /* I - Number of nodes in index */
+mxmlIndexGetCount(mxml_index_t *ind)    /* I - Index of nodes */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!ind)
+    return (0);
+
+ /*
+  * Return the number of nodes in the index...
+  */
+
+  return (ind->num_nodes);
+}
+
+
+/*
+ * 'mxmlIndexNew()' - Create a new index.
+ *
+ * The index will contain all nodes that contain the named element and/or
+ * attribute. If both "element" and "attr" are NULL, then the index will
+ * contain a sorted list of the elements in the node tree.  Nodes are
+ * sorted by element name and optionally by attribute value if the "attr"
+ * argument is not NULL.
+ */
+
+mxml_index_t *                          /* O - New index */
+mxmlIndexNew(mxml_node_t *node,         /* I - XML node tree */
+             const char  *element,      /* I - Element to index or NULL for all */
+             const char  *attr)         /* I - Attribute to index or NULL for none */
+{
+  mxml_index_t  *ind;                   /* New index */
+  mxml_node_t   *current,               /* Current node in index */
+                **temp;                 /* Temporary node pointer array */
+
+
+ /*
+  * Range check input...
+  */
+
+#ifdef DEBUG
+  printf("mxmlIndexNew(node=%p, element=\"%s\", attr=\"%s\")\n",
+         node, element ? element : "(null)", attr ? attr : "(null)");
+#endif /* DEBUG */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Create a new index...
+  */
+
+  if ((ind = calloc(1, sizeof(mxml_index_t))) == NULL)
+  {
+    mxml_error("Unable to allocate %d bytes for index - %s",
+               sizeof(mxml_index_t), strerror(errno));
+    return (NULL);
+  }
+
+  if (attr)
+    ind->attr = strdup(attr);
+
+  if (!element && !attr)
+    current = node;
+  else
+    current = mxmlFindElement(node, node, element, attr, NULL, MXML_DESCEND);
+
+  while (current)
+  {
+    if (ind->num_nodes >= ind->alloc_nodes)
+    {
+      if (!ind->alloc_nodes)
+        temp = malloc(64 * sizeof(mxml_node_t *));
+      else
+        temp = realloc(ind->nodes, (ind->alloc_nodes + 64) * sizeof(mxml_node_t *));
+
+      if (!temp)
+      {
+       /*
+        * Unable to allocate memory for the index, so abort...
+        */
+
+        mxml_error("Unable to allocate %d bytes for index: %s",
+                   (ind->alloc_nodes + 64) * sizeof(mxml_node_t *),
+                   strerror(errno));
+
+        mxmlIndexDelete(ind);
+        return (NULL);
+      }
+
+      ind->nodes       = temp;
+      ind->alloc_nodes += 64;
+    }
+
+    ind->nodes[ind->num_nodes ++] = current;
+
+    current = mxmlFindElement(current, node, element, attr, NULL, MXML_DESCEND);
+  }
+
+ /*
+  * Sort nodes based upon the search criteria...
+  */
+
+#ifdef DEBUG
+  {
+    int i;                              /* Looping var */
+
+
+    printf("%d node(s) in index.\n\n", ind->num_nodes);
+
+    if (attr)
+    {
+      printf("Node      Address   Element         %s\n", attr);
+      puts("--------  --------  --------------  ------------------------------");
+
+      for (i = 0; i < ind->num_nodes; i ++)
+        printf("%8d  %-8p  %-14.14s  %s\n", i, ind->nodes[i],
+               ind->nodes[i]->value.element.name,
+               mxmlElementGetAttr(ind->nodes[i], attr));
+    }
+    else
+    {
+      puts("Node      Address   Element");
+      puts("--------  --------  --------------");
+
+      for (i = 0; i < ind->num_nodes; i ++)
+        printf("%8d  %-8p  %s\n", i, ind->nodes[i],
+               ind->nodes[i]->value.element.name);
+    }
+
+    putchar('\n');
+  }
+#endif /* DEBUG */
+
+  if (ind->num_nodes > 1)
+    index_sort(ind, 0, ind->num_nodes - 1);
+
+#ifdef DEBUG
+  {
+    int i;                              /* Looping var */
+
+
+    puts("After sorting:\n");
+
+    if (attr)
+    {
+      printf("Node      Address   Element         %s\n", attr);
+      puts("--------  --------  --------------  ------------------------------");
+
+      for (i = 0; i < ind->num_nodes; i ++)
+        printf("%8d  %-8p  %-14.14s  %s\n", i, ind->nodes[i],
+               ind->nodes[i]->value.element.name,
+               mxmlElementGetAttr(ind->nodes[i], attr));
+    }
+    else
+    {
+      puts("Node      Address   Element");
+      puts("--------  --------  --------------");
+
+      for (i = 0; i < ind->num_nodes; i ++)
+        printf("%8d  %-8p  %s\n", i, ind->nodes[i],
+               ind->nodes[i]->value.element.name);
+    }
+
+    putchar('\n');
+  }
+#endif /* DEBUG */
+
+ /*
+  * Return the new index...
+  */
+
+  return (ind);
+}
+
+
+/*
+ * 'mxmlIndexReset()' - Reset the enumeration/find pointer in the index and
+ *                      return the first node in the index.
+ *
+ * This function should be called prior to using mxmlIndexEnum() or
+ * mxmlIndexFind() for the first time.
+ */
+
+mxml_node_t *                           /* O - First node or NULL if there is none */
+mxmlIndexReset(mxml_index_t *ind)       /* I - Index to reset */
+{
+#ifdef DEBUG
+  printf("mxmlIndexReset(ind=%p)\n", ind);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!ind)
+    return (NULL);
+
+ /*
+  * Set the index to the first element...
+  */
+
+  ind->cur_node = 0;
+
+ /*
+  * Return the first node...
+  */
+
+  if (ind->num_nodes)
+    return (ind->nodes[0]);
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'index_compare()' - Compare two nodes.
+ */
+
+static int                              /* O - Result of comparison */
+index_compare(mxml_index_t *ind,        /* I - Index */
+              mxml_node_t  *first,      /* I - First node */
+              mxml_node_t  *second)     /* I - Second node */
+{
+  int   diff;                           /* Difference */
+
+
+ /*
+  * Check the element name...
+  */
+
+  if ((diff = strcmp(first->value.element.name,
+                     second->value.element.name)) != 0)
+    return (diff);
+
+ /*
+  * Check the attribute value...
+  */
+
+  if (ind->attr)
+  {
+    if ((diff = strcmp(mxmlElementGetAttr(first, ind->attr),
+                       mxmlElementGetAttr(second, ind->attr))) != 0)
+      return (diff);
+  }
+
+ /*
+  * No difference, return 0...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'index_find()' - Compare a node with index values.
+ */
+
+static int                              /* O - Result of comparison */
+index_find(mxml_index_t *ind,           /* I - Index */
+           const char   *element,       /* I - Element name or NULL */
+           const char   *value,         /* I - Attribute value or NULL */
+           mxml_node_t  *node)          /* I - Node */
+{
+  int   diff;                           /* Difference */
+
+
+ /*
+  * Check the element name...
+  */
+
+  if (element)
+  {
+    if ((diff = strcmp(element, node->value.element.name)) != 0)
+      return (diff);
+  }
+
+ /*
+  * Check the attribute value...
+  */
+
+  if (value)
+  {
+    if ((diff = strcmp(value, mxmlElementGetAttr(node, ind->attr))) != 0)
+      return (diff);
+  }
+
+ /*
+  * No difference, return 0...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'index_sort()' - Sort the nodes in the index...
+ *
+ * This function implements the classic quicksort algorithm...
+ */
+
+static void
+index_sort(mxml_index_t *ind,           /* I - Index to sort */
+           int          left,           /* I - Left node in partition */
+           int          right)          /* I - Right node in partition */
+{
+  mxml_node_t   *pivot,                 /* Pivot node */
+                *temp;                  /* Swap node */
+  int           templ,                  /* Temporary left node */
+                tempr;                  /* Temporary right node */
+
+
+ /*
+  * Loop until we have sorted all the way to the right...
+  */
+
+  do
+  {
+   /*
+    * Sort the pivot in the current partition...
+    */
+
+    pivot = ind->nodes[left];
+
+    for (templ = left, tempr = right; templ < tempr;)
+    {
+     /*
+      * Move left while left node <= pivot node...
+      */
+
+      while ((templ < right) &&
+             index_compare(ind, ind->nodes[templ], pivot) <= 0)
+        templ ++;
+
+     /*
+      * Move right while right node > pivot node...
+      */
+
+      while ((tempr > left) &&
+             index_compare(ind, ind->nodes[tempr], pivot) > 0)
+        tempr --;
+
+     /*
+      * Swap nodes if needed...
+      */
+
+      if (templ < tempr)
+      {
+        temp              = ind->nodes[templ];
+        ind->nodes[templ] = ind->nodes[tempr];
+        ind->nodes[tempr] = temp;
+      }
+    }
+
+   /*
+    * When we get here, the right (tempr) node is the new position for the
+    * pivot node...
+    */
+
+    if (index_compare(ind, pivot, ind->nodes[tempr]) > 0)
+    {
+      ind->nodes[left]  = ind->nodes[tempr];
+      ind->nodes[tempr] = pivot;
+    }
+
+   /*
+    * Recursively sort the left partition as needed...
+    */
+
+    if (left < (tempr - 1))
+      index_sort(ind, left, tempr - 1);
+  }
+  while (right > (left = tempr + 1));
+}
+
+
+/*
+ * End of "$Id: mxml-index.c 426 2011-01-01 23:42:17Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-node.c b/pathologist/src/minixml/mxml-node.c
new file mode 100644
index 0000000..44af759
--- /dev/null
+++ b/pathologist/src/minixml/mxml-node.c
@@ -0,0 +1,807 @@
+/*
+ * "$Id: mxml-node.c 436 2011-01-22 01:02:05Z mike $"
+ *
+ * Node support code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlAdd()         - Add a node to a tree.
+ *   mxmlDelete()      - Delete a node and all of its children.
+ *   mxmlGetRefCount() - Get the current reference (use) count for a node.
+ *   mxmlNewCDATA()    - Create a new CDATA node.
+ *   mxmlNewCustom()   - Create a new custom data node.
+ *   mxmlNewElement()  - Create a new element node.
+ *   mxmlNewInteger()  - Create a new integer node.
+ *   mxmlNewOpaque()   - Create a new opaque string.
+ *   mxmlNewReal()     - Create a new real number node.
+ *   mxmlNewText()     - Create a new text fragment node.
+ *   mxmlNewTextf()    - Create a new formatted text fragment node.
+ *   mxmlRemove()      - Remove a node from its parent.
+ *   mxmlNewXML()      - Create a new XML document tree.
+ *   mxmlRelease()     - Release a node.
+ *   mxmlRetain()      - Retain a node.
+ *   mxml_new()        - Create a new node.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Local functions...
+ */
+
+static mxml_node_t      *mxml_new(mxml_node_t *parent, mxml_type_t type);
+
+
+/*
+ * 'mxmlAdd()' - Add a node to a tree.
+ *
+ * Adds the specified node to the parent. If the child argument is not
+ * NULL, puts the new node before or after the specified child depending
+ * on the value of the where argument. If the child argument is NULL,
+ * puts the new node at the beginning of the child list (MXML_ADD_BEFORE)
+ * or at the end of the child list (MXML_ADD_AFTER). The constant
+ * MXML_ADD_TO_PARENT can be used to specify a NULL child pointer.
+ */
+
+void
+mxmlAdd(mxml_node_t *parent,            /* I - Parent node */
+        int         where,              /* I - Where to add, MXML_ADD_BEFORE or MXML_ADD_AFTER */
+        mxml_node_t *child,             /* I - Child node for where or MXML_ADD_TO_PARENT */
+        mxml_node_t *node)              /* I - Node to add */
+{
+#ifdef DEBUG
+  fprintf(stderr, "mxmlAdd(parent=%p, where=%d, child=%p, node=%p)\n", parent,
+          where, child, node);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!parent || !node)
+    return;
+
+#if DEBUG > 1
+  fprintf(stderr, "    BEFORE: node->parent=%p\n", node->parent);
+  if (parent)
+  {
+    fprintf(stderr, "    BEFORE: parent->child=%p\n", parent->child);
+    fprintf(stderr, "    BEFORE: parent->last_child=%p\n", parent->last_child);
+    fprintf(stderr, "    BEFORE: parent->prev=%p\n", parent->prev);
+    fprintf(stderr, "    BEFORE: parent->next=%p\n", parent->next);
+  }
+#endif /* DEBUG > 1 */
+
+ /*
+  * Remove the node from any existing parent...
+  */
+
+  if (node->parent)
+    mxmlRemove(node);
+
+ /*
+  * Reset pointers...
+  */
+
+  node->parent = parent;
+
+  switch (where)
+  {
+    case MXML_ADD_BEFORE :
+        if (!child || child == parent->child || child->parent != parent)
+        {
+         /*
+          * Insert as first node under parent...
+          */
+
+          node->next = parent->child;
+
+          if (parent->child)
+            parent->child->prev = node;
+          else
+            parent->last_child = node;
+
+          parent->child = node;
+        }
+        else
+        {
+         /*
+          * Insert node before this child...
+          */
+
+          node->next = child;
+          node->prev = child->prev;
+
+          if (child->prev)
+            child->prev->next = node;
+          else
+            parent->child = node;
+
+          child->prev = node;
+        }
+        break;
+
+    case MXML_ADD_AFTER :
+        if (!child || child == parent->last_child || child->parent != parent)
+        {
+         /*
+          * Insert as last node under parent...
+          */
+
+          node->parent = parent;
+          node->prev   = parent->last_child;
+
+          if (parent->last_child)
+            parent->last_child->next = node;
+          else
+            parent->child = node;
+
+          parent->last_child = node;
+        }
+        else
+        {
+         /*
+          * Insert node after this child...
+          */
+
+          node->prev = child;
+          node->next = child->next;
+
+          if (child->next)
+            child->next->prev = node;
+          else
+            parent->last_child = node;
+
+          child->next = node;
+        }
+        break;
+  }
+
+#if DEBUG > 1
+  fprintf(stderr, "    AFTER: node->parent=%p\n", node->parent);
+  if (parent)
+  {
+    fprintf(stderr, "    AFTER: parent->child=%p\n", parent->child);
+    fprintf(stderr, "    AFTER: parent->last_child=%p\n", parent->last_child);
+    fprintf(stderr, "    AFTER: parent->prev=%p\n", parent->prev);
+    fprintf(stderr, "    AFTER: parent->next=%p\n", parent->next);
+  }
+#endif /* DEBUG > 1 */
+}
+
+
+/*
+ * 'mxmlDelete()' - Delete a node and all of its children.
+ *
+ * If the specified node has a parent, this function first removes the
+ * node from its parent using the mxmlRemove() function.
+ */
+
+void
+mxmlDelete(mxml_node_t *node)           /* I - Node to delete */
+{
+  int   i;                              /* Looping var */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlDelete(node=%p)\n", node);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return;
+
+ /*
+  * Remove the node from its parent, if any...
+  */
+
+  mxmlRemove(node);
+
+ /*
+  * Delete children...
+  */
+
+  while (node->child)
+    mxmlDelete(node->child);
+
+ /*
+  * Now delete any node data...
+  */
+
+  switch (node->type)
+  {
+    case MXML_ELEMENT :
+        if (node->value.element.name)
+          free(node->value.element.name);
+
+        if (node->value.element.num_attrs)
+        {
+          for (i = 0; i < node->value.element.num_attrs; i ++)
+          {
+            if (node->value.element.attrs[i].name)
+              free(node->value.element.attrs[i].name);
+            if (node->value.element.attrs[i].value)
+              free(node->value.element.attrs[i].value);
+          }
+
+          free(node->value.element.attrs);
+        }
+        break;
+    case MXML_INTEGER :
+       /* Nothing to do */
+        break;
+    case MXML_OPAQUE :
+        if (node->value.opaque)
+          free(node->value.opaque);
+        break;
+    case MXML_REAL :
+       /* Nothing to do */
+        break;
+    case MXML_TEXT :
+        if (node->value.text.string)
+          free(node->value.text.string);
+        break;
+    case MXML_CUSTOM :
+        if (node->value.custom.data &&
+            node->value.custom.destroy)
+          (*(node->value.custom.destroy))(node->value.custom.data);
+        break;
+    default :
+        break;
+  }
+
+ /*
+  * Free this node...
+  */
+
+  free(node);
+}
+
+
+/*
+ * 'mxmlGetRefCount()' - Get the current reference (use) count for a node.
+ *
+ * The initial reference count of new nodes is 1. Use the @link mxmlRetain@
+ * and @link mxmlRelease@ functions to increment and decrement a node's
+ * reference count.
+ *
+ * @since Mini-XML 2.7@.
+ */
+
+int                                     /* O - Reference count */
+mxmlGetRefCount(mxml_node_t *node)      /* I - Node */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (0);
+
+ /*
+  * Return the reference count...
+  */
+
+  return (node->ref_count);
+}
+
+
+/*
+ * 'mxmlNewCDATA()' - Create a new CDATA node.
+ *
+ * The new CDATA node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * CDATA node has no parent. The data string must be nul-terminated and
+ * is copied into the new node. CDATA nodes use the MXML_ELEMENT type.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewCDATA(mxml_node_t *parent,       /* I - Parent node or MXML_NO_PARENT */
+             const char  *data)         /* I - Data string */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewCDATA(parent=%p, data=\"%s\")\n",
+          parent, data ? data : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!data)
+    return (NULL);
+
+ /*
+  * Create the node and set the name value...
+  */
+
+  if ((node = mxml_new(parent, MXML_ELEMENT)) != NULL)
+    node->value.element.name = _mxml_strdupf("![CDATA[%s]]", data);
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewCustom()' - Create a new custom data node.
+ *
+ * The new custom node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * element node has no parent. NULL can be passed when the data in the
+ * node is not dynamically allocated or is separately managed.
+ *
+ * @since Mini-XML 2.1@
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewCustom(
+    mxml_node_t              *parent,   /* I - Parent node or MXML_NO_PARENT */
+    void                     *data,     /* I - Pointer to data */
+    mxml_custom_destroy_cb_t destroy)   /* I - Function to destroy data */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewCustom(parent=%p, data=%p, destroy=%p)\n", parent,
+          data, destroy);
+#endif /* DEBUG */
+
+ /*
+  * Create the node and set the value...
+  */
+
+  if ((node = mxml_new(parent, MXML_CUSTOM)) != NULL)
+  {
+    node->value.custom.data    = data;
+    node->value.custom.destroy = destroy;
+  }
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewElement()' - Create a new element node.
+ *
+ * The new element node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * element node has no parent.
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewElement(mxml_node_t *parent,     /* I - Parent node or MXML_NO_PARENT */
+               const char  *name)       /* I - Name of element */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewElement(parent=%p, name=\"%s\")\n", parent,
+          name ? name : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!name)
+    return (NULL);
+
+ /*
+  * Create the node and set the element name...
+  */
+
+  if ((node = mxml_new(parent, MXML_ELEMENT)) != NULL)
+    node->value.element.name = strdup(name);
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewInteger()' - Create a new integer node.
+ *
+ * The new integer node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * integer node has no parent.
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewInteger(mxml_node_t *parent,     /* I - Parent node or MXML_NO_PARENT */
+               int         integer)     /* I - Integer value */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewInteger(parent=%p, integer=%d)\n", parent, integer);
+#endif /* DEBUG */
+
+ /*
+  * Create the node and set the element name...
+  */
+
+  if ((node = mxml_new(parent, MXML_INTEGER)) != NULL)
+    node->value.integer = integer;
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewOpaque()' - Create a new opaque string.
+ *
+ * The new opaque node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * opaque node has no parent. The opaque string must be nul-terminated and
+ * is copied into the new node.
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewOpaque(mxml_node_t *parent,      /* I - Parent node or MXML_NO_PARENT */
+              const char  *opaque)      /* I - Opaque string */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewOpaque(parent=%p, opaque=\"%s\")\n", parent,
+          opaque ? opaque : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!opaque)
+    return (NULL);
+
+ /*
+  * Create the node and set the element name...
+  */
+
+  if ((node = mxml_new(parent, MXML_OPAQUE)) != NULL)
+    node->value.opaque = strdup(opaque);
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewReal()' - Create a new real number node.
+ *
+ * The new real number node is added to the end of the specified parent's
+ * child list. The constant MXML_NO_PARENT can be used to specify that
+ * the new real number node has no parent.
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewReal(mxml_node_t *parent,        /* I - Parent node or MXML_NO_PARENT */
+            double      real)           /* I - Real number value */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewReal(parent=%p, real=%g)\n", parent, real);
+#endif /* DEBUG */
+
+ /*
+  * Create the node and set the element name...
+  */
+
+  if ((node = mxml_new(parent, MXML_REAL)) != NULL)
+    node->value.real = real;
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewText()' - Create a new text fragment node.
+ *
+ * The new text node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * text node has no parent. The whitespace parameter is used to specify
+ * whether leading whitespace is present before the node. The text
+ * string must be nul-terminated and is copied into the new node.  
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewText(mxml_node_t *parent,        /* I - Parent node or MXML_NO_PARENT */
+            int         whitespace,     /* I - 1 = leading whitespace, 0 = no whitespace */
+            const char  *string)        /* I - String */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewText(parent=%p, whitespace=%d, string=\"%s\")\n",
+          parent, whitespace, string ? string : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!string)
+    return (NULL);
+
+ /*
+  * Create the node and set the text value...
+  */
+
+  if ((node = mxml_new(parent, MXML_TEXT)) != NULL)
+  {
+    node->value.text.whitespace = whitespace;
+    node->value.text.string     = strdup(string);
+  }
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewTextf()' - Create a new formatted text fragment node.
+ *
+ * The new text node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * text node has no parent. The whitespace parameter is used to specify
+ * whether leading whitespace is present before the node. The format
+ * string must be nul-terminated and is formatted into the new node.  
+ */
+
+mxml_node_t *                           /* O - New node */
+mxmlNewTextf(mxml_node_t *parent,       /* I - Parent node or MXML_NO_PARENT */
+             int         whitespace,    /* I - 1 = leading whitespace, 0 = no whitespace */
+             const char  *format,       /* I - Printf-style frmat string */
+             ...)                       /* I - Additional args as needed */
+{
+  mxml_node_t   *node;                  /* New node */
+  va_list       ap;                     /* Pointer to arguments */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewTextf(parent=%p, whitespace=%d, format=\"%s\", ...)\n",
+          parent, whitespace, format ? format : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!format)
+    return (NULL);
+
+ /*
+  * Create the node and set the text value...
+  */
+
+  if ((node = mxml_new(parent, MXML_TEXT)) != NULL)
+  {
+    va_start(ap, format);
+
+    node->value.text.whitespace = whitespace;
+    node->value.text.string     = _mxml_vstrdupf(format, ap);
+
+    va_end(ap);
+  }
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlRemove()' - Remove a node from its parent.
+ *
+ * Does not free memory used by the node - use mxmlDelete() for that.
+ * This function does nothing if the node has no parent.
+ */
+
+void
+mxmlRemove(mxml_node_t *node)           /* I - Node to remove */
+{
+#ifdef DEBUG
+  fprintf(stderr, "mxmlRemove(node=%p)\n", node);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || !node->parent)
+    return;
+
+ /*
+  * Remove from parent...
+  */
+
+#if DEBUG > 1
+  fprintf(stderr, "    BEFORE: node->parent=%p\n", node->parent);
+  if (node->parent)
+  {
+    fprintf(stderr, "    BEFORE: node->parent->child=%p\n", node->parent->child);
+    fprintf(stderr, "    BEFORE: node->parent->last_child=%p\n", node->parent->last_child);
+  }
+  fprintf(stderr, "    BEFORE: node->child=%p\n", node->child);
+  fprintf(stderr, "    BEFORE: node->last_child=%p\n", node->last_child);
+  fprintf(stderr, "    BEFORE: node->prev=%p\n", node->prev);
+  fprintf(stderr, "    BEFORE: node->next=%p\n", node->next);
+#endif /* DEBUG > 1 */
+
+  if (node->prev)
+    node->prev->next = node->next;
+  else
+    node->parent->child = node->next;
+
+  if (node->next)
+    node->next->prev = node->prev;
+  else
+    node->parent->last_child = node->prev;
+
+  node->parent = NULL;
+  node->prev   = NULL;
+  node->next   = NULL;
+
+#if DEBUG > 1
+  fprintf(stderr, "    AFTER: node->parent=%p\n", node->parent);
+  if (node->parent)
+  {
+    fprintf(stderr, "    AFTER: node->parent->child=%p\n", node->parent->child);
+    fprintf(stderr, "    AFTER: node->parent->last_child=%p\n", node->parent->last_child);
+  }
+  fprintf(stderr, "    AFTER: node->child=%p\n", node->child);
+  fprintf(stderr, "    AFTER: node->last_child=%p\n", node->last_child);
+  fprintf(stderr, "    AFTER: node->prev=%p\n", node->prev);
+  fprintf(stderr, "    AFTER: node->next=%p\n", node->next);
+#endif /* DEBUG > 1 */
+}
+
+
+/*
+ * 'mxmlNewXML()' - Create a new XML document tree.
+ *
+ * The "version" argument specifies the version number to put in the
+ * ?xml element node. If NULL, version 1.0 is assumed.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *                           /* O - New ?xml node */
+mxmlNewXML(const char *version)         /* I - Version number to use */
+{
+  char  element[1024];                  /* Element text */
+
+
+  snprintf(element, sizeof(element), "?xml version=\"%s\" encoding=\"utf-8\"?",
+           version ? version : "1.0");
+
+  return (mxmlNewElement(NULL, element));
+}
+
+
+/*
+ * 'mxmlRelease()' - Release a node.
+ *
+ * When the reference count reaches zero, the node (and any children)
+ * is deleted via mxmlDelete().
+ *
+ * @since Mini-XML 2.3@
+ */
+
+int                                     /* O - New reference count */
+mxmlRelease(mxml_node_t *node)          /* I - Node */
+{
+  if (node)
+  {
+    if ((-- node->ref_count) <= 0)
+    {
+      mxmlDelete(node);
+      return (0);
+    }
+    else
+      return (node->ref_count);
+  }
+  else
+    return (-1);
+}
+
+
+/*
+ * 'mxmlRetain()' - Retain a node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+int                                     /* O - New reference count */
+mxmlRetain(mxml_node_t *node)           /* I - Node */
+{
+  if (node)
+    return (++ node->ref_count);
+  else
+    return (-1);
+}
+
+
+/*
+ * 'mxml_new()' - Create a new node.
+ */
+
+static mxml_node_t *                    /* O - New node */
+mxml_new(mxml_node_t *parent,           /* I - Parent node */
+         mxml_type_t type)              /* I - Node type */
+{
+  mxml_node_t   *node;                  /* New node */
+
+
+#if DEBUG > 1
+  fprintf(stderr, "mxml_new(parent=%p, type=%d)\n", parent, type);
+#endif /* DEBUG > 1 */
+
+ /*
+  * Allocate memory for the node...
+  */
+
+  if ((node = calloc(1, sizeof(mxml_node_t))) == NULL)
+  {
+#if DEBUG > 1
+    fputs("    returning NULL\n", stderr);
+#endif /* DEBUG > 1 */
+
+    return (NULL);
+  }
+
+#if DEBUG > 1
+  fprintf(stderr, "    returning %p\n", node);
+#endif /* DEBUG > 1 */
+
+ /*
+  * Set the node type...
+  */
+
+  node->type      = type;
+  node->ref_count = 1;
+
+ /*
+  * Add to the parent if present...
+  */
+
+  if (parent)
+    mxmlAdd(parent, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);
+
+ /*
+  * Return the new node...
+  */
+
+  return (node);
+}
+
+
+/*
+ * End of "$Id: mxml-node.c 436 2011-01-22 01:02:05Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-private.c b/pathologist/src/minixml/mxml-private.c
new file mode 100644
index 0000000..72f3e23
--- /dev/null
+++ b/pathologist/src/minixml/mxml-private.c
@@ -0,0 +1,331 @@
+/*
+ * "$Id: mxml-private.c 422 2010-11-07 22:55:11Z mike $"
+ *
+ * Private functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxml_error()      - Display an error message.
+ *   mxml_integer_cb() - Default callback for integer values.
+ *   mxml_opaque_cb()  - Default callback for opaque values.
+ *   mxml_real_cb()    - Default callback for real number values.
+ *   _mxml_global()    - Get global data.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "mxml-private.h"
+
+
+/*
+ * Some crazy people think that unloading a shared object is a good or safe
+ * thing to do.  Unfortunately, most objects are simply *not* safe to unload
+ * and bad things *will* happen.
+ *
+ * The following mess of conditional code allows us to provide a destructor
+ * function in Mini-XML for our thread-global storage so that it can possibly
+ * be unloaded safely, although since there is no standard way to do so I
+ * can't even provide any guarantees that you can do it safely on all platforms.
+ *
+ * This code currently supports AIX, HP-UX, Linux, Mac OS X, Solaris, and
+ * Windows.  It might work on the BSDs and IRIX, but I haven't tested that.
+ */
+
+#if defined(__sun) || defined(_AIX)
+#  pragma fini(_mxml_fini)
+#  define _MXML_FINI _mxml_fini
+#elif defined(__hpux)
+#  pragma FINI _mxml_fini
+#  define _MXML_FINI _mxml_fini
+#elif defined(__GNUC__) /* Linux and Mac OS X */
+#  define _MXML_FINI __attribute((destructor)) _mxml_fini
+#else
+#  define _MXML_FINI _fini
+#endif /* __sun */
+
+
+/*
+ * 'mxml_error()' - Display an error message.
+ */
+
+void
+mxml_error(const char *format,          /* I - Printf-style format string */
+           ...)                         /* I - Additional arguments as needed */
+{
+  va_list       ap;                     /* Pointer to arguments */
+  char          s[1024];                /* Message string */
+  _mxml_global_t *global = _mxml_global();
+                                        /* Global data */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!format)
+    return;
+
+ /*
+  * Format the error message string...
+  */
+
+  va_start(ap, format);
+
+  vsnprintf(s, sizeof(s), format, ap);
+
+  va_end(ap);
+
+ /*
+  * And then display the error message...
+  */
+
+  if (global->error_cb)
+    (*global->error_cb)(s);
+  else
+    fprintf(stderr, "mxml: %s\n", s);
+}
+
+
+/*
+ * 'mxml_ignore_cb()' - Default callback for ignored values.
+ */
+
+mxml_type_t                             /* O - Node type */
+mxml_ignore_cb(mxml_node_t *node)       /* I - Current node */
+{
+  (void)node;
+
+  return (MXML_IGNORE);
+}
+
+
+/*
+ * 'mxml_integer_cb()' - Default callback for integer values.
+ */
+
+mxml_type_t                             /* O - Node type */
+mxml_integer_cb(mxml_node_t *node)      /* I - Current node */
+{
+  (void)node;
+
+  return (MXML_INTEGER);
+}
+
+
+/*
+ * 'mxml_opaque_cb()' - Default callback for opaque values.
+ */
+
+mxml_type_t                             /* O - Node type */
+mxml_opaque_cb(mxml_node_t *node)       /* I - Current node */
+{
+  (void)node;
+
+  return (MXML_OPAQUE);
+}
+
+
+/*
+ * 'mxml_real_cb()' - Default callback for real number values.
+ */
+
+mxml_type_t                             /* O - Node type */
+mxml_real_cb(mxml_node_t *node)         /* I - Current node */
+{
+  (void)node;
+
+  return (MXML_REAL);
+}
+
+
+#ifdef HAVE_PTHREAD_H                   /**** POSIX threading ****/
+#  include <pthread.h>
+
+static pthread_key_t    _mxml_key = -1; /* Thread local storage key */
+static pthread_once_t   _mxml_key_once = PTHREAD_ONCE_INIT;
+                                        /* One-time initialization object */
+static void             _mxml_init(void);
+static void             _mxml_destructor(void *g);
+
+
+/*
+ * '_mxml_destructor()' - Free memory used for globals...
+ */
+
+static void
+_mxml_destructor(void *g)               /* I - Global data */
+{
+  free(g);
+}
+
+
+/*
+ * '_mxml_fini()' - Clean up when unloaded.
+ */
+
+static void
+_MXML_FINI(void)
+{
+  _mxml_global_t        *global;        /* Global data */
+
+
+  if (_mxml_key != -1)
+  {
+    if ((global = (_mxml_global_t *)pthread_getspecific(_mxml_key)) != NULL)
+      _mxml_destructor(global);
+
+    pthread_key_delete(_mxml_key);
+    _mxml_key = -1;
+  }
+}
+
+
+/*
+ * '_mxml_global()' - Get global data.
+ */
+
+_mxml_global_t *                        /* O - Global data */
+_mxml_global(void)
+{
+  _mxml_global_t        *global;        /* Global data */
+
+
+  pthread_once(&_mxml_key_once, _mxml_init);
+
+  if ((global = (_mxml_global_t *)pthread_getspecific(_mxml_key)) == NULL)
+  {
+    global = (_mxml_global_t *)calloc(1, sizeof(_mxml_global_t));
+    pthread_setspecific(_mxml_key, global);
+
+    global->num_entity_cbs = 1;
+    global->entity_cbs[0]  = _mxml_entity_cb;
+    global->wrap           = 72;
+  }
+
+  return (global);
+}
+
+
+/*
+ * '_mxml_init()' - Initialize global data...
+ */
+
+static void
+_mxml_init(void)
+{
+  pthread_key_create(&_mxml_key, _mxml_destructor);
+}
+
+
+#elif defined(WIN32) && defined(MXML1_EXPORTS) /**** WIN32 threading ****/
+#  include <windows.h>
+
+static DWORD _mxml_tls_index;           /* Index for global storage */
+
+
+/*
+ * 'DllMain()' - Main entry for library.
+ */
+ 
+BOOL WINAPI                             /* O - Success/failure */
+DllMain(HINSTANCE hinst,                /* I - DLL module handle */
+        DWORD     reason,               /* I - Reason */
+        LPVOID    reserved)             /* I - Unused */
+{
+  _mxml_global_t        *global;        /* Global data */
+
+
+  (void)hinst;
+  (void)reserved;
+
+  switch (reason) 
+  { 
+    case DLL_PROCESS_ATTACH :           /* Called on library initialization */
+        if ((_mxml_tls_index = TlsAlloc()) == TLS_OUT_OF_INDEXES) 
+          return (FALSE); 
+        break; 
+
+    case DLL_THREAD_DETACH :            /* Called when a thread terminates */
+        if ((global = (_mxml_global_t *)TlsGetValue(_mxml_tls_index)) != NULL)
+          free(global);
+        break; 
+
+    case DLL_PROCESS_DETACH :           /* Called when library is unloaded */
+        if ((global = (_mxml_global_t *)TlsGetValue(_mxml_tls_index)) != NULL)
+          free(global);
+
+        TlsFree(_mxml_tls_index); 
+        break; 
+
+    default: 
+        break; 
+  } 
+
+  return (TRUE);
+}
+
+
+/*
+ * '_mxml_global()' - Get global data.
+ */
+
+_mxml_global_t *                        /* O - Global data */
+_mxml_global(void)
+{
+  _mxml_global_t        *global;        /* Global data */
+
+
+  if ((global = (_mxml_global_t *)TlsGetValue(_mxml_tls_index)) == NULL)
+  {
+    global = (_mxml_global_t *)calloc(1, sizeof(_mxml_global_t));
+
+    global->num_entity_cbs = 1;
+    global->entity_cbs[0]  = _mxml_entity_cb;
+    global->wrap           = 72;
+
+    TlsSetValue(_mxml_tls_index, (LPVOID)global); 
+  }
+
+  return (global);
+}
+
+
+#else                                   /**** No threading ****/
+/*
+ * '_mxml_global()' - Get global data.
+ */
+
+_mxml_global_t *                        /* O - Global data */
+_mxml_global(void)
+{
+  static _mxml_global_t global =        /* Global data */
+  {
+    NULL,                               /* error_cb */
+    1,                                  /* num_entity_cbs */
+    { _mxml_entity_cb },                /* entity_cbs */
+    72,                                 /* wrap */
+    NULL,                               /* custom_load_cb */
+    NULL                                /* custom_save_cb */
+  };
+
+
+  return (&global);
+}
+#endif /* HAVE_PTHREAD_H */
+
+
+/*
+ * End of "$Id: mxml-private.c 422 2010-11-07 22:55:11Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-private.h b/pathologist/src/minixml/mxml-private.h
new file mode 100644
index 0000000..8789e6c
--- /dev/null
+++ b/pathologist/src/minixml/mxml-private.h
@@ -0,0 +1,50 @@
+/*
+ * "$Id: mxml-private.h 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Private definitions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Global, per-thread data...
+ */
+
+typedef struct _mxml_global_s
+{
+  void  (*error_cb)(const char *);
+  int   num_entity_cbs;
+  int   (*entity_cbs[100])(const char *name);
+  int   wrap;
+  mxml_custom_load_cb_t custom_load_cb;
+  mxml_custom_save_cb_t custom_save_cb;
+} _mxml_global_t;
+
+
+/*
+ * Functions...
+ */
+
+extern _mxml_global_t   *_mxml_global(void);
+extern int              _mxml_entity_cb(const char *name);
+
+
+/*
+ * End of "$Id: mxml-private.h 408 2010-09-19 05:26:46Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-search.c b/pathologist/src/minixml/mxml-search.c
new file mode 100644
index 0000000..f975af1
--- /dev/null
+++ b/pathologist/src/minixml/mxml-search.c
@@ -0,0 +1,287 @@
+/*
+ * "$Id: mxml-search.c 427 2011-01-03 02:03:29Z mike $"
+ *
+ * Search/navigation functions for Mini-XML, a small XML-like file
+ * parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlFindElement() - Find the named element.
+ *   mxmlFindValue()   - Find a value with the given path.
+ *   mxmlWalkNext()    - Walk to the next logical node in the tree.
+ *   mxmlWalkPrev()    - Walk to the previous logical node in the tree.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * 'mxmlFindElement()' - Find the named element.
+ *
+ * The search is constrained by the name, attribute name, and value; any
+ * NULL names or values are treated as wildcards, so different kinds of
+ * searches can be implemented by looking for all elements of a given name
+ * or all elements with a specific attribute. The descend argument determines
+ * whether the search descends into child nodes; normally you will use
+ * MXML_DESCEND_FIRST for the initial search and MXML_NO_DESCEND to find
+ * additional direct descendents of the node. The top node argument
+ * constrains the search to a particular node's children.
+ */
+
+mxml_node_t *                           /* O - Element node or NULL */
+mxmlFindElement(mxml_node_t *node,      /* I - Current node */
+                mxml_node_t *top,       /* I - Top node */
+                const char  *name,      /* I - Element name or NULL for any */
+                const char  *attr,      /* I - Attribute name, or NULL for none */
+                const char  *value,     /* I - Attribute value, or NULL for any */
+                int         descend)    /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
+{
+  const char    *temp;                  /* Current attribute value */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || !top || (!attr && value))
+    return (NULL);
+
+ /*
+  * Start with the next node...
+  */
+
+  node = mxmlWalkNext(node, top, descend);
+
+ /*
+  * Loop until we find a matching element...
+  */
+
+  while (node != NULL)
+  {
+   /*
+    * See if this node matches...
+    */
+
+    if (node->type == MXML_ELEMENT &&
+        node->value.element.name &&
+        (!name || !strcmp(node->value.element.name, name)))
+    {
+     /*
+      * See if we need to check for an attribute...
+      */
+
+      if (!attr)
+        return (node);                  /* No attribute search, return it... */
+
+     /*
+      * Check for the attribute...
+      */
+
+      if ((temp = mxmlElementGetAttr(node, attr)) != NULL)
+      {
+       /*
+        * OK, we have the attribute, does it match?
+        */
+
+        if (!value || !strcmp(value, temp))
+          return (node);                /* Yes, return it... */
+      }
+    }
+
+   /*
+    * No match, move on to the next node...
+    */
+
+    if (descend == MXML_DESCEND)
+      node = mxmlWalkNext(node, top, MXML_DESCEND);
+    else
+      node = node->next;
+  }
+
+  return (NULL);
+}
+
+
+/*
+ * 'mxmlFindPath()' - Find a node with the given path.
+ *
+ * The "path" is a slash-separated list of element names. The name "*" is
+ * considered a wildcard for one or more levels of elements.  For example,
+ * "foo/one/two", "bar/two/one", "*\/one", and so forth.
+ *
+ * The first child node of the found node is returned if the given node has
+ * children and the first child is a value node.
+ * 
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *                           /* O - Found node or NULL */
+mxmlFindPath(mxml_node_t *top,          /* I - Top node */
+             const char  *path)         /* I - Path to element */
+{
+  mxml_node_t   *node;                  /* Current node */
+  char          element[256];           /* Current element name */
+  const char    *pathsep;               /* Separator in path */
+  int           descend;                /* mxmlFindElement option */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!top || !path || !*path)
+    return (NULL);
+
+ /*
+  * Search each element in the path...
+  */
+
+  node = top;
+  while (*path)
+  {
+   /*
+    * Handle wildcards...
+    */
+
+    if (!strncmp(path, "*/", 2))
+    {
+      path += 2;
+      descend = MXML_DESCEND;
+    }
+    else
+      descend = MXML_DESCEND_FIRST;
+
+   /*
+    * Get the next element in the path...
+    */
+
+    if ((pathsep = strchr(path, '/')) == NULL)
+      pathsep = path + strlen(path);
+
+    if (pathsep == path || (pathsep - path) >= sizeof(element))
+      return (NULL);
+
+    memcpy(element, path, pathsep - path);
+    element[pathsep - path] = '\0';
+
+    if (*pathsep)
+      path = pathsep + 1;
+    else
+      path = pathsep;
+
+   /*
+    * Search for the element...
+    */
+
+    if ((node = mxmlFindElement(node, node, element, NULL, NULL,
+                                descend)) == NULL)
+      return (NULL);
+  }
+
+ /*
+  * If we get this far, return the node or its first child...
+  */
+
+  if (node->child && node->child->type != MXML_ELEMENT)
+    return (node->child);
+  else
+    return (node);
+}
+
+
+/*
+ * 'mxmlWalkNext()' - Walk to the next logical node in the tree.
+ *
+ * The descend argument controls whether the first child is considered
+ * to be the next node. The top node argument constrains the walk to
+ * the node's children.
+ */
+
+mxml_node_t *                           /* O - Next node or NULL */
+mxmlWalkNext(mxml_node_t *node,         /* I - Current node */
+             mxml_node_t *top,          /* I - Top node */
+             int         descend)       /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
+{
+  if (!node)
+    return (NULL);
+  else if (node->child && descend)
+    return (node->child);
+  else if (node == top)
+    return (NULL);
+  else if (node->next)
+    return (node->next);
+  else if (node->parent && node->parent != top)
+  {
+    node = node->parent;
+
+    while (!node->next)
+      if (node->parent == top || !node->parent)
+        return (NULL);
+      else
+        node = node->parent;
+
+    return (node->next);
+  }
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'mxmlWalkPrev()' - Walk to the previous logical node in the tree.
+ *
+ * The descend argument controls whether the previous node's last child
+ * is considered to be the previous node. The top node argument constrains
+ * the walk to the node's children.
+ */
+
+mxml_node_t *                           /* O - Previous node or NULL */
+mxmlWalkPrev(mxml_node_t *node,         /* I - Current node */
+             mxml_node_t *top,          /* I - Top node */
+             int         descend)       /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
+{
+  if (!node || node == top)
+    return (NULL);
+  else if (node->prev)
+  {
+    if (node->prev->last_child && descend)
+    {
+     /*
+      * Find the last child under the previous node...
+      */
+
+      node = node->prev->last_child;
+
+      while (node->last_child)
+        node = node->last_child;
+
+      return (node);
+    }
+    else
+      return (node->prev);
+  }
+  else if (node->parent != top)
+    return (node->parent);
+  else
+    return (NULL);
+}
+
+
+/*
+ * End of "$Id: mxml-search.c 427 2011-01-03 02:03:29Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-set.c b/pathologist/src/minixml/mxml-set.c
new file mode 100644
index 0000000..b0bd527
--- /dev/null
+++ b/pathologist/src/minixml/mxml-set.c
@@ -0,0 +1,349 @@
+/*
+ * "$Id: mxml-set.c 441 2011-12-09 23:49:00Z mike $"
+ *
+ * Node set functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlSetCDATA()    - Set the element name of a CDATA node.
+ *   mxmlSetCustom()   - Set the data and destructor of a custom data node.
+ *   mxmlSetElement()  - Set the name of an element node.
+ *   mxmlSetInteger()  - Set the value of an integer node.
+ *   mxmlSetOpaque()   - Set the value of an opaque node.
+ *   mxmlSetReal()     - Set the value of a real number node.
+ *   mxmlSetText()     - Set the value of a text node.
+ *   mxmlSetTextf()    - Set the value of a text node to a formatted string.
+ *   mxmlSetUserData() - Set the user data pointer for a node.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * 'mxmlSetCDATA()' - Set the element name of a CDATA node.
+ *
+ * The node is not changed if it (or its first child) is not a CDATA element node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetCDATA(mxml_node_t *node,         /* I - Node to set */
+             const char  *data)         /* I - New data string */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      strncmp(node->value.element.name, "![CDATA[", 8) &&
+      node->child && node->child->type == MXML_ELEMENT &&
+      !strncmp(node->child->value.element.name, "![CDATA[", 8))
+    node = node->child;
+
+  if (!node || node->type != MXML_ELEMENT || !data ||
+      strncmp(node->value.element.name, "![CDATA[", 8))
+    return (-1);
+
+ /*
+  * Free any old element value and set the new value...
+  */
+
+  if (node->value.element.name)
+    free(node->value.element.name);
+
+  node->value.element.name = _mxml_strdupf("![CDATA[%s]]", data);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetCustom()' - Set the data and destructor of a custom data node.
+ *
+ * The node is not changed if it (or its first child) is not a custom node.
+ *
+ * @since Mini-XML 2.1@
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetCustom(
+    mxml_node_t              *node,     /* I - Node to set */
+    void                     *data,     /* I - New data pointer */
+    mxml_custom_destroy_cb_t destroy)   /* I - New destructor function */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_CUSTOM)
+    node = node->child;
+
+  if (!node || node->type != MXML_CUSTOM)
+    return (-1);
+
+ /*
+  * Free any old element value and set the new value...
+  */
+
+  if (node->value.custom.data && node->value.custom.destroy)
+    (*(node->value.custom.destroy))(node->value.custom.data);
+
+  node->value.custom.data    = data;
+  node->value.custom.destroy = destroy;
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetElement()' - Set the name of an element node.
+ *
+ * The node is not changed if it is not an element node.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetElement(mxml_node_t *node,       /* I - Node to set */
+               const char  *name)       /* I - New name string */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name)
+    return (-1);
+
+ /*
+  * Free any old element value and set the new value...
+  */
+
+  if (node->value.element.name)
+    free(node->value.element.name);
+
+  node->value.element.name = strdup(name);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetInteger()' - Set the value of an integer node.
+ *
+ * The node is not changed if it (or its first child) is not an integer node.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetInteger(mxml_node_t *node,       /* I - Node to set */
+               int         integer)     /* I - Integer value */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_INTEGER)
+    node = node->child;
+
+  if (!node || node->type != MXML_INTEGER)
+    return (-1);
+
+ /*
+  * Set the new value and return...
+  */
+
+  node->value.integer = integer;
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetOpaque()' - Set the value of an opaque node.
+ *
+ * The node is not changed if it (or its first child) is not an opaque node.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetOpaque(mxml_node_t *node,        /* I - Node to set */
+              const char  *opaque)      /* I - Opaque string */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_OPAQUE)
+    node = node->child;
+
+  if (!node || node->type != MXML_OPAQUE || !opaque)
+    return (-1);
+
+ /*
+  * Free any old opaque value and set the new value...
+  */
+
+  if (node->value.opaque)
+    free(node->value.opaque);
+
+  node->value.opaque = strdup(opaque);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetReal()' - Set the value of a real number node.
+ *
+ * The node is not changed if it (or its first child) is not a real number node.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetReal(mxml_node_t *node,          /* I - Node to set */
+            double      real)           /* I - Real number value */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_REAL)
+    node = node->child;
+
+  if (!node || node->type != MXML_REAL)
+    return (-1);
+
+ /*
+  * Set the new value and return...
+  */
+
+  node->value.real = real;
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetText()' - Set the value of a text node.
+ *
+ * The node is not changed if it (or its first child) is not a text node.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetText(mxml_node_t *node,          /* I - Node to set */
+            int         whitespace,     /* I - 1 = leading whitespace, 0 = no whitespace */
+            const char  *string)        /* I - String */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_TEXT)
+    node = node->child;
+
+  if (!node || node->type != MXML_TEXT || !string)
+    return (-1);
+
+ /*
+  * Free any old string value and set the new value...
+  */
+
+  if (node->value.text.string)
+    free(node->value.text.string);
+
+  node->value.text.whitespace = whitespace;
+  node->value.text.string     = strdup(string);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetTextf()' - Set the value of a text node to a formatted string.
+ *
+ * The node is not changed if it (or its first child) is not a text node.
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetTextf(mxml_node_t *node,         /* I - Node to set */
+             int         whitespace,    /* I - 1 = leading whitespace, 0 = no whitespace */
+             const char  *format,       /* I - Printf-style format string */
+             ...)                       /* I - Additional arguments as needed */
+{
+  va_list       ap;                     /* Pointer to arguments */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_TEXT)
+    node = node->child;
+
+  if (!node || node->type != MXML_TEXT || !format)
+    return (-1);
+
+ /*
+  * Free any old string value and set the new value...
+  */
+
+  if (node->value.text.string)
+    free(node->value.text.string);
+
+  va_start(ap, format);
+
+  node->value.text.whitespace = whitespace;
+  node->value.text.string     = _mxml_strdupf(format, ap);
+
+  va_end(ap);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetUserData()' - Set the user data pointer for a node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+int                                     /* O - 0 on success, -1 on failure */
+mxmlSetUserData(mxml_node_t *node,      /* I - Node to set */
+                void        *data)      /* I - User data pointer */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (-1);
+
+ /*
+  * Set the user data pointer and return...
+  */
+
+  node->user_data = data;
+  return (0);
+}
+
+
+/*
+ * End of "$Id: mxml-set.c 441 2011-12-09 23:49:00Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxml-string.c b/pathologist/src/minixml/mxml-string.c
new file mode 100644
index 0000000..6be4252
--- /dev/null
+++ b/pathologist/src/minixml/mxml-string.c
@@ -0,0 +1,476 @@
+/*
+ * "$Id: mxml-string.c 424 2010-12-25 16:21:50Z mike $"
+ *
+ * String functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   _mxml_snprintf()  - Format a string.
+ *   _mxml_strdup()    - Duplicate a string.
+ *   _mxml_strdupf()   - Format and duplicate a string.
+ *   _mxml_vsnprintf() - Format a string into a fixed size buffer.
+ *   _mxml_vstrdupf()  - Format and duplicate a string.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+
+
+/*
+ * The va_copy macro is part of C99, but many compilers don't implement it.
+ * Provide a "direct assignment" implmentation when va_copy isn't defined...
+ */
+
+#ifndef va_copy
+#  ifdef __va_copy
+#    define va_copy(dst,src) __va_copy(dst,src)
+#  else
+#    define va_copy(dst,src) memcpy(&dst, &src, sizeof(va_list))
+#  endif /* __va_copy */
+#endif /* va_copy */
+
+
+#ifndef HAVE_SNPRINTF
+/*
+ * '_mxml_snprintf()' - Format a string.
+ */
+
+int                                     /* O - Number of bytes formatted */
+_mxml_snprintf(char       *buffer,      /* I - Output buffer */
+               size_t     bufsize,      /* I - Size of output buffer */
+               const char *format,      /* I - Printf-style format string */
+               ...)                     /* I - Additional arguments as needed */
+{
+  va_list       ap;                     /* Argument list */
+  int           bytes;                  /* Number of bytes formatted */
+
+
+  va_start(ap, format);
+  bytes = vsnprintf(buffer, bufsize, format, ap);
+  va_end(ap);
+
+  return (bytes);
+}
+#endif /* !HAVE_SNPRINTF */
+
+
+/*
+ * '_mxml_strdup()' - Duplicate a string.
+ */
+
+#ifndef HAVE_STRDUP
+char *                                  /* O - New string pointer */
+_mxml_strdup(const char *s)             /* I - String to duplicate */
+{
+  char  *t;                             /* New string pointer */
+
+
+  if (s == NULL)
+    return (NULL);
+
+  if ((t = malloc(strlen(s) + 1)) == NULL)
+    return (NULL);
+
+  return (strcpy(t, s));
+}
+#endif /* !HAVE_STRDUP */
+
+
+/*
+ * '_mxml_strdupf()' - Format and duplicate a string.
+ */
+
+char *                                  /* O - New string pointer */
+_mxml_strdupf(const char *format,       /* I - Printf-style format string */
+              ...)                      /* I - Additional arguments as needed */
+{
+  va_list       ap;                     /* Pointer to additional arguments */
+  char          *s;                     /* Pointer to formatted string */
+
+
+ /*
+  * Get a pointer to the additional arguments, format the string,
+  * and return it...
+  */
+
+  va_start(ap, format);
+  s = _mxml_vstrdupf(format, ap);
+  va_end(ap);
+
+  return (s);
+}
+
+
+#ifndef HAVE_VSNPRINTF
+/*
+ * '_mxml_vsnprintf()' - Format a string into a fixed size buffer.
+ */
+
+int                                     /* O - Number of bytes formatted */
+_mxml_vsnprintf(char       *buffer,     /* O - Output buffer */
+                size_t     bufsize,     /* O - Size of output buffer */
+                const char *format,     /* I - Printf-style format string */
+                va_list    ap)          /* I - Pointer to additional arguments */
+{
+  char          *bufptr,                /* Pointer to position in buffer */
+                *bufend,                /* Pointer to end of buffer */
+                sign,                   /* Sign of format width */
+                size,                   /* Size character (h, l, L) */
+                type;                   /* Format type character */
+  int           width,                  /* Width of field */
+                prec;                   /* Number of characters of precision */
+  char          tformat[100],           /* Temporary format string for sprintf() */
+                *tptr,                  /* Pointer into temporary format */
+                temp[1024];             /* Buffer for formatted numbers */
+  char          *s;                     /* Pointer to string */
+  int           slen;                   /* Length of string */
+  int           bytes;                  /* Total number of bytes needed */
+
+
+ /*
+  * Loop through the format string, formatting as needed...
+  */
+
+  bufptr = buffer;
+  bufend = buffer + bufsize - 1;
+  bytes  = 0;
+
+  while (*format)
+  {
+    if (*format == '%')
+    {
+      tptr = tformat;
+      *tptr++ = *format++;
+
+      if (*format == '%')
+      {
+        if (bufptr && bufptr < bufend) *bufptr++ = *format;
+        bytes ++;
+        format ++;
+        continue;
+      }
+      else if (strchr(" -+#\'", *format))
+      {
+        *tptr++ = *format;
+        sign = *format++;
+      }
+      else
+        sign = 0;
+
+      if (*format == '*')
+      {
+       /*
+        * Get width from argument...
+        */
+
+        format ++;
+        width = va_arg(ap, int);
+
+        snprintf(tptr, sizeof(tformat) - (tptr - tformat), "%d", width);
+        tptr += strlen(tptr);
+      }
+      else
+      {
+        width = 0;
+
+        while (isdigit(*format & 255))
+        {
+          if (tptr < (tformat + sizeof(tformat) - 1))
+            *tptr++ = *format;
+
+          width = width * 10 + *format++ - '0';
+        }
+      }
+
+      if (*format == '.')
+      {
+        if (tptr < (tformat + sizeof(tformat) - 1))
+          *tptr++ = *format;
+
+        format ++;
+
+        if (*format == '*')
+        {
+         /*
+          * Get precision from argument...
+          */
+
+          format ++;
+          prec = va_arg(ap, int);
+
+          snprintf(tptr, sizeof(tformat) - (tptr - tformat), "%d", prec);
+          tptr += strlen(tptr);
+        }
+        else
+        {
+          prec = 0;
+
+          while (isdigit(*format & 255))
+          {
+            if (tptr < (tformat + sizeof(tformat) - 1))
+              *tptr++ = *format;
+
+            prec = prec * 10 + *format++ - '0';
+          }
+        }
+      }
+      else
+        prec = -1;
+
+      if (*format == 'l' && format[1] == 'l')
+      {
+        size = 'L';
+
+        if (tptr < (tformat + sizeof(tformat) - 2))
+        {
+          *tptr++ = 'l';
+          *tptr++ = 'l';
+        }
+
+        format += 2;
+      }
+      else if (*format == 'h' || *format == 'l' || *format == 'L')
+      {
+        if (tptr < (tformat + sizeof(tformat) - 1))
+          *tptr++ = *format;
+
+        size = *format++;
+      }
+
+      if (!*format)
+        break;
+
+      if (tptr < (tformat + sizeof(tformat) - 1))
+        *tptr++ = *format;
+
+      type  = *format++;
+      *tptr = '\0';
+
+      switch (type)
+      {
+        case 'E' : /* Floating point formats */
+        case 'G' :
+        case 'e' :
+        case 'f' :
+        case 'g' :
+            if ((width + 2) > sizeof(temp))
+              break;
+
+            sprintf(temp, tformat, va_arg(ap, double));
+
+            bytes += strlen(temp);
+
+            if (bufptr)
+            {
+              if ((bufptr + strlen(temp)) > bufend)
+              {
+                strncpy(bufptr, temp, (size_t)(bufend - bufptr));
+                bufptr = bufend;
+              }
+              else
+              {
+                strcpy(bufptr, temp);
+                bufptr += strlen(temp);
+              }
+            }
+            break;
+
+        case 'B' : /* Integer formats */
+        case 'X' :
+        case 'b' :
+        case 'd' :
+        case 'i' :
+        case 'o' :
+        case 'u' :
+        case 'x' :
+            if ((width + 2) > sizeof(temp))
+              break;
+
+#ifdef HAVE_LONG_LONG
+            if (size == 'L')
+              sprintf(temp, tformat, va_arg(ap, long long));
+            else
+#endif /* HAVE_LONG_LONG */
+            sprintf(temp, tformat, va_arg(ap, int));
+
+            bytes += strlen(temp);
+
+            if (bufptr)
+            {
+              if ((bufptr + strlen(temp)) > bufend)
+              {
+                strncpy(bufptr, temp, (size_t)(bufend - bufptr));
+                bufptr = bufend;
+              }
+              else
+              {
+                strcpy(bufptr, temp);
+                bufptr += strlen(temp);
+              }
+            }
+            break;
+
+        case 'p' : /* Pointer value */
+            if ((width + 2) > sizeof(temp))
+              break;
+
+            sprintf(temp, tformat, va_arg(ap, void *));
+
+            bytes += strlen(temp);
+
+            if (bufptr)
+            {
+              if ((bufptr + strlen(temp)) > bufend)
+              {
+                strncpy(bufptr, temp, (size_t)(bufend - bufptr));
+                bufptr = bufend;
+              }
+              else
+              {
+                strcpy(bufptr, temp);
+                bufptr += strlen(temp);
+              }
+            }
+            break;
+
+        case 'c' : /* Character or character array */
+            bytes += width;
+
+            if (bufptr)
+            {
+              if (width <= 1)
+                *bufptr++ = va_arg(ap, int);
+              else
+              {
+                if ((bufptr + width) > bufend)
+                  width = bufend - bufptr;
+
+                memcpy(bufptr, va_arg(ap, char *), (size_t)width);
+                bufptr += width;
+              }
+            }
+            break;
+
+        case 's' : /* String */
+            if ((s = va_arg(ap, char *)) == NULL)
+              s = "(null)";
+
+            slen = strlen(s);
+            if (slen > width && prec != width)
+              width = slen;
+
+            bytes += width;
+
+            if (bufptr)
+            {
+              if ((bufptr + width) > bufend)
+                width = bufend - bufptr;
+
+              if (slen > width)
+                slen = width;
+
+              if (sign == '-')
+              {
+                strncpy(bufptr, s, (size_t)slen);
+                memset(bufptr + slen, ' ', (size_t)(width - slen));
+              }
+              else
+              {
+                memset(bufptr, ' ', (size_t)(width - slen));
+                strncpy(bufptr + width - slen, s, (size_t)slen);
+              }
+
+              bufptr += width;
+            }
+            break;
+
+        case 'n' : /* Output number of chars so far */
+            *(va_arg(ap, int *)) = bytes;
+            break;
+      }
+    }
+    else
+    {
+      bytes ++;
+
+      if (bufptr && bufptr < bufend)
+        *bufptr++ = *format;
+
+      format ++;
+    }
+  }
+
+ /*
+  * Nul-terminate the string and return the number of characters needed.
+  */
+
+  *bufptr = '\0';
+
+  return (bytes);
+}
+#endif /* !HAVE_VSNPRINTF */
+
+
+/*
+ * '_mxml_vstrdupf()' - Format and duplicate a string.
+ */
+
+char *                                  /* O - New string pointer */
+_mxml_vstrdupf(const char *format,      /* I - Printf-style format string */
+               va_list    ap)           /* I - Pointer to additional arguments */
+{
+  int           bytes;                  /* Number of bytes required */
+  char          *buffer,                /* String buffer */
+                temp[256];              /* Small buffer for first vsnprintf */
+  va_list       apcopy;                 /* Copy of argument list */
+
+
+ /*
+  * First format with a tiny buffer; this will tell us how many bytes are
+  * needed...
+  */
+
+  va_copy(apcopy, ap);
+  bytes = vsnprintf(temp, sizeof(temp), format, apcopy);
+
+  if (bytes < sizeof(temp))
+  {
+   /*
+    * Hey, the formatted string fits in the tiny buffer, so just dup that...
+    */
+
+    return (strdup(temp));
+  }
+
+ /*
+  * Allocate memory for the whole thing and reformat to the new, larger
+  * buffer...
+  */
+
+  if ((buffer = calloc(1, bytes + 1)) != NULL)
+    vsnprintf(buffer, bytes + 1, format, ap);
+
+ /*
+  * Return the new string...
+  */
+
+  return (buffer);
+}
+
+
+/*
+ * End of "$Id: mxml-string.c 424 2010-12-25 16:21:50Z mike $".
+ */
diff --git a/pathologist/src/minixml/mxmldoc.c b/pathologist/src/minixml/mxmldoc.c
new file mode 100644
index 0000000..28316ee
--- /dev/null
+++ b/pathologist/src/minixml/mxmldoc.c
@@ -0,0 +1,5809 @@
+/*#define DEBUG 1*/
+/*
+ * "$Id: mxmldoc.c 440 2011-08-11 18:51:26Z mike $"
+ *
+ * Documentation generator using Mini-XML, a small XML-like file parsing
+ * library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   main()              - Main entry for test program.
+ *   add_variable()      - Add a variable or argument.
+ *   find_public()       - Find a public function, type, etc.
+ *   get_comment_info()  - Get info from comment.
+ *   get_text()          - Get the text for a node.
+ *   load_cb()           - Set the type of child nodes.
+ *   new_documentation() - Create a new documentation tree.
+ *   remove_directory()  - Remove a directory.
+ *   safe_strcpy()       - Copy a string allowing for overlapping strings.
+ *   scan_file()         - Scan a source file.
+ *   sort_node()         - Insert a node sorted into a tree.
+ *   update_comment()    - Update a comment node.
+ *   usage()             - Show program usage...
+ *   write_description() - Write the description text.
+ *   write_element()     - Write an element's text nodes.
+ *   write_file()        - Copy a file to the output.
+ *   write_function()    - Write documentation for a function.
+ *   write_html()        - Write HTML documentation.
+ *   write_html_head()   - Write the standard HTML header.
+ *   write_man()         - Write manpage documentation.
+ *   write_scu()         - Write a structure, class, or union.
+ *   write_string()      - Write a string, quoting HTML special chars as needed.
+ *   write_toc()         - Write a table-of-contents.
+ *   write_tokens()      - Write <Token> nodes for all APIs.
+ *   ws_cb()             - Whitespace callback for saving.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+#include <time.h>
+#include <sys/stat.h>
+#ifndef WIN32
+#  include <dirent.h>
+#  include <unistd.h>
+#endif /* !WIN32 */
+#ifdef __APPLE__
+#  include <spawn.h>
+#  include <sys/wait.h>
+extern char **environ;
+#endif /* __APPLE__ */
+
+
+/*
+ * This program scans source and header files and produces public API
+ * documentation for code that conforms to the CUPS Configuration
+ * Management Plan (CMP) coding standards.  Please see the following web
+ * page for details:
+ *
+ *     http://www.cups.org/cmp.html
+ *
+ * Using Mini-XML, this program creates and maintains an XML representation
+ * of the public API code documentation which can then be converted to HTML
+ * as desired.  The following is a poor-man's schema:
+ *
+ * <?xml version="1.0"?>
+ * <mxmldoc xmlns="http://www.easysw.com"
+ *  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ *  xsi:schemaLocation="http://www.minixml.org/mxmldoc.xsd">
+ *
+ *   <namespace name="">                        [optional...]
+ *     <constant name="">
+ *       <description>descriptive text</description>
+ *     </constant>
+ *
+ *     <enumeration name="">
+ *       <description>descriptive text</description>
+ *       <constant name="">...</constant>
+ *     </enumeration>
+ *
+ *     <typedef name="">
+ *       <description>descriptive text</description>
+ *       <type>type string</type>
+ *     </typedef>
+ *
+ *     <function name="" scope="">
+ *       <description>descriptive text</description>
+ *       <argument name="" direction="I|O|IO" default="">
+ *         <description>descriptive text</description>
+ *         <type>type string</type>
+ *       </argument>
+ *       <returnvalue>
+ *         <description>descriptive text</description>
+ *         <type>type string</type>
+ *       </returnvalue>
+ *       <seealso>function names separated by spaces</seealso>
+ *     </function>
+ *
+ *     <variable name="" scope="">
+ *       <description>descriptive text</description>
+ *       <type>type string</type>
+ *     </variable>
+ *
+ *     <struct name="">
+ *       <description>descriptive text</description>
+ *       <variable name="">...</variable>
+ *       <function name="">...</function>
+ *     </struct>
+ *
+ *     <union name="">
+ *       <description>descriptive text</description>
+ *       <variable name="">...</variable>
+ *     </union>
+ *
+ *     <class name="" parent="">
+ *       <description>descriptive text</description>
+ *       <class name="">...</class>
+ *       <enumeration name="">...</enumeration>
+ *       <function name="">...</function>
+ *       <struct name="">...</struct>
+ *       <variable name="">...</variable>
+ *     </class>
+ *   </namespace>
+ * </mxmldoc>
+ */
+
+
+/*
+ * Basic states for file parser...
+ */
+
+#define STATE_NONE              0       /* No state - whitespace, etc. */
+#define STATE_PREPROCESSOR      1       /* Preprocessor directive */
+#define STATE_C_COMMENT         2       /* Inside a C comment */
+#define STATE_CXX_COMMENT       3       /* Inside a C++ comment */
+#define STATE_STRING            4       /* Inside a string constant */
+#define STATE_CHARACTER         5       /* Inside a character constant */
+#define STATE_IDENTIFIER        6       /* Inside a keyword/identifier */
+
+
+/*
+ * Output modes...
+ */
+
+#define OUTPUT_NONE             0       /* No output */
+#define OUTPUT_HTML             1       /* Output HTML */
+#define OUTPUT_XML              2       /* Output XML */
+#define OUTPUT_MAN              3       /* Output nroff/man */
+#define OUTPUT_TOKENS           4       /* Output docset Tokens.xml file */
+
+
+/*
+ * Local functions...
+ */
+
+static mxml_node_t      *add_variable(mxml_node_t *parent, const char *name,
+                                      mxml_node_t *type);
+static mxml_node_t      *find_public(mxml_node_t *node, mxml_node_t *top,
+                                     const char *name);
+static char             *get_comment_info(mxml_node_t *description);
+static char             *get_text(mxml_node_t *node, char *buffer, int buflen);
+static mxml_type_t      load_cb(mxml_node_t *node);
+static mxml_node_t      *new_documentation(mxml_node_t **mxmldoc);
+static int              remove_directory(const char *path);
+static void             safe_strcpy(char *dst, const char *src);
+static int              scan_file(const char *filename, FILE *fp,
+                                  mxml_node_t *doc);
+static void             sort_node(mxml_node_t *tree, mxml_node_t *func);
+static void             update_comment(mxml_node_t *parent,
+                                       mxml_node_t *comment);
+static void             usage(const char *option);
+static void             write_description(FILE *out, mxml_node_t *description,
+                                          const char *element, int summary);
+static void             write_element(FILE *out, mxml_node_t *doc,
+                                      mxml_node_t *element, int mode);
+static void             write_file(FILE *out, const char *file);
+static void             write_function(FILE *out, mxml_node_t *doc,
+                                       mxml_node_t *function, int level);
+static void             write_html(const char *section, const char *title,
+                                   const char *footerfile,
+                                   const char *headerfile,
+                                   const char *introfile, const char *cssfile,
+                                   const char *framefile,
+                                   const char *docset, const char *docversion,
+                                   const char *feedname, const char *feedurl,
+                                   mxml_node_t *doc);
+static void             write_html_head(FILE *out, const char *section,
+                                        const char *title, const char *cssfile);
+static void             write_man(const char *man_name, const char *section,
+                                  const char *title, const char *headerfile,
+                                  const char *footerfile, const char *introfile,
+                                  mxml_node_t *doc);
+static void             write_scu(FILE *out, mxml_node_t *doc,
+                                  mxml_node_t *scut);
+static void             write_string(FILE *out, const char *s, int mode);
+static void             write_toc(FILE *out, mxml_node_t *doc,
+                                  const char *introfile, const char *target,
+                                  int xml);
+static void             write_tokens(FILE *out, mxml_node_t *doc,
+                                     const char *path);
+static const char       *ws_cb(mxml_node_t *node, int where);
+
+
+/*
+ * 'main()' - Main entry for test program.
+ */
+
+int                                     /* O - Exit status */
+main(int  argc,                         /* I - Number of command-line args */
+     char *argv[])                      /* I - Command-line args */
+{
+  int           i;                      /* Looping var */
+  int           len;                    /* Length of argument */
+  FILE          *fp;                    /* File to read */
+  mxml_node_t   *doc;                   /* XML documentation tree */
+  mxml_node_t   *mxmldoc;               /* mxmldoc node */
+  const char    *cssfile,               /* CSS stylesheet file */
+                *docset,                /* Documentation set directory */
+                *docversion,            /* Documentation set version */
+                *feedname,              /* Feed name for documentation set */
+                *feedurl,               /* Feed URL for documentation set */
+                *footerfile,            /* Footer file */
+                *framefile,             /* Framed HTML basename */
+                *headerfile,            /* Header file */
+                *introfile,             /* Introduction file */
+                *name,                  /* Name of manpage */
+                *path,                  /* Path to help file for tokens */
+                *section,               /* Section/keywords of documentation */
+                *title,                 /* Title of documentation */
+                *xmlfile;               /* XML file */
+  int           mode,                   /* Output mode */
+                update;                 /* Updated XML file */
+
+
+ /*
+  * Check arguments...
+  */
+
+  cssfile     = NULL;
+  doc         = NULL;
+  docset      = NULL;
+  docversion  = NULL;
+  feedname    = NULL;
+  feedurl     = NULL;
+  footerfile  = NULL;
+  framefile   = NULL;
+  headerfile  = NULL;
+  introfile   = NULL;
+  mode        = OUTPUT_HTML;
+  mxmldoc     = NULL;
+  name        = NULL;
+  path        = NULL;
+  section     = NULL;
+  title       = NULL;
+  update      = 0;
+  xmlfile     = NULL;
+
+  for (i = 1; i < argc; i ++)
+    if (!strcmp(argv[i], "--help"))
+    {
+     /*
+      * Show help...
+      */
+
+      usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--version"))
+    {
+     /*
+      * Show version...
+      */
+
+      puts(MXML_VERSION + 10);
+      return (0);
+    }
+    else if (!strcmp(argv[i], "--css") && !cssfile)
+    {
+     /*
+      * Set CSS stylesheet file...
+      */
+
+      i ++;
+      if (i < argc)
+        cssfile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--docset") && !docset)
+    {
+     /*
+      * Set documentation set directory...
+      */
+
+      i ++;
+      if (i < argc)
+        docset = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--docversion") && !docversion)
+    {
+     /*
+      * Set documentation set directory...
+      */
+
+      i ++;
+      if (i < argc)
+        docversion = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--footer") && !footerfile)
+    {
+     /*
+      * Set footer file...
+      */
+
+      i ++;
+      if (i < argc)
+        footerfile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--feedname") && !feedname)
+    {
+     /*
+      * Set documentation set feed name...
+      */
+
+      i ++;
+      if (i < argc)
+        feedname = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--feedurl") && !feedurl)
+    {
+     /*
+      * Set documentation set feed name...
+      */
+
+      i ++;
+      if (i < argc)
+        feedurl = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--framed") && !framefile)
+    {
+     /*
+      * Set base filename for framed HTML output...
+      */
+
+      i ++;
+      if (i < argc)
+        framefile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--header") && !headerfile)
+    {
+     /*
+      * Set header file...
+      */
+
+      i ++;
+      if (i < argc)
+        headerfile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--intro") && !introfile)
+    {
+     /*
+      * Set intro file...
+      */
+
+      i ++;
+      if (i < argc)
+        introfile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--man") && !name)
+    {
+     /*
+      * Output manpage...
+      */
+
+      i ++;
+      if (i < argc)
+      {
+        mode = OUTPUT_MAN;
+        name = argv[i];
+      }
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--no-output"))
+      mode = OUTPUT_NONE;
+    else if (!strcmp(argv[i], "--section") && !section)
+    {
+     /*
+      * Set section/keywords...
+      */
+
+      i ++;
+      if (i < argc)
+        section = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--title") && !title)
+    {
+     /*
+      * Set title...
+      */
+
+      i ++;
+      if (i < argc)
+        title = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--tokens"))
+    {
+     /*
+      * Output Tokens.xml file...
+      */
+
+      mode = OUTPUT_TOKENS;
+
+      i ++;
+      if (i < argc)
+        path = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (argv[i][0] == '-')
+    {
+     /*
+      * Unknown/bad option...
+      */
+
+      usage(argv[i]);
+    }
+    else
+    {
+     /*
+      * Process XML or source file...
+      */
+
+      len = (int)strlen(argv[i]);
+      if (len > 4 && !strcmp(argv[i] + len - 4, ".xml"))
+      {
+       /*
+        * Set XML file...
+        */
+
+        if (xmlfile)
+          usage(NULL);
+
+        xmlfile = argv[i];
+
+        if (!doc)
+        {
+          if ((fp = fopen(argv[i], "r")) != NULL)
+          {
+           /*
+            * Read the existing XML file...
+            */
+
+            doc = mxmlLoadFile(NULL, fp, load_cb);
+
+            fclose(fp);
+
+            if (!doc)
+            {
+              mxmldoc = NULL;
+
+              fprintf(stderr,
+                      "mxmldoc: Unable to read the XML documentation file "
+                      "\"%s\"!\n", argv[i]);
+            }
+            else if ((mxmldoc = mxmlFindElement(doc, doc, "mxmldoc", NULL,
+                                                NULL, MXML_DESCEND)) == NULL)
+            {
+              fprintf(stderr,
+                      "mxmldoc: XML documentation file \"%s\" is missing "
+                      "<mxmldoc> node!!\n", argv[i]);
+
+              mxmlDelete(doc);
+              doc = NULL;
+            }
+          }
+          else
+          {
+            doc     = NULL;
+            mxmldoc = NULL;
+          }
+
+          if (!doc)
+            doc = new_documentation(&mxmldoc);
+        }
+      }
+      else
+      {
+       /*
+        * Load source file...
+        */
+
+        update = 1;
+
+        if (!doc)
+          doc = new_documentation(&mxmldoc);
+
+        if ((fp = fopen(argv[i], "r")) == NULL)
+        {
+          fprintf(stderr, "mxmldoc: Unable to open source file \"%s\": %s\n",
+                  argv[i], strerror(errno));
+          mxmlDelete(doc);
+          return (1);
+        }
+        else if (scan_file(argv[i], fp, mxmldoc))
+        {
+          fclose(fp);
+          mxmlDelete(doc);
+          return (1);
+        }
+        else
+          fclose(fp);
+      }
+    }
+
+  if (update && xmlfile)
+  {
+   /*
+    * Save the updated XML documentation file...
+    */
+
+    if ((fp = fopen(xmlfile, "w")) != NULL)
+    {
+     /*
+      * Write over the existing XML file...
+      */
+
+      mxmlSetWrapMargin(0);
+
+      if (mxmlSaveFile(doc, fp, ws_cb))
+      {
+        fprintf(stderr,
+                "mxmldoc: Unable to write the XML documentation file \"%s\": "
+                "%s!\n", xmlfile, strerror(errno));
+        fclose(fp);
+        mxmlDelete(doc);
+        return (1);
+      }
+
+      fclose(fp);
+    }
+    else
+    {
+      fprintf(stderr,
+              "mxmldoc: Unable to create the XML documentation file \"%s\": "
+              "%s!\n", xmlfile, strerror(errno));
+      mxmlDelete(doc);
+      return (1);
+    }
+  }
+
+  switch (mode)
+  {
+    case OUTPUT_HTML :
+       /*
+        * Write HTML documentation...
+        */
+
+        write_html(section, title ? title : "Documentation", footerfile,
+                   headerfile, introfile, cssfile, framefile, docset,
+                   docversion, feedname, feedurl, mxmldoc);
+        break;
+
+    case OUTPUT_MAN :
+       /*
+        * Write manpage documentation...
+        */
+
+        write_man(name, section, title, footerfile, headerfile, introfile,
+                  mxmldoc);
+        break;
+
+    case OUTPUT_TOKENS :
+        fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+              "<Tokens version=\"1.0\">\n", stdout);
+
+        write_tokens(stdout, mxmldoc, path);
+
+        fputs("</Tokens>\n", stdout);
+        break;
+  }
+
+ /*
+  * Delete the tree and return...
+  */
+
+  mxmlDelete(doc);
+
+  return (0);
+}
+
+
+/*
+ * 'add_variable()' - Add a variable or argument.
+ */
+
+static mxml_node_t *                    /* O - New variable/argument */
+add_variable(mxml_node_t *parent,       /* I - Parent node */
+             const char  *name,         /* I - "argument" or "variable" */
+             mxml_node_t *type)         /* I - Type nodes */
+{
+  mxml_node_t   *variable,              /* New variable */
+                *node,                  /* Current node */
+                *next;                  /* Next node */
+  char          buffer[16384],          /* String buffer */
+                *bufptr;                /* Pointer into buffer */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "add_variable(parent=%p, name=\"%s\", type=%p)\n",
+          parent, name, type);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!type || !type->child)
+    return (NULL);
+
+ /*
+  * Create the variable/argument node...
+  */
+
+  variable = mxmlNewElement(parent, name);
+
+ /*
+  * Check for a default value...
+  */
+
+  for (node = type->child; node; node = node->next)
+    if (!strcmp(node->value.text.string, "="))
+      break;
+
+  if (node)
+  {
+   /*
+    * Default value found, copy it and add as a "default" attribute...
+    */
+
+    for (bufptr = buffer; node; bufptr += strlen(bufptr))
+    {
+      if (node->value.text.whitespace && bufptr > buffer)
+        *bufptr++ = ' ';
+
+      strcpy(bufptr, node->value.text.string);
+
+      next = node->next;
+      mxmlDelete(node);
+      node = next;
+    }
+
+    mxmlElementSetAttr(variable, "default", buffer);
+  }
+
+ /*
+  * Extract the argument/variable name...
+  */
+
+  if (type->last_child->value.text.string[0] == ')')
+  {
+   /*
+    * Handle "type (*name)(args)"...
+    */
+
+    for (node = type->child; node; node = node->next)
+      if (node->value.text.string[0] == '(')
+        break;
+
+    for (bufptr = buffer; node; bufptr += strlen(bufptr))
+    {
+      if (node->value.text.whitespace && bufptr > buffer)
+        *bufptr++ = ' ';
+
+      strcpy(bufptr, node->value.text.string);
+
+      next = node->next;
+      mxmlDelete(node);
+      node = next;
+    }
+  }
+  else
+  {
+   /*
+    * Handle "type name"...
+    */
+
+    strcpy(buffer, type->last_child->value.text.string);
+    mxmlDelete(type->last_child);
+  }
+
+ /*
+  * Set the name...
+  */
+
+  mxmlElementSetAttr(variable, "name", buffer);
+
+ /*
+  * Add the remaining type information to the variable node...
+  */
+
+  mxmlAdd(variable, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, type);
+
+ /*
+  * Add new new variable node...
+  */
+
+  return (variable);
+}
+
+
+/*
+ * 'find_public()' - Find a public function, type, etc.
+ */
+
+static mxml_node_t *                    /* I - Found node or NULL */
+find_public(mxml_node_t *node,          /* I - Current node */
+            mxml_node_t *top,           /* I - Top node */
+            const char  *name)          /* I - Name of element */
+{
+  mxml_node_t   *description,           /* Description node */
+                *comment;               /* Comment node */
+
+
+  for (node = mxmlFindElement(node, top, name, NULL, NULL,
+                              node == top ? MXML_DESCEND_FIRST :
+                                            MXML_NO_DESCEND);
+       node;
+       node = mxmlFindElement(node, top, name, NULL, NULL, MXML_NO_DESCEND))
+  {
+   /*
+    * Get the description for this node...
+    */
+
+    description = mxmlFindElement(node, node, "description", NULL, NULL,
+                                  MXML_DESCEND_FIRST);
+
+   /*
+    * A missing or empty description signals a private node...
+    */
+
+    if (!description)
+      continue;
+
+   /*
+    * Look for @private@ in the comment text...
+    */
+
+    for (comment = description->child; comment; comment = comment->next)
+      if ((comment->type == MXML_TEXT &&
+           strstr(comment->value.text.string, "@private@")) ||
+          (comment->type == MXML_OPAQUE &&
+           strstr(comment->value.opaque, "@private@")))
+        break;
+
+    if (!comment)
+    {
+     /*
+      * No @private@, so return this node...
+      */
+
+      return (node);
+    }
+  }
+
+ /*
+  * If we get here, there are no (more) public nodes...
+  */
+
+  return (NULL);
+}
+
+
+/*
+ * 'get_comment_info()' - Get info from comment.
+ */
+
+static char *                           /* O - Info from comment */
+get_comment_info(
+    mxml_node_t *description)           /* I - Description node */
+{
+  char          text[10240],            /* Description text */
+                since[255],             /* @since value */
+                *ptr;                   /* Pointer into text */
+  static char   info[1024];             /* Info string */
+
+
+  if (!description)
+    return ("");
+
+  get_text(description, text, sizeof(text));
+
+  for (ptr = strchr(text, '@'); ptr; ptr = strchr(ptr + 1, '@'))
+  {
+    if (!strncmp(ptr, "@deprecated@", 12))
+      return ("<span class=\"info\">&nbsp;DEPRECATED&nbsp;</span>");
+    else if (!strncmp(ptr, "@since ", 7))
+    {
+      strncpy(since, ptr + 7, sizeof(since) - 1);
+      since[sizeof(since) - 1] = '\0';
+
+      if ((ptr = strchr(since, '@')) != NULL)
+        *ptr = '\0';
+
+      snprintf(info, sizeof(info), "<span class=\"info\">&nbsp;%s&nbsp;</span>", since);
+      return (info);
+    }
+  }
+
+  return ("");
+}
+
+
+/*
+ * 'get_text()' - Get the text for a node.
+ */
+
+static char *                           /* O - Text in node */
+get_text(mxml_node_t *node,             /* I - Node to get */
+         char        *buffer,           /* I - Buffer */
+         int         buflen)            /* I - Size of buffer */
+{
+  char          *ptr,                   /* Pointer into buffer */
+                *end;                   /* End of buffer */
+  int           len;                    /* Length of node */
+  mxml_node_t   *current;               /* Current node */
+
+
+  ptr = buffer;
+  end = buffer + buflen - 1;
+
+  for (current = node->child; current && ptr < end; current = current->next)
+  {
+    if (current->type == MXML_TEXT)
+    {
+      if (current->value.text.whitespace)
+        *ptr++ = ' ';
+
+      len = (int)strlen(current->value.text.string);
+      if (len > (int)(end - ptr))
+        len = (int)(end - ptr);
+
+      memcpy(ptr, current->value.text.string, len);
+      ptr += len;
+    }
+    else if (current->type == MXML_OPAQUE)
+    {
+      len = (int)strlen(current->value.opaque);
+      if (len > (int)(end - ptr))
+        len = (int)(end - ptr);
+
+      memcpy(ptr, current->value.opaque, len);
+      ptr += len;
+    }
+  }
+
+  *ptr = '\0';
+
+  return (buffer);
+}
+
+
+/*
+ * 'load_cb()' - Set the type of child nodes.
+ */
+
+static mxml_type_t                      /* O - Node type */
+load_cb(mxml_node_t *node)              /* I - Node */
+{
+  if (!strcmp(node->value.element.name, "description"))
+    return (MXML_OPAQUE);
+  else
+    return (MXML_TEXT);
+}
+
+
+/*
+ * 'new_documentation()' - Create a new documentation tree.
+ */
+
+static mxml_node_t *                    /* O - New documentation */
+new_documentation(mxml_node_t **mxmldoc)/* O - mxmldoc node */
+{
+  mxml_node_t   *doc;                   /* New documentation */
+
+
+ /*
+  * Create an empty XML documentation file...
+  */
+
+  doc = mxmlNewXML(NULL);
+
+  *mxmldoc = mxmlNewElement(doc, "mxmldoc");
+
+  mxmlElementSetAttr(*mxmldoc, "xmlns", "http://www.easysw.com");
+  mxmlElementSetAttr(*mxmldoc, "xmlns:xsi",
+                     "http://www.w3.org/2001/XMLSchema-instance");
+  mxmlElementSetAttr(*mxmldoc, "xsi:schemaLocation",
+                     "http://www.minixml.org/mxmldoc.xsd");
+
+  return (doc);
+}
+
+
+/*
+ * 'remove_directory()' - Remove a directory.
+ */
+
+static int                              /* O - 1 on success, 0 on failure */
+remove_directory(const char *path)      /* I - Directory to remove */
+{
+#ifdef WIN32
+  /* TODO: Add Windows directory removal code */
+
+#else
+  DIR           *dir;                   /* Directory */
+  struct dirent *dent;                  /* Current directory entry */
+  char          filename[1024];         /* Current filename */
+  struct stat   fileinfo;               /* File information */
+
+
+  if ((dir = opendir(path)) == NULL)
+  {
+    fprintf(stderr, "mxmldoc: Unable to open directory \"%s\": %s\n", path,
+            strerror(errno));
+    return (0);
+  }
+
+  while ((dent = readdir(dir)) != NULL)
+  {
+   /*
+    * Skip "." and ".."...
+    */
+
+    if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
+      continue;
+
+   /*
+    * See if we have a file or directory...
+    */
+
+    snprintf(filename, sizeof(filename), "%s/%s", path, dent->d_name);
+
+    if (stat(filename, &fileinfo))
+    {
+      fprintf(stderr, "mxmldoc: Unable to stat \"%s\": %s\n", filename,
+              strerror(errno));
+      closedir(dir);
+      return (0);
+    }
+
+    if (S_ISDIR(fileinfo.st_mode))
+    {
+      if (!remove_directory(filename))
+      {
+        closedir(dir);
+        return (0);
+      }
+    }
+    else if (unlink(filename))
+    {
+      fprintf(stderr, "mxmldoc: Unable to remove \"%s\": %s\n", filename,
+              strerror(errno));
+      closedir(dir);
+      return (0);
+    }
+  }
+
+  closedir(dir);
+
+  if (rmdir(path))
+  {
+    fprintf(stderr, "mxmldoc: Unable to remove directory \"%s\": %s\n", path,
+            strerror(errno));
+    return (0);
+  }
+#endif /* WIN32 */
+
+  return (1);
+}
+
+
+/*
+ * 'safe_strcpy()' - Copy a string allowing for overlapping strings.
+ */
+
+static void
+safe_strcpy(char       *dst,            /* I - Destination string */
+            const char *src)            /* I - Source string */
+{
+  while (*src)
+    *dst++ = *src++;
+
+  *dst = '\0';
+}
+
+
+/*
+ * 'scan_file()' - Scan a source file.
+ */
+
+static int                              /* O - 0 on success, -1 on error */
+scan_file(const char  *filename,        /* I - Filename */
+          FILE        *fp,              /* I - File to scan */
+          mxml_node_t *tree)            /* I - Function tree */
+{
+  int           state,                  /* Current parser state */
+                braces,                 /* Number of braces active */
+                parens;                 /* Number of active parenthesis */
+  int           ch;                     /* Current character */
+  char          buffer[65536],          /* String buffer */
+                *bufptr;                /* Pointer into buffer */
+  const char    *scope;                 /* Current variable/function scope */
+  mxml_node_t   *comment,               /* <comment> node */
+                *constant,              /* <constant> node */
+                *enumeration,           /* <enumeration> node */
+                *function,              /* <function> node */
+                *fstructclass,          /* function struct/class node */
+                *structclass,           /* <struct> or <class> node */
+                *typedefnode,           /* <typedef> node */
+                *variable,              /* <variable> or <argument> node */
+                *returnvalue,           /* <returnvalue> node */
+                *type,                  /* <type> node */
+                *description,           /* <description> node */
+                *node,                  /* Current node */
+                *next;                  /* Next node */
+#if DEBUG > 1
+  mxml_node_t   *temp;                  /* Temporary node */
+  int           oldstate,               /* Previous state */
+                oldch;                  /* Old character */
+  static const char *states[] =         /* State strings */
+                {
+                  "STATE_NONE",
+                  "STATE_PREPROCESSOR",
+                  "STATE_C_COMMENT",
+                  "STATE_CXX_COMMENT",
+                  "STATE_STRING",
+                  "STATE_CHARACTER",
+                  "STATE_IDENTIFIER"
+                };
+#endif /* DEBUG > 1 */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "scan_file(filename=\"%s\", fp=%p, tree=%p)\n", filename,
+          fp, tree);
+#endif /* DEBUG */
+
+ /*
+  * Initialize the finite state machine...
+  */
+
+  state        = STATE_NONE;
+  braces       = 0;
+  parens       = 0;
+  bufptr       = buffer;
+
+  comment      = mxmlNewElement(MXML_NO_PARENT, "temp");
+  constant     = NULL;
+  enumeration  = NULL;
+  function     = NULL;
+  variable     = NULL;
+  returnvalue  = NULL;
+  type         = NULL;
+  description  = NULL;
+  typedefnode  = NULL;
+  structclass  = NULL;
+  fstructclass = NULL;
+
+  if (!strcmp(tree->value.element.name, "class"))
+    scope = "private";
+  else
+    scope = NULL;
+
+ /*
+  * Read until end-of-file...
+  */
+
+  while ((ch = getc(fp)) != EOF)
+  {
+#if DEBUG > 1
+    oldstate = state;
+    oldch    = ch;
+#endif /* DEBUG > 1 */
+
+    switch (state)
+    {
+      case STATE_NONE :                 /* No state - whitespace, etc. */
+          switch (ch)
+          {
+            case '/' :                  /* Possible C/C++ comment */
+                ch     = getc(fp);
+                bufptr = buffer;
+
+                if (ch == '*')
+                  state = STATE_C_COMMENT;
+                else if (ch == '/')
+                  state = STATE_CXX_COMMENT;
+                else
+                {
+                  ungetc(ch, fp);
+
+                  if (type)
+                  {
+#ifdef DEBUG
+                    fputs("Identifier: <<<< / >>>\n", stderr);
+#endif /* DEBUG */
+                    ch = type->last_child->value.text.string[0];
+                    mxmlNewText(type, isalnum(ch) || ch == '_', "/");
+                  }
+                }
+                break;
+
+            case '#' :                  /* Preprocessor */
+#ifdef DEBUG
+                fputs("    #preprocessor...\n", stderr);
+#endif /* DEBUG */
+                state = STATE_PREPROCESSOR;
+                break;
+
+            case '\'' :                 /* Character constant */
+                state = STATE_CHARACTER;
+                bufptr = buffer;
+                *bufptr++ = ch;
+                break;
+
+            case '\"' :                 /* String constant */
+                state = STATE_STRING;
+                bufptr = buffer;
+                *bufptr++ = ch;
+                break;
+
+            case '{' :
+#ifdef DEBUG
+                fprintf(stderr, "    open brace, function=%p, type=%p...\n",
+                        function, type);
+                if (type)
+                  fprintf(stderr, "    type->child=\"%s\"...\n",
+                          type->child->value.text.string);
+#endif /* DEBUG */
+
+                if (function)
+                {
+                  if (fstructclass)
+                  {
+                    sort_node(fstructclass, function);
+                    fstructclass = NULL;
+                  }
+                  else
+                    sort_node(tree, function);
+
+                  function = NULL;
+                }
+                else if (type && type->child &&
+                         ((!strcmp(type->child->value.text.string, "typedef") &&
+                           type->child->next &&
+                           (!strcmp(type->child->next->value.text.string, "struct") ||
+                            !strcmp(type->child->next->value.text.string, "union") ||
+                            !strcmp(type->child->next->value.text.string, "class"))) ||
+                          !strcmp(type->child->value.text.string, "union") ||
+                          !strcmp(type->child->value.text.string, "struct") ||
+                          !strcmp(type->child->value.text.string, "class")))
+                {
+                 /*
+                  * Start of a class or structure...
+                  */
+
+                  if (!strcmp(type->child->value.text.string, "typedef"))
+                  {
+#ifdef DEBUG
+                    fputs("    starting typedef...\n", stderr);
+#endif /* DEBUG */
+
+                    typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+                    mxmlDelete(type->child);
+                  }
+                  else
+                    typedefnode = NULL;
+
+                  structclass = mxmlNewElement(MXML_NO_PARENT,
+                                               type->child->value.text.string);
+
+#ifdef DEBUG
+                  fprintf(stderr, "%c%s: <<<< %s >>>\n",
+                          toupper(type->child->value.text.string[0]),
+                          type->child->value.text.string + 1,
+                          type->child->next ?
+                              type->child->next->value.text.string : "(noname)");
+
+                  fputs("    type =", stderr);
+                  for (node = type->child; node; node = node->next)
+                    fprintf(stderr, " \"%s\"", node->value.text.string);
+                  putc('\n', stderr);
+
+                  fprintf(stderr, "    scope = %s\n", scope ? scope : "(null)");
+#endif /* DEBUG */
+
+                  if (type->child->next)
+                  {
+                    mxmlElementSetAttr(structclass, "name",
+                                       type->child->next->value.text.string);
+                    sort_node(tree, structclass);
+                  }
+
+                  if (typedefnode && type->child)
+                    type->child->value.text.whitespace = 0;
+                  else if (structclass && type->child &&
+                           type->child->next && type->child->next->next)
+                  {
+                    for (bufptr = buffer, node = type->child->next->next;
+                         node;
+                         bufptr += strlen(bufptr))
+                    {
+                      if (node->value.text.whitespace && bufptr > buffer)
+                        *bufptr++ = ' ';
+
+                      strcpy(bufptr, node->value.text.string);
+
+                      next = node->next;
+                      mxmlDelete(node);
+                      node = next;
+                    }
+
+                    mxmlElementSetAttr(structclass, "parent", buffer);
+
+                    mxmlDelete(type);
+                    type = NULL;
+                  }
+                  else
+                  {
+                    mxmlDelete(type);
+                    type = NULL;
+                  }
+
+                  if (typedefnode && comment->last_child)
+                  {
+                   /*
+                    * Copy comment for typedef as well as class/struct/union...
+                    */
+
+                    mxmlNewText(comment, 0,
+                                comment->last_child->value.text.string);
+                    description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+                    fprintf(stderr,
+                            "    duplicating comment %p/%p for typedef...\n",
+                            comment->last_child, comment->child);
+#endif /* DEBUG */
+                    update_comment(typedefnode, comment->last_child);
+                    mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                            comment->last_child);
+                  }
+
+                  description = mxmlNewElement(structclass, "description");
+#ifdef DEBUG
+                  fprintf(stderr, "    adding comment %p/%p to %s...\n",
+                          comment->last_child, comment->child,
+                          structclass->value.element.name);
+#endif /* DEBUG */
+                  update_comment(structclass, comment->last_child);
+                  mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                          comment->last_child);
+
+                  if (scan_file(filename, fp, structclass))
+                  {
+                    mxmlDelete(comment);
+                    return (-1);
+                  }
+
+#ifdef DEBUG
+                  fputs("    ended typedef...\n", stderr);
+#endif /* DEBUG */
+                  structclass = NULL;
+                  break;
+                }
+                else if (type && type->child && type->child->next &&
+                         (!strcmp(type->child->value.text.string, "enum") ||
+                          (!strcmp(type->child->value.text.string, "typedef") &&
+                           !strcmp(type->child->next->value.text.string, "enum"))))
+                {
+                 /*
+                  * Enumeration type...
+                  */
+
+                  if (!strcmp(type->child->value.text.string, "typedef"))
+                  {
+#ifdef DEBUG
+                    fputs("    starting typedef...\n", stderr);
+#endif /* DEBUG */
+
+                    typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+                    mxmlDelete(type->child);
+                  }
+                  else
+                    typedefnode = NULL;
+
+                  enumeration = mxmlNewElement(MXML_NO_PARENT, "enumeration");
+
+#ifdef DEBUG
+                  fprintf(stderr, "Enumeration: <<<< %s >>>\n",
+                          type->child->next ?
+                              type->child->next->value.text.string : "(noname)");
+#endif /* DEBUG */
+
+                  if (type->child->next)
+                  {
+                    mxmlElementSetAttr(enumeration, "name",
+                                       type->child->next->value.text.string);
+                    sort_node(tree, enumeration);
+                  }
+
+                  if (typedefnode && type->child)
+                    type->child->value.text.whitespace = 0;
+                  else
+                  {
+                    mxmlDelete(type);
+                    type = NULL;
+                  }
+
+                  if (typedefnode && comment->last_child)
+                  {
+                   /*
+                    * Copy comment for typedef as well as class/struct/union...
+                    */
+
+                    mxmlNewText(comment, 0,
+                                comment->last_child->value.text.string);
+                    description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+                    fprintf(stderr,
+                            "    duplicating comment %p/%p for typedef...\n",
+                            comment->last_child, comment->child);
+#endif /* DEBUG */
+                    update_comment(typedefnode, comment->last_child);
+                    mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                            comment->last_child);
+                  }
+
+                  description = mxmlNewElement(enumeration, "description");
+#ifdef DEBUG
+                  fprintf(stderr, "    adding comment %p/%p to enumeration...\n",
+                          comment->last_child, comment->child);
+#endif /* DEBUG */
+                  update_comment(enumeration, comment->last_child);
+                  mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                          comment->last_child);
+                }
+                else if (type && type->child &&
+                         !strcmp(type->child->value.text.string, "extern"))
+                {
+                  if (scan_file(filename, fp, tree))
+                  {
+                    mxmlDelete(comment);
+                    return (-1);
+                  }
+                }
+                else if (type)
+                {
+                  mxmlDelete(type);
+                  type = NULL;
+                }
+
+                braces ++;
+                function = NULL;
+                variable = NULL;
+                break;
+
+            case '}' :
+#ifdef DEBUG
+                fputs("    close brace...\n", stderr);
+#endif /* DEBUG */
+
+                if (structclass)
+                  scope = NULL;
+
+                if (!typedefnode)
+                  enumeration = NULL;
+
+                constant    = NULL;
+                structclass = NULL;
+
+                if (braces > 0)
+                  braces --;
+                else
+                {
+                  mxmlDelete(comment);
+                  return (0);
+                }
+                break;
+
+            case '(' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< ( >>>\n", stderr);
+#endif /* DEBUG */
+                  mxmlNewText(type, 0, "(");
+                }
+
+                parens ++;
+                break;
+
+            case ')' :
+                if (type && parens)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< ) >>>\n", stderr);
+#endif /* DEBUG */
+                  mxmlNewText(type, 0, ")");
+                }
+
+                if (function && type && !parens)
+                {
+                 /*
+                  * Check for "void" argument...
+                  */
+
+                  if (type->child && type->child->next)
+                    variable = add_variable(function, "argument", type);
+                  else
+                    mxmlDelete(type);
+
+                  type = NULL;
+                }
+
+                if (parens > 0)
+                  parens --;
+                break;
+
+            case ';' :
+#ifdef DEBUG
+                fputs("Identifier: <<<< ; >>>\n", stderr);
+                fprintf(stderr, "    enumeration=%p, function=%p, type=%p, type->child=%p, typedefnode=%p\n",
+                        enumeration, function, type, type ? type->child : NULL, typedefnode);
+#endif /* DEBUG */
+
+                if (function)
+                {
+                  if (!strcmp(tree->value.element.name, "class"))
+                  {
+#ifdef DEBUG
+                    fputs("    ADDING FUNCTION TO CLASS\n", stderr);
+#endif /* DEBUG */
+                    sort_node(tree, function);
+                  }
+                  else
+                    mxmlDelete(function);
+
+                  function = NULL;
+                  variable = NULL;
+                }
+
+                if (type)
+                {
+                 /*
+                  * See if we have a typedef...
+                  */
+
+                  if (type->child &&
+                      !strcmp(type->child->value.text.string, "typedef"))
+                  {
+                   /*
+                    * Yes, add it!
+                    */
+
+                    typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+
+                    for (node = type->child->next; node; node = node->next)
+                      if (!strcmp(node->value.text.string, "("))
+                        break;
+
+                    if (node)
+                    {
+                      for (node = node->next; node; node = node->next)
+                        if (strcmp(node->value.text.string, "*"))
+                          break;
+                    }
+
+                    if (!node)
+                      node = type->last_child;
+
+#ifdef DEBUG
+                    fprintf(stderr, "    ADDING TYPEDEF FOR %p(%s)...\n",
+                            node, node->value.text.string);
+#endif /* DEBUG */
+
+                    mxmlElementSetAttr(typedefnode, "name",
+                                       node->value.text.string);
+                    sort_node(tree, typedefnode);
+
+                    if (type->child != node)
+                      mxmlDelete(type->child);
+
+                    mxmlDelete(node);
+
+                    if (type->child)
+                      type->child->value.text.whitespace = 0;
+
+                    mxmlAdd(typedefnode, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                            type);
+                    type = NULL;
+                    break;
+                  }
+                  else if (typedefnode && enumeration)
+                  {
+                   /*
+                    * Add enum typedef...
+                    */
+
+                    node = type->child;
+
+#ifdef DEBUG
+                    fprintf(stderr, "    ADDING TYPEDEF FOR %p(%s)...\n",
+                            node, node->value.text.string);
+#endif /* DEBUG */
+
+                    mxmlElementSetAttr(typedefnode, "name",
+                                       node->value.text.string);
+                    sort_node(tree, typedefnode);
+                    mxmlDelete(type);
+
+                    type = mxmlNewElement(typedefnode, "type");
+                    mxmlNewText(type, 0, "enum");
+                    mxmlNewText(type, 1,
+                                mxmlElementGetAttr(enumeration, "name"));
+                    enumeration = NULL;
+                    type = NULL;
+                    break;
+                  }
+
+                  mxmlDelete(type);
+                  type = NULL;
+                }
+                break;
+
+            case ':' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< : >>>\n", stderr);
+#endif /* DEBUG */
+                  mxmlNewText(type, 1, ":");
+                }
+                break;
+
+            case '*' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< * >>>\n", stderr);
+#endif /* DEBUG */
+                  ch = type->last_child->value.text.string[0];
+                  mxmlNewText(type, isalnum(ch) || ch == '_', "*");
+                }
+                break;
+
+            case ',' :
+                if (type && !enumeration)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< , >>>\n", stderr);
+#endif /* DEBUG */
+                  mxmlNewText(type, 0, ",");
+                }
+                break;
+
+            case '&' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< & >>>\n", stderr);
+#endif /* DEBUG */
+                  mxmlNewText(type, 1, "&");
+                }
+                break;
+
+            case '+' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< + >>>\n", stderr);
+#endif /* DEBUG */
+                  ch = type->last_child->value.text.string[0];
+                  mxmlNewText(type, isalnum(ch) || ch == '_', "+");
+                }
+                break;
+
+            case '-' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< - >>>\n", stderr);
+#endif /* DEBUG */
+                  ch = type->last_child->value.text.string[0];
+                  mxmlNewText(type, isalnum(ch) || ch == '_', "-");
+                }
+                break;
+
+            case '=' :
+                if (type)
+                {
+#ifdef DEBUG
+                  fputs("Identifier: <<<< = >>>\n", stderr);
+#endif /* DEBUG */
+                  ch = type->last_child->value.text.string[0];
+                  mxmlNewText(type, isalnum(ch) || ch == '_', "=");
+                }
+                break;
+
+            default :                   /* Other */
+                if (isalnum(ch) || ch == '_' || ch == '.' || ch == ':' || ch == '~')
+                {
+                  state     = STATE_IDENTIFIER;
+                  bufptr    = buffer;
+                  *bufptr++ = ch;
+                }
+                break;
+          }
+          break;
+
+      case STATE_PREPROCESSOR :         /* Preprocessor directive */
+          if (ch == '\n')
+            state = STATE_NONE;
+          else if (ch == '\\')
+            getc(fp);
+          break;
+
+      case STATE_C_COMMENT :            /* Inside a C comment */
+          switch (ch)
+          {
+            case '\n' :
+                while ((ch = getc(fp)) != EOF)
+                  if (ch == '*')
+                  {
+                    ch = getc(fp);
+
+                    if (ch == '/')
+                    {
+                      *bufptr = '\0';
+
+                      if (comment->child != comment->last_child)
+                      {
+#ifdef DEBUG
+                        fprintf(stderr, "    removing comment %p(%20.20s), last comment %p(%20.20s)...\n",
+                                comment->child,
+                                comment->child ? comment->child->value.text.string : "",
+                                comment->last_child,
+                                comment->last_child ? comment->last_child->value.text.string : "");
+#endif /* DEBUG */
+                        mxmlDelete(comment->child);
+#ifdef DEBUG
+                        fprintf(stderr, "    new comment %p, last comment %p...\n",
+                                comment->child, comment->last_child);
+#endif /* DEBUG */
+                      }
+
+#ifdef DEBUG
+                      fprintf(stderr,
+                              "    processing comment, variable=%p, "
+                              "constant=%p, typedefnode=%p, tree=\"%s\"\n",
+                              variable, constant, typedefnode,
+                              tree->value.element.name);
+#endif /* DEBUG */
+
+                      if (variable)
+                      {
+                        if (strstr(buffer, "@private@"))
+                        {
+                         /*
+                          * Delete private variables...
+                          */
+
+                          mxmlDelete(variable);
+                        }
+                        else
+                        {
+                          description = mxmlNewElement(variable, "description");
+#ifdef DEBUG
+                          fprintf(stderr,
+                                  "    adding comment %p/%p to variable...\n",
+                                  comment->last_child, comment->child);
+#endif /* DEBUG */
+                          mxmlNewText(comment, 0, buffer);
+                          update_comment(variable,
+                                         mxmlNewText(description, 0, buffer));
+                        }
+
+                        variable = NULL;
+                      }
+                      else if (constant)
+                      {
+                        if (strstr(buffer, "@private@"))
+                        {
+                         /*
+                          * Delete private constants...
+                          */
+
+                          mxmlDelete(constant);
+                        }
+                        else
+                        {
+                          description = mxmlNewElement(constant, "description");
+#ifdef DEBUG
+                          fprintf(stderr,
+                                  "    adding comment %p/%p to constant...\n",
+                                  comment->last_child, comment->child);
+#endif /* DEBUG */
+                          mxmlNewText(comment, 0, buffer);
+                          update_comment(constant,
+                                         mxmlNewText(description, 0, buffer));
+                        }
+
+                        constant = NULL;
+                      }
+                      else if (typedefnode)
+                      {
+                        if (strstr(buffer, "@private@"))
+                        {
+                         /*
+                          * Delete private typedefs...
+                          */
+
+                          mxmlDelete(typedefnode);
+
+                          if (structclass)
+                          {
+                            mxmlDelete(structclass);
+                            structclass = NULL;
+                          }
+
+                          if (enumeration)
+                          {
+                            mxmlDelete(enumeration);
+                            enumeration = NULL;
+                          }
+                        }
+                        else
+                        {
+                          description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+                          fprintf(stderr,
+                                  "    adding comment %p/%p to typedef %s...\n",
+                                  comment->last_child, comment->child,
+                                  mxmlElementGetAttr(typedefnode, "name"));
+#endif /* DEBUG */
+                          mxmlNewText(comment, 0, buffer);
+                          update_comment(typedefnode,
+                                         mxmlNewText(description, 0, buffer));
+
+                          if (structclass)
+                          {
+                            description = mxmlNewElement(structclass, "description");
+                            update_comment(structclass,
+                                           mxmlNewText(description, 0, buffer));
+                          }
+                          else if (enumeration)
+                          {
+                            description = mxmlNewElement(enumeration, "description");
+                            update_comment(enumeration,
+                                           mxmlNewText(description, 0, buffer));
+                          }
+                        }
+
+                        typedefnode = NULL;
+                      }
+                      else if (strcmp(tree->value.element.name, "mxmldoc") &&
+                               !mxmlFindElement(tree, tree, "description",
+                                                NULL, NULL, MXML_DESCEND_FIRST))
+                      {
+                        description = mxmlNewElement(tree, "description");
+#ifdef DEBUG
+                        fprintf(stderr, "    adding comment %p/%p to parent...\n",
+                                comment->last_child, comment->child);
+#endif /* DEBUG */
+                        mxmlNewText(comment, 0, buffer);
+                        update_comment(tree,
+                                       mxmlNewText(description, 0, buffer));
+                      }
+                      else
+                      {
+#ifdef DEBUG
+                        fprintf(stderr, "    before adding comment, child=%p, last_child=%p\n",
+                                comment->child, comment->last_child);
+#endif /* DEBUG */
+                        mxmlNewText(comment, 0, buffer);
+#ifdef DEBUG
+                        fprintf(stderr, "    after adding comment, child=%p, last_child=%p\n",
+                                comment->child, comment->last_child);
+#endif /* DEBUG */
+                      }
+#ifdef DEBUG
+                      fprintf(stderr, "C comment: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+                      state = STATE_NONE;
+                      break;
+                    }
+                    else
+                      ungetc(ch, fp);
+                  }
+                  else if (ch == '\n' && bufptr > buffer &&
+                           bufptr < (buffer + sizeof(buffer) - 1))
+                    *bufptr++ = ch;
+                  else if (!isspace(ch))
+                    break;
+
+                if (ch != EOF)
+                  ungetc(ch, fp);
+
+                if (bufptr > buffer && bufptr < (buffer + sizeof(buffer) - 1))
+                  *bufptr++ = '\n';
+                break;
+
+            case '/' :
+                if (ch == '/' && bufptr > buffer && bufptr[-1] == '*')
+                {
+                  while (bufptr > buffer &&
+                         (bufptr[-1] == '*' || isspace(bufptr[-1] & 255)))
+                    bufptr --;
+                  *bufptr = '\0';
+
+                  if (comment->child != comment->last_child)
+                  {
+#ifdef DEBUG
+                    fprintf(stderr, "    removing comment %p(%20.20s), last comment %p(%20.20s)...\n",
+                            comment->child,
+                            comment->child ? comment->child->value.text.string : "",
+                            comment->last_child,
+                            comment->last_child ? comment->last_child->value.text.string : "");
+#endif /* DEBUG */
+                    mxmlDelete(comment->child);
+#ifdef DEBUG
+                    fprintf(stderr, "    new comment %p, last comment %p...\n",
+                            comment->child, comment->last_child);
+#endif /* DEBUG */
+                  }
+
+#ifdef DEBUG
+                  fprintf(stderr,
+                          "    processing comment, variable=%p, "
+                          "constant=%p, typedefnode=%p, tree=\"%s\"\n",
+                          variable, constant, typedefnode,
+                          tree->value.element.name);
+#endif /* DEBUG */
+
+                  if (variable)
+                  {
+                    if (strstr(buffer, "@private@"))
+                    {
+                     /*
+                      * Delete private variables...
+                      */
+
+                      mxmlDelete(variable);
+                    }
+                    else
+                    {
+                      description = mxmlNewElement(variable, "description");
+#ifdef DEBUG
+                      fprintf(stderr, "    adding comment %p/%p to variable...\n",
+                              comment->last_child, comment->child);
+#endif /* DEBUG */
+                      mxmlNewText(comment, 0, buffer);
+                      update_comment(variable,
+                                     mxmlNewText(description, 0, buffer));
+                    }
+
+                    variable = NULL;
+                  }
+                  else if (constant)
+                  {
+                    if (strstr(buffer, "@private@"))
+                    {
+                     /*
+                      * Delete private constants...
+                      */
+
+                      mxmlDelete(constant);
+                    }
+                    else
+                    {
+                      description = mxmlNewElement(constant, "description");
+#ifdef DEBUG
+                      fprintf(stderr, "    adding comment %p/%p to constant...\n",
+                              comment->last_child, comment->child);
+#endif /* DEBUG */
+                      mxmlNewText(comment, 0, buffer);
+                      update_comment(constant,
+                                     mxmlNewText(description, 0, buffer));
+                    }
+
+                    constant = NULL;
+                  }
+                  else if (typedefnode)
+                  {
+                    if (strstr(buffer, "@private@"))
+                    {
+                     /*
+                      * Delete private typedefs...
+                      */
+
+                      mxmlDelete(typedefnode);
+
+                      if (structclass)
+                      {
+                        mxmlDelete(structclass);
+                        structclass = NULL;
+                      }
+
+                      if (enumeration)
+                      {
+                        mxmlDelete(enumeration);
+                        enumeration = NULL;
+                      }
+                    }
+                    else
+                    {
+                      description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+                      fprintf(stderr,
+                              "    adding comment %p/%p to typedef %s...\n",
+                              comment->last_child, comment->child,
+                              mxmlElementGetAttr(typedefnode, "name"));
+#endif /* DEBUG */
+                      mxmlNewText(comment, 0, buffer);
+                      update_comment(typedefnode,
+                                     mxmlNewText(description, 0, buffer));
+
+                      if (structclass)
+                      {
+                        description = mxmlNewElement(structclass, "description");
+                        update_comment(structclass,
+                                       mxmlNewText(description, 0, buffer));
+                      }
+                      else if (enumeration)
+                      {
+                        description = mxmlNewElement(enumeration, "description");
+                        update_comment(enumeration,
+                                       mxmlNewText(description, 0, buffer));
+                      }
+                    }
+
+                    typedefnode = NULL;
+                  }
+                  else if (strcmp(tree->value.element.name, "mxmldoc") &&
+                           !mxmlFindElement(tree, tree, "description",
+                                            NULL, NULL, MXML_DESCEND_FIRST))
+                  {
+                    description = mxmlNewElement(tree, "description");
+#ifdef DEBUG
+                    fprintf(stderr, "    adding comment %p/%p to parent...\n",
+                            comment->last_child, comment->child);
+#endif /* DEBUG */
+                    mxmlNewText(comment, 0, buffer);
+                    update_comment(tree,
+                                   mxmlNewText(description, 0, buffer));
+                  }
+                  else
+                    mxmlNewText(comment, 0, buffer);
+
+#ifdef DEBUG
+                  fprintf(stderr, "C comment: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+                  state = STATE_NONE;
+                  break;
+                }
+
+            default :
+                if (ch == ' ' && bufptr == buffer)
+                  break;
+
+                if (bufptr < (buffer + sizeof(buffer) - 1))
+                  *bufptr++ = ch;
+                break;
+          }
+          break;
+
+      case STATE_CXX_COMMENT :          /* Inside a C++ comment */
+          if (ch == '\n')
+          {
+            state = STATE_NONE;
+            *bufptr = '\0';
+
+            if (comment->child != comment->last_child)
+            {
+#ifdef DEBUG
+              fprintf(stderr, "    removing comment %p(%20.20s), last comment %p(%20.20s)...\n",
+                      comment->child,
+                      comment->child ? comment->child->value.text.string : "",
+                      comment->last_child,
+                      comment->last_child ? comment->last_child->value.text.string : "");
+#endif /* DEBUG */
+              mxmlDelete(comment->child);
+#ifdef DEBUG
+              fprintf(stderr, "    new comment %p, last comment %p...\n",
+                      comment->child, comment->last_child);
+#endif /* DEBUG */
+            }
+
+            if (variable)
+            {
+              if (strstr(buffer, "@private@"))
+              {
+               /*
+                * Delete private variables...
+                */
+
+                mxmlDelete(variable);
+              }
+              else
+              {
+                description = mxmlNewElement(variable, "description");
+#ifdef DEBUG
+                fprintf(stderr, "    adding comment %p/%p to variable...\n",
+                        comment->last_child, comment->child);
+#endif /* DEBUG */
+                mxmlNewText(comment, 0, buffer);
+                update_comment(variable,
+                               mxmlNewText(description, 0, buffer));
+              }
+
+              variable = NULL;
+            }
+            else if (constant)
+            {
+              if (strstr(buffer, "@private@"))
+              {
+               /*
+                * Delete private constants...
+                */
+
+                mxmlDelete(constant);
+              }
+              else
+              {
+                description = mxmlNewElement(constant, "description");
+#ifdef DEBUG
+                fprintf(stderr, "    adding comment %p/%p to constant...\n",
+                        comment->last_child, comment->child);
+#endif /* DEBUG */
+                mxmlNewText(comment, 0, buffer);
+                update_comment(constant,
+                               mxmlNewText(description, 0, buffer));
+              }
+
+              constant = NULL;
+            }
+            else if (typedefnode)
+            {
+              if (strstr(buffer, "@private@"))
+              {
+               /*
+                * Delete private typedefs...
+                */
+
+                mxmlDelete(typedefnode);
+                typedefnode = NULL;
+
+                if (structclass)
+                {
+                  mxmlDelete(structclass);
+                  structclass = NULL;
+                }
+
+                if (enumeration)
+                {
+                  mxmlDelete(enumeration);
+                  enumeration = NULL;
+                }
+              }
+              else
+              {
+                description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+                fprintf(stderr, "    adding comment %p/%p to typedef %s...\n",
+                        comment->last_child, comment->child,
+                        mxmlElementGetAttr(typedefnode, "name"));
+#endif /* DEBUG */
+                mxmlNewText(comment, 0, buffer);
+                update_comment(typedefnode,
+                               mxmlNewText(description, 0, buffer));
+
+                if (structclass)
+                {
+                  description = mxmlNewElement(structclass, "description");
+                  update_comment(structclass,
+                                 mxmlNewText(description, 0, buffer));
+                }
+                else if (enumeration)
+                {
+                  description = mxmlNewElement(enumeration, "description");
+                  update_comment(enumeration,
+                                 mxmlNewText(description, 0, buffer));
+                }
+              }
+            }
+            else if (strcmp(tree->value.element.name, "mxmldoc") &&
+                     !mxmlFindElement(tree, tree, "description",
+                                      NULL, NULL, MXML_DESCEND_FIRST))
+            {
+              description = mxmlNewElement(tree, "description");
+#ifdef DEBUG
+              fprintf(stderr, "    adding comment %p/%p to parent...\n",
+                      comment->last_child, comment->child);
+#endif /* DEBUG */
+              mxmlNewText(comment, 0, buffer);
+              update_comment(tree,
+                             mxmlNewText(description, 0, buffer));
+            }
+            else
+              mxmlNewText(comment, 0, buffer);
+
+#ifdef DEBUG
+            fprintf(stderr, "C++ comment: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+          }
+          else if (ch == ' ' && bufptr == buffer)
+            break;
+          else if (bufptr < (buffer + sizeof(buffer) - 1))
+            *bufptr++ = ch;
+          break;
+
+      case STATE_STRING :               /* Inside a string constant */
+          *bufptr++ = ch;
+
+          if (ch == '\\')
+            *bufptr++ = getc(fp);
+          else if (ch == '\"')
+          {
+            *bufptr = '\0';
+
+            if (type)
+              mxmlNewText(type, type->child != NULL, buffer);
+
+            state = STATE_NONE;
+          }
+          break;
+
+      case STATE_CHARACTER :            /* Inside a character constant */
+          *bufptr++ = ch;
+
+          if (ch == '\\')
+            *bufptr++ = getc(fp);
+          else if (ch == '\'')
+          {
+            *bufptr = '\0';
+
+            if (type)
+              mxmlNewText(type, type->child != NULL, buffer);
+
+            state = STATE_NONE;
+          }
+          break;
+
+      case STATE_IDENTIFIER :           /* Inside a keyword or identifier */
+          if (isalnum(ch) || ch == '_' || ch == '[' || ch == ']' ||
+              (ch == ',' && (parens > 1 || (type && !enumeration && !function))) ||
+              ch == ':' || ch == '.' || ch == '~')
+          {
+            if (bufptr < (buffer + sizeof(buffer) - 1))
+              *bufptr++ = ch;
+          }
+          else
+          {
+            ungetc(ch, fp);
+            *bufptr = '\0';
+            state   = STATE_NONE;
+
+#ifdef DEBUG
+            fprintf(stderr, "    braces=%d, type=%p, type->child=%p, buffer=\"%s\"\n",
+                    braces, type, type ? type->child : NULL, buffer);
+#endif /* DEBUG */
+
+            if (!braces)
+            {
+              if (!type || !type->child)
+              {
+                if (!strcmp(tree->value.element.name, "class"))
+                {
+                  if (!strcmp(buffer, "public") ||
+                      !strcmp(buffer, "public:"))
+                  {
+                    scope = "public";
+#ifdef DEBUG
+                    fputs("    scope = public\n", stderr);
+#endif /* DEBUG */
+                    break;
+                  }
+                  else if (!strcmp(buffer, "private") ||
+                           !strcmp(buffer, "private:"))
+                  {
+                    scope = "private";
+#ifdef DEBUG
+                    fputs("    scope = private\n", stderr);
+#endif /* DEBUG */
+                    break;
+                  }
+                  else if (!strcmp(buffer, "protected") ||
+                           !strcmp(buffer, "protected:"))
+                  {
+                    scope = "protected";
+#ifdef DEBUG
+                    fputs("    scope = protected\n", stderr);
+#endif /* DEBUG */
+                    break;
+                  }
+                }
+              }
+
+              if (!type)
+                type = mxmlNewElement(MXML_NO_PARENT, "type");
+
+#ifdef DEBUG
+              fprintf(stderr, "    function=%p (%s), type->child=%p, ch='%c', parens=%d\n",
+                      function,
+                      function ? mxmlElementGetAttr(function, "name") : "null",
+                      type->child, ch, parens);
+#endif /* DEBUG */
+
+              if (!function && ch == '(')
+              {
+                if (type->child &&
+                    !strcmp(type->child->value.text.string, "extern"))
+                {
+                 /*
+                  * Remove external declarations...
+                  */
+
+                  mxmlDelete(type);
+                  type = NULL;
+                  break;
+                }
+
+                if (type->child &&
+                    !strcmp(type->child->value.text.string, "static") &&
+                    !strcmp(tree->value.element.name, "mxmldoc"))
+                {
+                 /*
+                  * Remove static functions...
+                  */
+
+                  mxmlDelete(type);
+                  type = NULL;
+                  break;
+                }
+
+                function = mxmlNewElement(MXML_NO_PARENT, "function");
+                if ((bufptr = strchr(buffer, ':')) != NULL && bufptr[1] == ':')
+                {
+                  *bufptr = '\0';
+                  bufptr += 2;
+
+                  if ((fstructclass =
+                           mxmlFindElement(tree, tree, "class", "name", buffer,
+                                           MXML_DESCEND_FIRST)) == NULL)
+                    fstructclass =
+                        mxmlFindElement(tree, tree, "struct", "name", buffer,
+                                        MXML_DESCEND_FIRST);
+                }
+                else
+                  bufptr = buffer;
+
+                mxmlElementSetAttr(function, "name", bufptr);
+
+                if (scope)
+                  mxmlElementSetAttr(function, "scope", scope);
+
+#ifdef DEBUG
+                fprintf(stderr, "function: %s\n", buffer);
+                fprintf(stderr, "    scope = %s\n", scope ? scope : "(null)");
+                fprintf(stderr, "    comment = %p\n", comment);
+                fprintf(stderr, "    child = (%p) %s\n",
+                        comment->child,
+                        comment->child ?
+                            comment->child->value.text.string : "(null)");
+                fprintf(stderr, "    last_child = (%p) %s\n",
+                        comment->last_child,
+                        comment->last_child ?
+                            comment->last_child->value.text.string : "(null)");
+#endif /* DEBUG */
+
+                if (type->last_child &&
+                    strcmp(type->last_child->value.text.string, "void"))
+                {
+                  returnvalue = mxmlNewElement(function, "returnvalue");
+
+                  mxmlAdd(returnvalue, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, type);
+
+                  description = mxmlNewElement(returnvalue, "description");
+#ifdef DEBUG
+                  fprintf(stderr, "    adding comment %p/%p to returnvalue...\n",
+                          comment->last_child, comment->child);
+#endif /* DEBUG */
+                  update_comment(returnvalue, comment->last_child);
+                  mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                          comment->last_child);
+                }
+                else
+                  mxmlDelete(type);
+
+                description = mxmlNewElement(function, "description");
+#ifdef DEBUG
+                  fprintf(stderr, "    adding comment %p/%p to function...\n",
+                          comment->last_child, comment->child);
+#endif /* DEBUG */
+                update_comment(function, comment->last_child);
+                mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+                        comment->last_child);
+
+                type = NULL;
+              }
+              else if (function && ((ch == ')' && parens == 1) || ch == ','))
+              {
+               /*
+                * Argument definition...
+                */
+
+                if (strcmp(buffer, "void"))
+                {
+                  mxmlNewText(type, type->child != NULL &&
+                                    type->last_child->value.text.string[0] != '(' &&
+                                    type->last_child->value.text.string[0] != '*',
+                              buffer);
+
+#ifdef DEBUG
+                  fprintf(stderr, "Argument: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+                  variable = add_variable(function, "argument", type);
+                }
+                else
+                  mxmlDelete(type);
+
+                type = NULL;
+              }
+              else if (type->child && !function && (ch == ';' || ch == ','))
+              {
+#ifdef DEBUG
+                fprintf(stderr, "    got semicolon, typedefnode=%p, structclass=%p\n",
+                        typedefnode, structclass);
+#endif /* DEBUG */
+
+                if (typedefnode || structclass)
+                {
+#ifdef DEBUG
+                  fprintf(stderr, "Typedef/struct/class: <<<< %s >>>>\n", buffer);
+#endif /* DEBUG */
+
+                  if (typedefnode)
+                  {
+                    mxmlElementSetAttr(typedefnode, "name", buffer);
+
+                    sort_node(tree, typedefnode);
+                  }
+
+                  if (structclass && !mxmlElementGetAttr(structclass, "name"))
+                  {
+#ifdef DEBUG
+                    fprintf(stderr, "setting struct/class name to %s!\n",
+                            type->last_child->value.text.string);
+#endif /* DEBUG */
+                    mxmlElementSetAttr(structclass, "name", buffer);
+
+                    sort_node(tree, structclass);
+                    structclass = NULL;
+                  }
+
+                  if (typedefnode)
+                    mxmlAdd(typedefnode, MXML_ADD_BEFORE, MXML_ADD_TO_PARENT,
+                            type);
+                  else
+                    mxmlDelete(type);
+
+                  type        = NULL;
+                  typedefnode = NULL;
+                }
+                else if (type->child &&
+                         !strcmp(type->child->value.text.string, "typedef"))
+                {
+                 /*
+                  * Simple typedef...
+                  */
+
+#ifdef DEBUG
+                  fprintf(stderr, "Typedef: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+                  typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+                  mxmlElementSetAttr(typedefnode, "name", buffer);
+                  mxmlDelete(type->child);
+
+                  sort_node(tree, typedefnode);
+
+                  if (type->child)
+                    type->child->value.text.whitespace = 0;
+
+                  mxmlAdd(typedefnode, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, type);
+                  type = NULL;
+                }
+                else if (!parens)
+                {
+                 /*
+                  * Variable definition...
+                  */
+
+                  if (type->child &&
+                      !strcmp(type->child->value.text.string, "static") &&
+                      !strcmp(tree->value.element.name, "mxmldoc"))
+                  {
+                   /*
+                    * Remove static functions...
+                    */
+
+                    mxmlDelete(type);
+                    type = NULL;
+                    break;
+                  }
+
+                  mxmlNewText(type, type->child != NULL &&
+                                    type->last_child->value.text.string[0] != '(' &&
+                                    type->last_child->value.text.string[0] != '*',
+                              buffer);
+
+#ifdef DEBUG
+                  fprintf(stderr, "Variable: <<<< %s >>>>\n", buffer);
+                  fprintf(stderr, "    scope = %s\n", scope ? scope : "(null)");
+#endif /* DEBUG */
+
+                  variable = add_variable(MXML_NO_PARENT, "variable", type);
+                  type     = NULL;
+
+                  sort_node(tree, variable);
+
+                  if (scope)
+                    mxmlElementSetAttr(variable, "scope", scope);
+                }
+              }
+              else
+              {
+#ifdef DEBUG
+                fprintf(stderr, "Identifier: <<<< %s >>>>\n", buffer);
+#endif /* DEBUG */
+
+                mxmlNewText(type, type->child != NULL &&
+                                  type->last_child->value.text.string[0] != '(' &&
+                                  type->last_child->value.text.string[0] != '*',
+                            buffer);
+              }
+            }
+            else if (enumeration && !isdigit(buffer[0] & 255))
+            {
+#ifdef DEBUG
+              fprintf(stderr, "Constant: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+              constant = mxmlNewElement(MXML_NO_PARENT, "constant");
+              mxmlElementSetAttr(constant, "name", buffer);
+              sort_node(enumeration, constant);
+            }
+            else if (type)
+            {
+              mxmlDelete(type);
+              type = NULL;
+            }
+          }
+          break;
+    }
+
+#if DEBUG > 1
+    if (state != oldstate)
+    {
+      fprintf(stderr, "    changed states from %s to %s on receipt of character '%c'...\n",
+              states[oldstate], states[state], oldch);
+      fprintf(stderr, "    variable = %p\n", variable);
+      if (type)
+      {
+        fputs("    type =", stderr);
+        for (temp = type->child; temp; temp = temp->next)
+          fprintf(stderr, " \"%s\"", temp->value.text.string);
+        fputs("\n", stderr);
+      }
+    }
+#endif /* DEBUG > 1 */
+  }
+
+  mxmlDelete(comment);
+
+ /*
+  * All done, return with no errors...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'sort_node()' - Insert a node sorted into a tree.
+ */
+
+static void
+sort_node(mxml_node_t *tree,            /* I - Tree to sort into */
+          mxml_node_t *node)            /* I - Node to add */
+{
+  mxml_node_t   *temp;                  /* Current node */
+  const char    *tempname,              /* Name of current node */
+                *nodename,              /* Name of node */
+                *scope;                 /* Scope */
+
+
+#if DEBUG > 1
+  fprintf(stderr, "    sort_node(tree=%p, node=%p)\n", tree, node);
+#endif /* DEBUG > 1 */
+
+ /*
+  * Range check input...
+  */
+
+  if (!tree || !node || node->parent == tree)
+    return;
+
+ /*
+  * Get the node name...
+  */
+
+  if ((nodename = mxmlElementGetAttr(node, "name")) == NULL)
+    return;
+
+  if (nodename[0] == '_')
+    return;                             /* Hide private names */
+
+#if DEBUG > 1
+  fprintf(stderr, "        nodename=%p (\"%s\")\n", nodename, nodename);
+#endif /* DEBUG > 1 */
+
+ /*
+  * Delete any existing definition at this level, if one exists...
+  */
+
+  if ((temp = mxmlFindElement(tree, tree, node->value.element.name,
+                              "name", nodename, MXML_DESCEND_FIRST)) != NULL)
+  {
+   /*
+    * Copy the scope if needed...
+    */
+
+    if ((scope = mxmlElementGetAttr(temp, "scope")) != NULL &&
+        mxmlElementGetAttr(node, "scope") == NULL)
+    {
+#ifdef DEBUG
+      fprintf(stderr, "    copying scope %s for %s\n", scope, nodename);
+#endif /* DEBUG */
+
+      mxmlElementSetAttr(node, "scope", scope);
+    }
+
+    mxmlDelete(temp);
+  }
+
+ /*
+  * Add the node into the tree at the proper place...
+  */
+
+  for (temp = tree->child; temp; temp = temp->next)
+  {
+#if DEBUG > 1
+    fprintf(stderr, "        temp=%p\n", temp);
+#endif /* DEBUG > 1 */
+
+    if ((tempname = mxmlElementGetAttr(temp, "name")) == NULL)
+      continue;
+
+#if DEBUG > 1
+    fprintf(stderr, "        tempname=%p (\"%s\")\n", tempname, tempname);
+#endif /* DEBUG > 1 */
+
+    if (strcmp(nodename, tempname) < 0)
+      break;
+  }
+
+  if (temp)
+    mxmlAdd(tree, MXML_ADD_BEFORE, temp, node);
+  else
+    mxmlAdd(tree, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);
+}
+
+
+/*
+ * 'update_comment()' - Update a comment node.
+ */
+
+static void
+update_comment(mxml_node_t *parent,     /* I - Parent node */
+               mxml_node_t *comment)    /* I - Comment node */
+{
+  char  *ptr;                           /* Pointer into comment */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "update_comment(parent=%p, comment=%p)\n",
+          parent, comment);
+#endif /* DEBUG */
+
+ /*
+  * Range check the input...
+  */
+
+  if (!parent || !comment)
+    return;
+
+ /*
+  * Convert "\/" to "/"...
+  */
+
+  for (ptr = strstr(comment->value.text.string, "\\/");
+       ptr;
+       ptr = strstr(ptr, "\\/"))
+    safe_strcpy(ptr, ptr + 1);
+
+ /*
+  * Update the comment...
+  */
+
+  ptr = comment->value.text.string;
+
+  if (*ptr == '\'')
+  {
+   /*
+    * Convert "'name()' - description" to "description".
+    */
+
+    for (ptr ++; *ptr && *ptr != '\''; ptr ++);
+
+    if (*ptr == '\'')
+    {
+      ptr ++;
+      while (isspace(*ptr & 255))
+        ptr ++;
+
+      if (*ptr == '-')
+        ptr ++;
+
+      while (isspace(*ptr & 255))
+        ptr ++;
+
+      safe_strcpy(comment->value.text.string, ptr);
+    }
+  }
+  else if (!strncmp(ptr, "I ", 2) || !strncmp(ptr, "O ", 2) ||
+           !strncmp(ptr, "IO ", 3))
+  {
+   /*
+    * 'Convert "I - description", "IO - description", or "O - description"
+    * to description + direction attribute.
+    */
+
+    ptr = strchr(ptr, ' ');
+    *ptr++ = '\0';
+
+    if (!strcmp(parent->value.element.name, "argument"))
+      mxmlElementSetAttr(parent, "direction", comment->value.text.string);
+
+    while (isspace(*ptr & 255))
+      ptr ++;
+
+    if (*ptr == '-')
+      ptr ++;
+
+    while (isspace(*ptr & 255))
+      ptr ++;
+
+    safe_strcpy(comment->value.text.string, ptr);
+  }
+
+ /*
+  * Eliminate leading and trailing *'s...
+  */
+
+  for (ptr = comment->value.text.string; *ptr == '*'; ptr ++);
+  for (; isspace(*ptr & 255); ptr ++);
+  if (ptr > comment->value.text.string)
+    safe_strcpy(comment->value.text.string, ptr);
+
+  for (ptr = comment->value.text.string + strlen(comment->value.text.string) - 1;
+       ptr > comment->value.text.string && *ptr == '*';
+       ptr --)
+    *ptr = '\0';
+  for (; ptr > comment->value.text.string && isspace(*ptr & 255); ptr --)
+    *ptr = '\0';
+
+#ifdef DEBUG
+  fprintf(stderr, "    updated comment = %s\n", comment->value.text.string);
+#endif /* DEBUG */
+}
+
+
+/*
+ * 'usage()' - Show program usage...
+ */
+
+static void
+usage(const char *option)               /* I - Unknown option */
+{
+  if (option)
+    printf("mxmldoc: Bad option \"%s\"!\n\n", option);
+
+  puts("Usage: mxmldoc [options] [filename.xml] [source files] >filename.html");
+  puts("Options:");
+  puts("    --css filename.css         Set CSS stylesheet file");
+  puts("    --docset bundleid.docset   Generate documentation set");
+  puts("    --docversion version       Set documentation version");
+  puts("    --feedname name            Set documentation set feed name");
+  puts("    --feedurl url              Set documentation set feed URL");
+  puts("    --footer footerfile        Set footer file");
+  puts("    --framed basename          Generate framed HTML to basename*.html");
+  puts("    --header headerfile        Set header file");
+  puts("    --intro introfile          Set introduction file");
+  puts("    --man name                 Generate man page");
+  puts("    --no-output                Do no generate documentation file");
+  puts("    --section section          Set section name");
+  puts("    --title title              Set documentation title");
+  puts("    --tokens path              Generate Xcode docset Tokens.xml file");
+  puts("    --version                  Show mxmldoc/Mini-XML version");
+
+  exit(1);
+}
+
+
+/*
+ * 'write_description()' - Write the description text.
+ */
+
+static void
+write_description(
+    FILE        *out,                   /* I - Output file */
+    mxml_node_t *description,           /* I - Description node */
+    const char  *element,               /* I - HTML element, if any */
+    int         summary)                /* I - Show summary */
+{
+  char  text[10240],                    /* Text for description */
+        *start,                         /* Start of code/link */
+        *ptr;                           /* Pointer into text */
+  int   col;                            /* Current column */
+
+
+  if (!description)
+    return;
+
+  get_text(description, text, sizeof(text));
+
+  ptr = strstr(text, "\n\n");
+
+  if (summary)
+  {
+    if (ptr)
+      *ptr = '\0';
+
+    ptr = text;
+  }
+  else if (!ptr || !ptr[2])
+    return;
+  else
+    ptr += 2;
+
+  if (element && *element)
+    fprintf(out, "<%s class=\"%s\">", element,
+            summary ? "description" : "discussion");
+  else if (!summary)
+    fputs(".PP\n", out);
+
+  for (col = 0; *ptr; ptr ++)
+  {
+    if (*ptr == '@' &&
+        (!strncmp(ptr + 1, "deprecated@", 11) ||
+         !strncmp(ptr + 1, "since ", 6)))
+    {
+      ptr ++;
+      while (*ptr && *ptr != '@')
+        ptr ++;
+
+      if (!*ptr)
+        return;
+    }
+    else if (!strncmp(ptr, "@code ", 6))
+    {
+      for (ptr += 6; isspace(*ptr & 255); ptr ++);
+
+      for (start = ptr, ptr ++; *ptr && *ptr != '@'; ptr ++);
+
+      if (*ptr)
+        *ptr = '\0';
+      else
+        ptr --;
+
+      if (element && *element)
+        fprintf(out, "<code>%s</code>", start);
+      else if (element)
+        fputs(start, out);
+      else
+        fprintf(out, "\\fB%s\\fR", start);
+    }
+    else if (!strncmp(ptr, "@link ", 6))
+    {
+      for (ptr += 6; isspace(*ptr & 255); ptr ++);
+
+      for (start = ptr, ptr ++; *ptr && *ptr != '@'; ptr ++);
+
+      if (*ptr)
+        *ptr = '\0';
+      else
+        ptr --;
+
+      if (element && *element)
+        fprintf(out, "<a href=\"#%s\"><code>%s</code></a>", start, start);
+      else if (element)
+        fputs(start, out);
+      else
+        fprintf(out, "\\fI%s\\fR", start);
+    }
+    else if (element)
+    {
+      if (*ptr == '&')
+        fputs("&amp;", out);
+      else if (*ptr == '<')
+        fputs("&lt;", out);
+      else if (*ptr == '>')
+        fputs("&gt;", out);
+      else if (*ptr == '\"')
+        fputs("&quot;", out);
+      else if (*ptr & 128)
+      {
+       /*
+        * Convert UTF-8 to Unicode constant...
+        */
+
+        int     ch;                     /* Unicode character */
+
+
+        ch = *ptr & 255;
+
+        if ((ch & 0xe0) == 0xc0)
+        {
+          ch = ((ch & 0x1f) << 6) | (ptr[1] & 0x3f);
+          ptr ++;
+        }
+        else if ((ch & 0xf0) == 0xe0)
+        {
+          ch = ((((ch * 0x0f) << 6) | (ptr[1] & 0x3f)) << 6) | (ptr[2] & 0x3f);
+          ptr += 2;
+        }
+
+        if (ch == 0xa0)
+        {
+         /*
+          * Handle non-breaking space as-is...
+          */
+
+          fputs("&nbsp;", out);
+        }
+        else
+          fprintf(out, "&#x%x;", ch);
+      }
+      else if (*ptr == '\n' && ptr[1] == '\n' && ptr[2] && ptr[2] != '@')
+      {
+        fputs("<br>\n<br>\n", out);
+        ptr ++;
+      }
+      else
+        putc(*ptr, out);
+    }
+    else if (*ptr == '\n' && ptr[1] == '\n' && ptr[2] && ptr[2] != '@')
+    {
+      fputs("\n.PP\n", out);
+      ptr ++;
+    }
+    else
+    {
+      if (*ptr == '\\' || (*ptr == '.' && col == 0))
+        putc('\\', out);
+
+      putc(*ptr, out);
+
+      if (*ptr == '\n')
+        col = 0;
+      else
+        col ++;
+    }
+  }
+
+  if (element && *element)
+    fprintf(out, "</%s>\n", element);
+  else if (!element)
+    putc('\n', out);
+}
+
+
+/*
+ * 'write_element()' - Write an element's text nodes.
+ */
+
+static void
+write_element(FILE        *out,         /* I - Output file */
+              mxml_node_t *doc,         /* I - Document tree */
+              mxml_node_t *element,     /* I - Element to write */
+              int         mode)         /* I - Output mode */
+{
+  mxml_node_t   *node;                  /* Current node */
+
+
+  if (!element)
+    return;
+
+  for (node = element->child;
+       node;
+       node = mxmlWalkNext(node, element, MXML_NO_DESCEND))
+    if (node->type == MXML_TEXT)
+    {
+      if (node->value.text.whitespace)
+        putc(' ', out);
+
+      if (mode == OUTPUT_HTML &&
+          (mxmlFindElement(doc, doc, "class", "name", node->value.text.string,
+                           MXML_DESCEND) ||
+           mxmlFindElement(doc, doc, "enumeration", "name",
+                           node->value.text.string, MXML_DESCEND) ||
+           mxmlFindElement(doc, doc, "struct", "name", node->value.text.string,
+                           MXML_DESCEND) ||
+           mxmlFindElement(doc, doc, "typedef", "name", node->value.text.string,
+                           MXML_DESCEND) ||
+           mxmlFindElement(doc, doc, "union", "name", node->value.text.string,
+                           MXML_DESCEND)))
+      {
+        fputs("<a href=\"#", out);
+        write_string(out, node->value.text.string, mode);
+        fputs("\">", out);
+        write_string(out, node->value.text.string, mode);
+        fputs("</a>", out);
+      }
+      else
+        write_string(out, node->value.text.string, mode);
+    }
+
+  if (!strcmp(element->value.element.name, "type") &&
+      element->last_child->value.text.string[0] != '*')
+    putc(' ', out);
+}
+
+
+/*
+ * 'write_file()' - Copy a file to the output.
+ */
+
+static void
+write_file(FILE       *out,             /* I - Output file */
+           const char *file)            /* I - File to copy */
+{
+  FILE          *fp;                    /* Copy file */
+  char          line[8192];             /* Line from file */
+
+
+  if ((fp = fopen(file, "r")) == NULL)
+  {
+    fprintf(stderr, "mxmldoc: Unable to open \"%s\": %s\n", file,
+            strerror(errno));
+    return;
+  }
+
+  while (fgets(line, sizeof(line), fp))
+    fputs(line, out);
+
+  fclose(fp);
+}
+
+
+/*
+ * 'write_function()' - Write documentation for a function.
+ */
+
+static void
+write_function(FILE        *out,        /* I - Output file */
+               mxml_node_t *doc,        /* I - Document */
+               mxml_node_t *function,   /* I - Function */
+               int         level)       /* I - Base heading level */
+{
+  mxml_node_t   *arg,                   /* Current argument */
+                *adesc,                 /* Description of argument */
+                *description,           /* Description of function */
+                *type,                  /* Type for argument */
+                *node;                  /* Node in description */
+  const char    *name,                  /* Name of function/type */
+                *defval;                /* Default value */
+  char          prefix;                 /* Prefix character */
+  char          *sep;                   /* Newline separator */
+
+
+  name        = mxmlElementGetAttr(function, "name");
+  description = mxmlFindElement(function, function, "description", NULL,
+                                NULL, MXML_DESCEND_FIRST);
+
+  fprintf(out, "<h%d class=\"%s\">%s<a name=\"%s\">%s</a></h%d>\n",
+          level, level == 3 ? "function" : "method",
+          get_comment_info(description), name, name, level);
+
+  if (description)
+    write_description(out, description, "p", 1);
+
+  fputs("<p class=\"code\">\n", out);
+
+  arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                        NULL, MXML_DESCEND_FIRST);
+
+  if (arg)
+    write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                            NULL, MXML_DESCEND_FIRST),
+                  OUTPUT_HTML);
+  else
+    fputs("void ", out);
+
+  fprintf(out, "%s ", name);
+  for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                             MXML_DESCEND_FIRST), prefix = '(';
+       arg;
+       arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                             MXML_NO_DESCEND), prefix = ',')
+  {
+    type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                           MXML_DESCEND_FIRST);
+
+    fprintf(out, "%c<br>\n&nbsp;&nbsp;&nbsp;&nbsp;", prefix);
+    if (type->child)
+      write_element(out, doc, type, OUTPUT_HTML);
+
+    fputs(mxmlElementGetAttr(arg, "name"), out);
+    if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+      fprintf(out, " %s", defval);
+  }
+
+  if (prefix == '(')
+    fputs("(void);</p>\n", out);
+  else
+  {
+    fprintf(out,
+            "<br>\n);</p>\n"
+            "<h%d class=\"parameters\">Parameters</h%d>\n"
+            "<dl>\n", level + 1, level + 1);
+
+    for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                               MXML_DESCEND_FIRST);
+         arg;
+         arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                               MXML_NO_DESCEND))
+    {
+      fprintf(out, "<dt>%s</dt>\n", mxmlElementGetAttr(arg, "name"));
+
+      adesc = mxmlFindElement(arg, arg, "description", NULL, NULL,
+                              MXML_DESCEND_FIRST);
+
+      write_description(out, adesc, "dd", 1);
+      write_description(out, adesc, "dd", 0);
+    }
+
+    fputs("</dl>\n", out);
+  }
+
+  arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                        NULL, MXML_DESCEND_FIRST);
+
+  if (arg)
+  {
+    fprintf(out, "<h%d class=\"returnvalue\">Return Value</h%d>\n", level + 1,
+            level + 1);
+
+    adesc = mxmlFindElement(arg, arg, "description", NULL, NULL,
+                            MXML_DESCEND_FIRST);
+
+    write_description(out, adesc, "p", 1);
+    write_description(out, adesc, "p", 0);
+  }
+
+  if (description)
+  {
+    for (node = description->child; node; node = node->next)
+      if (node->value.text.string &&
+          (sep = strstr(node->value.text.string, "\n\n")) != NULL)
+      {
+        sep += 2;
+        if (*sep && strncmp(sep, "@since ", 7) &&
+            strncmp(sep, "@deprecated@", 12))
+          break;
+      }
+
+    if (node)
+    {
+      fprintf(out, "<h%d class=\"discussion\">Discussion</h%d>\n", level + 1,
+              level + 1);
+      write_description(out, description, "p", 0);
+    }
+  }
+}
+
+
+/*
+ * 'write_html()' - Write HTML documentation.
+ */
+
+static void
+write_html(const char  *section,        /* I - Section */
+           const char  *title,          /* I - Title */
+           const char  *footerfile,     /* I - Footer file */
+           const char  *headerfile,     /* I - Header file */
+           const char  *introfile,      /* I - Intro file */
+           const char  *cssfile,        /* I - Stylesheet file */
+           const char  *framefile,      /* I - Framed HTML basename */
+           const char  *docset,         /* I - Documentation set directory */
+           const char  *docversion,     /* I - Documentation set version */
+           const char  *feedname,       /* I - Feed name for doc set */
+           const char  *feedurl,        /* I - Feed URL for doc set */
+           mxml_node_t *doc)            /* I - XML documentation */
+{
+  FILE          *out;                   /* Output file */
+  mxml_node_t   *function,              /* Current function */
+                *scut,                  /* Struct/class/union/typedef */
+                *arg,                   /* Current argument */
+                *description,           /* Description of function/var */
+                *type;                  /* Type for argument */
+  const char    *name,                  /* Name of function/type */
+                *defval,                /* Default value */
+                *basename;              /* Base filename for framed output */
+  char          filename[1024];         /* Current output filename */
+
+
+  if (framefile)
+  {
+   /*
+    * Get the basename of the frame file...
+    */
+
+    if ((basename = strrchr(framefile, '/')) != NULL)
+      basename ++;
+    else
+      basename = framefile;
+
+    if (strstr(basename, ".html"))
+      fputs("mxmldoc: Frame base name should not contain .html extension!\n",
+            stderr);
+
+   /*
+    * Create the container HTML file for the frames...
+    */
+
+    snprintf(filename, sizeof(filename), "%s.html", framefile);
+
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    fputs("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\" "
+          "\"http://www.w3.org/TR/html4/frameset.dtd\">\n"
+          "<html>\n"
+          "<head>\n"
+          "\t<title>", out);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</title>\n", out);
+
+    if (section)
+      fprintf(out, "\t<meta name=\"keywords\" content=\"%s\">\n", section);
+
+    fputs("\t<meta http-equiv=\"Content-Type\" "
+          "content=\"text/html;charset=utf-8\">\n"
+          "\t<meta name=\"creator\" content=\"" MXML_VERSION "\">\n"
+          "</head>\n", out);
+
+    fputs("<frameset cols=\"250,*\">\n", out);
+    fprintf(out, "<frame src=\"%s-toc.html\">\n", basename);
+    fprintf(out, "<frame name=\"body\" src=\"%s-body.html\">\n", basename);
+    fputs("</frameset>\n"
+          "<noframes>\n"
+          "<h1>", out);
+    write_string(out, title, OUTPUT_HTML);
+    fprintf(out,
+            "</h1>\n"
+            "<ul>\n"
+            "\t<li><a href=\"%s-toc.html\">Table of Contents</a></li>\n"
+            "\t<li><a href=\"%s-body.html\">Body</a></li>\n"
+            "</ul>\n", basename, basename);
+    fputs("</noframes>\n"
+          "</html>\n", out);
+    fclose(out);
+
+   /*
+    * Write the table-of-contents file...
+    */
+
+    snprintf(filename, sizeof(filename), "%s-toc.html", framefile);
+
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    write_html_head(out, section, title, cssfile);
+
+    snprintf(filename, sizeof(filename), "%s-body.html", basename);
+
+    fputs("<div class=\"contents\">\n", out);
+    fprintf(out, "<h1 class=\"title\"><a href=\"%s\" target=\"body\">",
+            filename);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</a></h1>\n", out);
+
+    write_toc(out, doc, introfile, filename, 0);
+
+    fputs("</div>\n"
+          "</body>\n"
+          "</html>\n", out);
+    fclose(out);
+
+   /*
+    * Finally, open the body file...
+    */
+
+    snprintf(filename, sizeof(filename), "%s-body.html", framefile);
+
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+  }
+  else if (docset)
+  {
+   /*
+    * Create an Xcode documentation set - start by removing any existing
+    * output directory...
+    */
+
+#ifdef __APPLE__
+    const char  *id;                    /* Identifier */
+
+
+    if (!access(docset, 0) && !remove_directory(docset))
+      return;
+
+   /*
+    * Then make the Apple standard bundle directory structure...
+    */
+
+    if (mkdir(docset, 0755))
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", docset,
+              strerror(errno));
+      return;
+    }
+
+    snprintf(filename, sizeof(filename), "%s/Contents", docset);
+    if (mkdir(filename, 0755))
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Resources", docset);
+    if (mkdir(filename, 0755))
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Resources/Documentation",
+             docset);
+    if (mkdir(filename, 0755))
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+   /*
+    * The Info.plist file, which describes the documentation set...
+    */
+
+    if ((id = strrchr(docset, '/')) != NULL)
+      id ++;
+    else
+      id = docset;
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Info.plist", docset);
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+          "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+          "<plist version=\"1.0\">\n"
+          "<dict>\n"
+          "\t<key>CFBundleIdentifier</key>\n"
+          "\t<string>", out);
+    write_string(out, id, OUTPUT_HTML);
+    fputs("</string>\n"
+          "\t<key>CFBundleName</key>\n"
+          "\t<string>", out);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</string>\n"
+          "\t<key>CFBundleVersion</key>\n"
+          "\t<string>", out);
+    write_string(out, docversion ? docversion : "0.0", OUTPUT_HTML);
+    fputs("</string>\n"
+          "\t<key>CFBundleShortVersionString</key>\n"
+          "\t<string>", out);
+    write_string(out, docversion ? docversion : "0.0", OUTPUT_HTML);
+    fputs("</string>\n", out);
+
+    if (feedname)
+    {
+      fputs("\t<key>DocSetFeedName</key>\n"
+            "\t<string>", out);
+      write_string(out, feedname ? feedname : title, OUTPUT_HTML);
+      fputs("</string>\n", out);
+    }
+
+    if (feedurl)
+    {
+      fputs("\t<key>DocSetFeedURL</key>\n"
+            "\t<string>", out);
+      write_string(out, feedurl, OUTPUT_HTML);
+      fputs("</string>\n", out);
+    }
+
+    fputs("</dict>\n"
+          "</plist>\n", out);
+
+    fclose(out);
+
+   /*
+    * Next the Nodes.xml file...
+    */
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Resources/Nodes.xml",
+             docset);
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+          "<DocSetNodes version=\"1.0\">\n"
+          "<TOC>\n"
+          "<Node id=\"0\">\n"
+          "<Name>", out);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</Name>\n"
+          "<Path>Documentation/index.html</Path>\n"
+          "<Subnodes>\n", out);
+
+    write_toc(out, doc, introfile, NULL, 1);
+
+    fputs("</Subnodes>\n"
+          "</Node>\n"
+          "</TOC>\n"
+          "</DocSetNodes>\n", out);
+
+    fclose(out);
+
+   /*
+    * Then the Tokens.xml file...
+    */
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Resources/Tokens.xml",
+             docset);
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+          "<Tokens version=\"1.0\">\n", out);
+
+    write_tokens(out, doc, "index.html");
+
+    fputs("</Tokens>\n", out);
+
+    fclose(out);
+
+   /*
+    * Finally the HTML file...
+    */
+
+    snprintf(filename, sizeof(filename),
+             "%s/Contents/Resources/Documentation/index.html",
+             docset);
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+#else
+    fputs("mxmldoc: Xcode documentation sets can only be created on "
+          "Mac OS X.\n", stderr);
+    return;
+#endif /* __APPLE__ */
+  }
+  else
+    out = stdout;
+
+ /*
+  * Standard header...
+  */
+
+  write_html_head(out, section, title, cssfile);
+
+  fputs("<div class='body'>\n", out);
+
+ /*
+  * Header...
+  */
+
+  if (headerfile)
+  {
+   /*
+    * Use custom header...
+    */
+
+    write_file(out, headerfile);
+  }
+  else
+  {
+   /*
+    * Use standard header...
+    */
+
+    fputs("<h1 class=\"title\">", out);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</h1>\n", out);
+  }
+
+ /*
+  * Table of contents...
+  */
+
+  if (!framefile)
+    write_toc(out, doc, introfile, NULL, 0);
+
+ /*
+  * Intro...
+  */
+
+  if (introfile)
+    write_file(out, introfile);
+
+ /*
+  * List of classes...
+  */
+
+  if ((scut = find_public(doc, doc, "class")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"CLASSES\">Classes</a></h2>\n", out);
+
+    while (scut)
+    {
+      write_scu(out, doc, scut);
+
+      scut = find_public(scut, doc, "class");
+    }
+  }
+
+ /*
+  * List of functions...
+  */
+
+  if ((function = find_public(doc, doc, "function")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"FUNCTIONS\">Functions</a></h2>\n", out);
+
+    while (function)
+    {
+      write_function(out, doc, function, 3);
+
+      function = find_public(function, doc, "function");
+    }
+  }
+
+ /*
+  * List of types...
+  */
+
+  if ((scut = find_public(doc, doc, "typedef")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"TYPES\">Data Types</a></h2>\n", out);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      fprintf(out, "<h3 class=\"typedef\">%s<a name=\"%s\">%s</a></h3>\n",
+              get_comment_info(description), name, name);
+
+      if (description)
+        write_description(out, description, "p", 1);
+
+      fputs("<p class=\"code\">\n"
+            "typedef ", out);
+
+      type = mxmlFindElement(scut, scut, "type", NULL, NULL,
+                             MXML_DESCEND_FIRST);
+
+      for (type = type->child; type; type = type->next)
+        if (!strcmp(type->value.text.string, "("))
+          break;
+        else
+        {
+          if (type->value.text.whitespace)
+            putc(' ', out);
+
+          if (mxmlFindElement(doc, doc, "class", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "enumeration", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "struct", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "typedef", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "union", "name",
+                              type->value.text.string, MXML_DESCEND))
+          {
+            fputs("<a href=\"#", out);
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+            fputs("\">", out);
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+            fputs("</a>", out);
+          }
+          else
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+        }
+
+      if (type)
+      {
+       /*
+        * Output function type...
+        */
+
+        if (type->prev && type->prev->value.text.string[0] != '*')
+          putc(' ', out);
+
+        fprintf(out, "(*%s", name);
+
+        for (type = type->next->next; type; type = type->next)
+        {
+          if (type->value.text.whitespace)
+            putc(' ', out);
+
+          if (mxmlFindElement(doc, doc, "class", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "enumeration", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "struct", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "typedef", "name",
+                              type->value.text.string, MXML_DESCEND) ||
+              mxmlFindElement(doc, doc, "union", "name",
+                              type->value.text.string, MXML_DESCEND))
+          {
+            fputs("<a href=\"#", out);
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+            fputs("\">", out);
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+            fputs("</a>", out);
+          }
+          else
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+        }
+
+        fputs(";\n", out);
+      }
+      else
+      {
+        type = mxmlFindElement(scut, scut, "type", NULL, NULL,
+                               MXML_DESCEND_FIRST);
+        if (type->last_child->value.text.string[0] != '*')
+          putc(' ', out);
+
+        fprintf(out, "%s;\n", name);
+      }
+
+      fputs("</p>\n", out);
+
+      scut = find_public(scut, doc, "typedef");
+    }
+  }
+
+ /*
+  * List of structures...
+  */
+
+  if ((scut = find_public(doc, doc, "struct")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"STRUCTURES\">Structures</a></h2>\n",
+          out);
+
+    while (scut)
+    {
+      write_scu(out, doc, scut);
+
+      scut = find_public(scut, doc, "struct");
+    }
+  }
+
+ /*
+  * List of unions...
+  */
+
+  if ((scut = find_public(doc, doc, "union")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"UNIONS\">Unions</a></h2>\n", out);
+
+    while (scut)
+    {
+      write_scu(out, doc, scut);
+
+      scut = find_public(scut, doc, "union");
+    }
+  }
+
+ /*
+  * Variables...
+  */
+
+  if ((arg = find_public(doc, doc, "variable")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"VARIABLES\">Variables</a></h2>\n",
+          out);
+
+    while (arg)
+    {
+      name        = mxmlElementGetAttr(arg, "name");
+      description = mxmlFindElement(arg, arg, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      fprintf(out, "<h3 class=\"variable\">%s<a name=\"%s\">%s</a></h3>\n",
+              get_comment_info(description), name, name);
+
+      if (description)
+        write_description(out, description, "p", 1);
+
+      fputs("<p class=\"code\">", out);
+
+      write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                              NULL, MXML_DESCEND_FIRST),
+                    OUTPUT_HTML);
+      fputs(mxmlElementGetAttr(arg, "name"), out);
+      if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+        fprintf(out, " %s", defval);
+      fputs(";</p>\n", out);
+
+      arg = find_public(arg, doc, "variable");
+    }
+  }
+
+ /*
+  * List of enumerations...
+  */
+
+  if ((scut = find_public(doc, doc, "enumeration")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"ENUMERATIONS\">Constants</a></h2>\n",
+          out);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      fprintf(out, "<h3 class=\"enumeration\">%s<a name=\"%s\">%s</a></h3>\n",
+              get_comment_info(description), name, name);
+
+      if (description)
+        write_description(out, description, "p", 1);
+
+      fputs("<h4 class=\"constants\">Constants</h4>\n"
+            "<dl>\n", out);
+
+      for (arg = mxmlFindElement(scut, scut, "constant", NULL, NULL,
+                                 MXML_DESCEND_FIRST);
+           arg;
+           arg = mxmlFindElement(arg, scut, "constant", NULL, NULL,
+                                 MXML_NO_DESCEND))
+      {
+        description = mxmlFindElement(arg, arg, "description", NULL,
+                                      NULL, MXML_DESCEND_FIRST);
+        fprintf(out, "<dt>%s %s</dt>\n",
+                mxmlElementGetAttr(arg, "name"), get_comment_info(description));
+
+        write_description(out, description, "dd", 1);
+        write_description(out, description, "dd", 0);
+      }
+
+      fputs("</dl>\n", out);
+
+      scut = find_public(scut, doc, "enumeration");
+    }
+  }
+
+ /*
+  * Footer...
+  */
+
+  if (footerfile)
+  {
+   /*
+    * Use custom footer...
+    */
+
+    write_file(out, footerfile);
+  }
+
+  fputs("</div>\n"
+        "</body>\n"
+        "</html>\n", out);
+
+ /*
+  * Close output file as needed...
+  */
+
+  if (out != stdout)
+    fclose(out);
+
+#ifdef __APPLE__
+ /*
+  * When generating document sets, run the docsetutil program to index it...
+  */
+
+  if (docset)
+  {
+    const char  *args[4];               /* Argument array */
+    pid_t       pid;                    /* Process ID */
+    int         status;                 /* Exit status */
+
+
+    args[0] = "/Developer/usr/bin/docsetutil";
+    args[1] = "index";
+    args[2] = docset;
+    args[3] = NULL;
+
+    if (posix_spawn(&pid, args[0], NULL, NULL, (char **)args, environ))
+    {
+      fprintf(stderr, "mxmldoc: Unable to index documentation set \"%s\": %s\n",
+              docset, strerror(errno));
+    }
+    else
+    {
+      while (wait(&status) != pid);
+
+      if (status)
+      {
+        if (WIFEXITED(status))
+          fprintf(stderr, "mxmldoc: docsetutil exited with status %d\n",
+                  WEXITSTATUS(status));
+        else
+          fprintf(stderr, "mxmldoc: docsetutil crashed with signal %d\n",
+                  WTERMSIG(status));
+      }
+      else
+      {
+       /*
+        * Remove unneeded temporary XML files...
+        */
+
+        snprintf(filename, sizeof(filename), "%s/Contents/Resources/Nodes.xml",
+                 docset);
+        unlink(filename);
+
+        snprintf(filename, sizeof(filename), "%s/Contents/Resources/Tokens.xml",
+                 docset);
+        unlink(filename);
+      }
+    }
+  }
+#endif /* __APPLE__ */
+}
+
+
+/*
+ * 'write_html_head()' - Write the standard HTML header.
+ */
+
+static void
+write_html_head(FILE       *out,        /* I - Output file */
+                const char *section,    /* I - Section */
+                const char *title,      /* I - Title */
+                const char *cssfile)    /* I - Stylesheet */
+{
+  fputs("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" "
+        "\"http://www.w3.org/TR/html4/loose.dtd\">\n"
+        "<html>\n", out);
+
+  if (section)
+    fprintf(out, "<!-- SECTION: %s -->\n", section);
+
+  fputs("<head>\n"
+        "\t<title>", out);
+  write_string(out, title, OUTPUT_HTML);
+  fputs("\t</title>\n", out);
+
+  if (section)
+    fprintf(out, "\t<meta name=\"keywords\" content=\"%s\">\n", section);
+
+  fputs("\t<meta http-equiv=\"Content-Type\" "
+        "content=\"text/html;charset=utf-8\">\n"
+        "\t<meta name=\"creator\" content=\"" MXML_VERSION "\">\n"
+        "<style type=\"text/css\"><!--\n", out);
+
+  if (cssfile)
+  {
+   /*
+    * Use custom stylesheet file...
+    */
+
+    write_file(out, cssfile);
+  }
+  else
+  {
+   /*
+    * Use standard stylesheet...
+    */
+
+    fputs("body, p, h1, h2, h3, h4 {\n"
+          "  font-family: \"lucida grande\", geneva, helvetica, arial, "
+          "sans-serif;\n"
+          "}\n"
+          "div.body h1 {\n"
+          "  font-size: 250%;\n"
+          "  font-weight: bold;\n"
+          "  margin: 0;\n"
+          "}\n"
+          "div.body h2 {\n"
+          "  font-size: 250%;\n"
+          "  margin-top: 1.5em;\n"
+          "}\n"
+          "div.body h3 {\n"
+          "  font-size: 150%;\n"
+          "  margin-bottom: 0.5em;\n"
+          "  margin-top: 1.5em;\n"
+          "}\n"
+          "div.body h4 {\n"
+          "  font-size: 110%;\n"
+          "  margin-bottom: 0.5em;\n"
+          "  margin-top: 1.5em;\n"
+          "}\n"
+          "div.body h5 {\n"
+          "  font-size: 100%;\n"
+          "  margin-bottom: 0.5em;\n"
+          "  margin-top: 1.5em;\n"
+          "}\n"
+          "div.contents {\n"
+          "  background: #e8e8e8;\n"
+          "  border: solid thin black;\n"
+          "  padding: 10px;\n"
+          "}\n"
+          "div.contents h1 {\n"
+          "  font-size: 110%;\n"
+          "}\n"
+          "div.contents h2 {\n"
+          "  font-size: 100%;\n"
+          "}\n"
+          "div.contents ul.contents {\n"
+          "  font-size: 80%;\n"
+          "}\n"
+          ".class {\n"
+          "  border-bottom: solid 2px gray;\n"
+          "}\n"
+          ".constants {\n"
+          "}\n"
+          ".description {\n"
+          "  margin-top: 0.5em;\n"
+          "}\n"
+          ".discussion {\n"
+          "}\n"
+          ".enumeration {\n"
+          "  border-bottom: solid 2px gray;\n"
+          "}\n"
+          ".function {\n"
+          "  border-bottom: solid 2px gray;\n"
+          "  margin-bottom: 0;\n"
+          "}\n"
+          ".members {\n"
+          "}\n"
+          ".method {\n"
+          "}\n"
+          ".parameters {\n"
+          "}\n"
+          ".returnvalue {\n"
+          "}\n"
+          ".struct {\n"
+          "  border-bottom: solid 2px gray;\n"
+          "}\n"
+          ".typedef {\n"
+          "  border-bottom: solid 2px gray;\n"
+          "}\n"
+          ".union {\n"
+          "  border-bottom: solid 2px gray;\n"
+          "}\n"
+          ".variable {\n"
+          "}\n"
+          "code, p.code, pre, ul.code li {\n"
+          "  font-family: monaco, courier, monospace;\n"
+          "  font-size: 90%;\n"
+          "}\n"
+          "a:link, a:visited {\n"
+          "  text-decoration: none;\n"
+          "}\n"
+          "span.info {\n"
+          "  background: black;\n"
+          "  border: solid thin black;\n"
+          "  color: white;\n"
+          "  font-size: 80%;\n"
+          "  font-style: italic;\n"
+          "  font-weight: bold;\n"
+          "  white-space: nowrap;\n"
+          "}\n"
+          "h3 span.info, h4 span.info {\n"
+          "  float: right;\n"
+          "  font-size: 100%;\n"
+          "}\n"
+          "ul.code, ul.contents, ul.subcontents {\n"
+          "  list-style-type: none;\n"
+          "  margin: 0;\n"
+          "  padding-left: 0;\n"
+          "}\n"
+          "ul.code li {\n"
+          "  margin: 0;\n"
+          "}\n"
+          "ul.contents > li {\n"
+          "  margin-top: 1em;\n"
+          "}\n"
+          "ul.contents li ul.code, ul.contents li ul.subcontents {\n"
+          "  padding-left: 2em;\n"
+          "}\n"
+          "div.body dl {\n"
+          "  margin-top: 0;\n"
+          "}\n"
+          "div.body dt {\n"
+          "  font-style: italic;\n"
+          "  margin-top: 0;\n"
+          "}\n"
+          "div.body dd {\n"
+          "  margin-bottom: 0.5em;\n"
+          "}\n"
+          "h1.title {\n"
+          "}\n"
+          "h2.title {\n"
+          "  border-bottom: solid 2px black;\n"
+          "}\n"
+          "h3.title {\n"
+          "  border-bottom: solid 2px black;\n"
+          "}\n", out);
+  }
+
+  fputs("--></style>\n"
+        "</head>\n"
+        "<body>\n", out);
+}
+
+
+/*
+ * 'write_man()' - Write manpage documentation.
+ */
+
+static void
+write_man(const char  *man_name,        /* I - Name of manpage */
+          const char  *section,         /* I - Section */
+          const char  *title,           /* I - Title */
+          const char  *footerfile,      /* I - Footer file */
+          const char  *headerfile,      /* I - Header file */
+          const char  *introfile,       /* I - Intro file */
+          mxml_node_t *doc)             /* I - XML documentation */
+{
+  int           i;                      /* Looping var */
+  mxml_node_t   *function,              /* Current function */
+                *scut,                  /* Struct/class/union/typedef */
+                *arg,                   /* Current argument */
+                *description,           /* Description of function/var */
+                *type;                  /* Type for argument */
+  const char    *name,                  /* Name of function/type */
+                *cname,                 /* Class name */
+                *defval,                /* Default value */
+                *parent;                /* Parent class */
+  int           inscope;                /* Variable/method scope */
+  char          prefix;                 /* Prefix character */
+  time_t        curtime;                /* Current time */
+  struct tm     *curdate;               /* Current date */
+  char          buffer[1024];           /* String buffer */
+  static const char * const scopes[] =  /* Scope strings */
+                {
+                  "private",
+                  "protected",
+                  "public"
+                };
+
+
+ /*
+  * Standard man page...
+  */
+
+  curtime = time(NULL);
+  curdate = localtime(&curtime);
+  strftime(buffer, sizeof(buffer), "%x", curdate);
+
+  printf(".TH %s %s \"%s\" \"%s\" \"%s\"\n", man_name, section ? section : "3",
+         title ? title : "", buffer, title ? title : "");
+
+ /*
+  * Header...
+  */
+
+  if (headerfile)
+  {
+   /*
+    * Use custom header...
+    */
+
+    write_file(stdout, headerfile);
+  }
+  else
+  {
+   /*
+    * Use standard header...
+    */
+
+    puts(".SH NAME");
+    printf("%s \\- %s\n", man_name, title ? title : man_name);
+  }
+
+ /*
+  * Intro...
+  */
+
+  if (introfile)
+    write_file(stdout, introfile);
+
+ /*
+  * List of classes...
+  */
+
+  if (find_public(doc, doc, "class"))
+  {
+    puts(".SH CLASSES");
+
+    for (scut = find_public(doc, doc, "class");
+         scut;
+         scut = find_public(scut, doc, "class"))
+    {
+      cname       = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", cname);
+
+      write_description(stdout, description, NULL, 1);
+
+      printf(".PP\n"
+             ".nf\n"
+             "class %s", cname);
+      if ((parent = mxmlElementGetAttr(scut, "parent")) != NULL)
+        printf(" %s", parent);
+      puts("\n{");
+
+      for (i = 0; i < 3; i ++)
+      {
+        inscope = 0;
+
+        for (arg = mxmlFindElement(scut, scut, "variable", "scope", scopes[i],
+                                   MXML_DESCEND_FIRST);
+             arg;
+             arg = mxmlFindElement(arg, scut, "variable", "scope", scopes[i],
+                                   MXML_NO_DESCEND))
+        {
+          if (!inscope)
+          {
+            inscope = 1;
+            printf("  %s:\n", scopes[i]);
+          }
+
+          printf("    ");
+          write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                     NULL, MXML_DESCEND_FIRST),
+                        OUTPUT_MAN);
+          printf("%s;\n", mxmlElementGetAttr(arg, "name"));
+        }
+
+        for (function = mxmlFindElement(scut, scut, "function", "scope",
+                                        scopes[i], MXML_DESCEND_FIRST);
+             function;
+             function = mxmlFindElement(function, scut, "function", "scope",
+                                        scopes[i], MXML_NO_DESCEND))
+        {
+          if (!inscope)
+          {
+            inscope = 1;
+            printf("  %s:\n", scopes[i]);
+          }
+
+          name = mxmlElementGetAttr(function, "name");
+
+          printf("    ");
+
+          arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                                NULL, MXML_DESCEND_FIRST);
+
+          if (arg)
+            write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                       NULL, MXML_DESCEND_FIRST),
+                          OUTPUT_MAN);
+          else if (strcmp(cname, name) && strcmp(cname, name + 1))
+            fputs("void ", stdout);
+
+          printf("%s", name);
+
+          for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                     MXML_DESCEND_FIRST), prefix = '(';
+               arg;
+               arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                     MXML_NO_DESCEND), prefix = ',')
+          {
+            type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                                   MXML_DESCEND_FIRST);
+
+            putchar(prefix);
+            if (prefix == ',')
+              putchar(' ');
+
+            if (type->child)
+              write_element(stdout, doc, type, OUTPUT_MAN);
+            fputs(mxmlElementGetAttr(arg, "name"), stdout);
+            if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+              printf(" %s", defval);
+          }
+
+          if (prefix == '(')
+            puts("(void);");
+          else
+            puts(");");
+        }
+      }
+
+      puts("};\n"
+           ".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * List of enumerations...
+  */
+
+  if (find_public(doc, doc, "enumeration"))
+  {
+    puts(".SH ENUMERATIONS");
+
+    for (scut = find_public(doc, doc, "enumeration");
+         scut;
+         scut = find_public(scut, doc, "enumeration"))
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+      write_description(stdout, description, NULL, 0);
+
+      for (arg = mxmlFindElement(scut, scut, "constant", NULL, NULL,
+                                 MXML_DESCEND_FIRST);
+           arg;
+           arg = mxmlFindElement(arg, scut, "constant", NULL, NULL,
+                                 MXML_NO_DESCEND))
+      {
+        description = mxmlFindElement(arg, arg, "description", NULL,
+                                      NULL, MXML_DESCEND_FIRST);
+        printf(".TP 5\n%s\n.br\n", mxmlElementGetAttr(arg, "name"));
+        write_description(stdout, description, NULL, 1);
+      }
+    }
+  }
+
+ /*
+  * List of functions...
+  */
+
+  if (find_public(doc, doc, "function"))
+  {
+    puts(".SH FUNCTIONS");
+
+    for (function = find_public(doc, doc, "function");
+         function;
+         function = find_public(function, doc, "function"))
+    {
+      name        = mxmlElementGetAttr(function, "name");
+      description = mxmlFindElement(function, function, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+
+      puts(".PP\n"
+           ".nf");
+
+      arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                            NULL, MXML_DESCEND_FIRST);
+
+      if (arg)
+        write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                   NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_MAN);
+      else
+        fputs("void", stdout);
+
+      printf(" %s ", name);
+      for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                 MXML_DESCEND_FIRST), prefix = '(';
+           arg;
+           arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                 MXML_NO_DESCEND), prefix = ',')
+      {
+        type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                               MXML_DESCEND_FIRST);
+
+        printf("%c\n    ", prefix);
+        if (type->child)
+          write_element(stdout, doc, type, OUTPUT_MAN);
+        fputs(mxmlElementGetAttr(arg, "name"), stdout);
+        if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+          printf(" %s", defval);
+      }
+
+      if (prefix == '(')
+        puts("(void);");
+      else
+        puts("\n);");
+
+      puts(".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * List of structures...
+  */
+
+  if (find_public(doc, doc, "struct"))
+  {
+    puts(".SH STRUCTURES");
+
+    for (scut = find_public(doc, doc, "struct");
+         scut;
+         scut = find_public(scut, doc, "struct"))
+    {
+      cname       = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", cname);
+
+      write_description(stdout, description, NULL, 1);
+
+      printf(".PP\n"
+             ".nf\n"
+             "struct %s\n{\n", cname);
+      for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+                                 MXML_DESCEND_FIRST);
+           arg;
+           arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+                                 MXML_NO_DESCEND))
+      {
+        printf("  ");
+        write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                   NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_MAN);
+        printf("%s;\n", mxmlElementGetAttr(arg, "name"));
+      }
+
+      for (function = mxmlFindElement(scut, scut, "function", NULL, NULL,
+                                      MXML_DESCEND_FIRST);
+           function;
+           function = mxmlFindElement(function, scut, "function", NULL, NULL,
+                                      MXML_NO_DESCEND))
+      {
+        name = mxmlElementGetAttr(function, "name");
+
+        printf("  ");
+
+        arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                              NULL, MXML_DESCEND_FIRST);
+
+        if (arg)
+          write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                     NULL, MXML_DESCEND_FIRST),
+                        OUTPUT_MAN);
+        else if (strcmp(cname, name) && strcmp(cname, name + 1))
+          fputs("void ", stdout);
+
+        fputs(name, stdout);
+
+        for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                   MXML_DESCEND_FIRST), prefix = '(';
+             arg;
+             arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                   MXML_NO_DESCEND), prefix = ',')
+        {
+          type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                                 MXML_DESCEND_FIRST);
+
+          putchar(prefix);
+          if (prefix == ',')
+            putchar(' ');
+
+          if (type->child)
+            write_element(stdout, doc, type, OUTPUT_MAN);
+          fputs(mxmlElementGetAttr(arg, "name"), stdout);
+          if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+            printf(" %s", defval);
+        }
+
+        if (prefix == '(')
+          puts("(void);");
+        else
+          puts(");");
+      }
+
+      puts("};\n"
+           ".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * List of types...
+  */
+
+  if (find_public(doc, doc, "typedef"))
+  {
+    puts(".SH TYPES");
+
+    for (scut = find_public(doc, doc, "typedef");
+         scut;
+         scut = find_public(scut, doc, "typedef"))
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+
+      fputs(".PP\n"
+            ".nf\n"
+            "typedef ", stdout);
+
+      type = mxmlFindElement(scut, scut, "type", NULL, NULL,
+                             MXML_DESCEND_FIRST);
+
+      for (type = type->child; type; type = type->next)
+        if (!strcmp(type->value.text.string, "("))
+          break;
+        else
+        {
+          if (type->value.text.whitespace)
+            putchar(' ');
+
+          write_string(stdout, type->value.text.string, OUTPUT_MAN);
+        }
+
+      if (type)
+      {
+       /*
+        * Output function type...
+        */
+
+        printf(" (*%s", name);
+
+        for (type = type->next->next; type; type = type->next)
+        {
+          if (type->value.text.whitespace)
+            putchar(' ');
+
+          write_string(stdout, type->value.text.string, OUTPUT_MAN);
+        }
+
+        puts(";");
+      }
+      else
+        printf(" %s;\n", name);
+
+      puts(".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * List of unions...
+  */
+
+  if (find_public(doc, doc, "union"))
+  {
+    puts(".SH UNIONS");
+
+    for (scut = find_public(doc, doc, "union");
+         scut;
+         scut = find_public(scut, doc, "union"))
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+
+      printf(".PP\n"
+             ".nf\n"
+             "union %s\n{\n", name);
+      for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+                                 MXML_DESCEND_FIRST);
+           arg;
+           arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+                                 MXML_NO_DESCEND))
+      {
+        printf("  ");
+        write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                   NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_MAN);
+        printf("%s;\n", mxmlElementGetAttr(arg, "name"));
+      }
+
+      puts("};\n"
+           ".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * Variables...
+  */
+
+  if (find_public(doc, doc, "variable"))
+  {
+    puts(".SH VARIABLES");
+
+    for (arg = find_public(doc, doc, "variable");
+         arg;
+         arg = find_public(arg, doc, "variable"))
+    {
+      name        = mxmlElementGetAttr(arg, "name");
+      description = mxmlFindElement(arg, arg, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+
+      puts(".PP\n"
+           ".nf");
+
+      write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                 NULL, MXML_DESCEND_FIRST),
+                    OUTPUT_MAN);
+      fputs(mxmlElementGetAttr(arg, "name"), stdout);
+      if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+        printf(" %s", defval);
+      puts(";\n"
+           ".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+  if (footerfile)
+  {
+   /*
+    * Use custom footer...
+    */
+
+    write_file(stdout, footerfile);
+  }
+}
+
+
+/*
+ * 'write_scu()' - Write a structure, class, or union.
+ */
+
+static void
+write_scu(FILE        *out,     /* I - Output file */
+          mxml_node_t *doc,     /* I - Document */
+          mxml_node_t *scut)    /* I - Structure, class, or union */
+{
+  int           i;                      /* Looping var */
+  mxml_node_t   *function,              /* Current function */
+                *arg,                   /* Current argument */
+                *description,           /* Description of function/var */
+                *type;                  /* Type for argument */
+  const char    *name,                  /* Name of function/type */
+                *cname,                 /* Class name */
+                *defval,                /* Default value */
+                *parent,                /* Parent class */
+                *scope;                 /* Scope for variable/function */
+  int           inscope,                /* Variable/method scope */
+                maxscope;               /* Maximum scope */
+  char          prefix;                 /* Prefix character */
+  static const char * const scopes[] =  /* Scope strings */
+                {
+                  "private",
+                  "protected",
+                  "public"
+                };
+
+
+  cname       = mxmlElementGetAttr(scut, "name");
+  description = mxmlFindElement(scut, scut, "description", NULL,
+                                NULL, MXML_DESCEND_FIRST);
+
+  fprintf(out, "<h3 class=\"%s\">%s<a name=\"%s\">%s</a></h3>\n",
+          scut->value.element.name, get_comment_info(description), cname,
+          cname);
+
+  if (description)
+    write_description(out, description, "p", 1);
+
+  fprintf(out, "<p class=\"code\">%s %s", scut->value.element.name, cname);
+  if ((parent = mxmlElementGetAttr(scut, "parent")) != NULL)
+    fprintf(out, " %s", parent);
+  fputs(" {<br>\n", out);
+
+  maxscope = !strcmp(scut->value.element.name, "class") ? 3 : 1;
+
+  for (i = 0; i < maxscope; i ++)
+  {
+    inscope = maxscope == 1;
+
+    for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+                               MXML_DESCEND_FIRST);
+         arg;
+         arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+                               MXML_NO_DESCEND))
+    {
+      if (maxscope > 1 &&
+          ((scope = mxmlElementGetAttr(arg, "scope")) == NULL ||
+           strcmp(scope, scopes[i])))
+        continue;
+
+      if (!inscope)
+      {
+        inscope = 1;
+        fprintf(out, "&nbsp;&nbsp;%s:<br>\n", scopes[i]);
+      }
+
+      fputs("&nbsp;&nbsp;&nbsp;&nbsp;", out);
+      write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                              NULL, MXML_DESCEND_FIRST),
+                    OUTPUT_HTML);
+      fprintf(out, "%s;<br>\n", mxmlElementGetAttr(arg, "name"));
+    }
+
+    for (function = mxmlFindElement(scut, scut, "function", NULL, NULL,
+                                    MXML_DESCEND_FIRST);
+         function;
+         function = mxmlFindElement(function, scut, "function", NULL, NULL,
+                                    MXML_NO_DESCEND))
+    {
+      if (maxscope > 1 &&
+          ((scope = mxmlElementGetAttr(arg, "scope")) == NULL ||
+           strcmp(scope, scopes[i])))
+        continue;
+
+      if (!inscope)
+      {
+        inscope = 1;
+        fprintf(out, "&nbsp;&nbsp;%s:<br>\n", scopes[i]);
+      }
+
+      name = mxmlElementGetAttr(function, "name");
+
+      fputs("&nbsp;&nbsp;&nbsp;&nbsp;", out);
+
+      arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                            NULL, MXML_DESCEND_FIRST);
+
+      if (arg)
+        write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_HTML);
+      else if (strcmp(cname, name) && strcmp(cname, name + 1))
+        fputs("void ", out);
+
+      fprintf(out, "<a href=\"#%s.%s\">%s</a>", cname, name, name);
+
+      for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                 MXML_DESCEND_FIRST), prefix = '(';
+           arg;
+           arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                 MXML_NO_DESCEND), prefix = ',')
+      {
+        type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                               MXML_DESCEND_FIRST);
+
+        putc(prefix, out);
+        if (prefix == ',')
+          putc(' ', out);
+
+        if (type->child)
+          write_element(out, doc, type, OUTPUT_HTML);
+
+        fputs(mxmlElementGetAttr(arg, "name"), out);
+        if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+          fprintf(out, " %s", defval);
+      }
+
+      if (prefix == '(')
+        fputs("(void);<br>\n", out);
+      else
+        fputs(");<br>\n", out);
+    }
+  }
+
+  fputs("};</p>\n"
+        "<h4 class=\"members\">Members</h4>\n"
+        "<dl>\n", out);
+
+  for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+                             MXML_DESCEND_FIRST);
+       arg;
+       arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+                             MXML_NO_DESCEND))
+  {
+    description = mxmlFindElement(arg, arg, "description", NULL,
+                                  NULL, MXML_DESCEND_FIRST);
+
+    fprintf(out, "<dt>%s %s</dt>\n",
+            mxmlElementGetAttr(arg, "name"), get_comment_info(description));
+
+    write_description(out, description, "dd", 1);
+    write_description(out, description, "dd", 0);
+  }
+
+  fputs("</dl>\n", out);
+
+  for (function = mxmlFindElement(scut, scut, "function", NULL, NULL,
+                                  MXML_DESCEND_FIRST);
+       function;
+       function = mxmlFindElement(function, scut, "function", NULL, NULL,
+                                  MXML_NO_DESCEND))
+  {
+    write_function(out, doc, function, 4);
+  }
+}
+
+
+/*
+ * 'write_string()' - Write a string, quoting HTML special chars as needed.
+ */
+
+static void
+write_string(FILE       *out,           /* I - Output file */
+             const char *s,             /* I - String to write */
+             int        mode)           /* I - Output mode */
+{
+  switch (mode)
+  {
+    case OUTPUT_HTML :
+    case OUTPUT_XML :
+        while (*s)
+        {
+          if (*s == '&')
+            fputs("&amp;", out);
+          else if (*s == '<')
+            fputs("&lt;", out);
+          else if (*s == '>')
+            fputs("&gt;", out);
+          else if (*s == '\"')
+            fputs("&quot;", out);
+          else if (*s & 128)
+          {
+           /*
+            * Convert UTF-8 to Unicode constant...
+            */
+
+            int ch;                     /* Unicode character */
+
+
+            ch = *s & 255;
+
+            if ((ch & 0xe0) == 0xc0)
+            {
+              ch = ((ch & 0x1f) << 6) | (s[1] & 0x3f);
+              s ++;
+            }
+            else if ((ch & 0xf0) == 0xe0)
+            {
+              ch = ((((ch * 0x0f) << 6) | (s[1] & 0x3f)) << 6) | (s[2] & 0x3f);
+              s += 2;
+            }
+
+            if (ch == 0xa0)
+            {
+             /*
+              * Handle non-breaking space as-is...
+              */
+
+              fputs("&nbsp;", out);
+            }
+            else
+              fprintf(out, "&#x%x;", ch);
+          }
+          else
+            putc(*s, out);
+
+          s ++;
+        }
+        break;
+
+    case OUTPUT_MAN :
+        while (*s)
+        {
+          if (*s == '\\' || *s == '-')
+            putc('\\', out);
+
+          putc(*s++, out);
+        }
+        break;
+  }
+}
+
+
+/*
+ * 'write_toc()' - Write a table-of-contents.
+ */
+
+static void
+write_toc(FILE        *out,             /* I - Output file */
+          mxml_node_t *doc,             /* I - Document */
+          const char  *introfile,       /* I - Introduction file */
+          const char  *target,          /* I - Target name */
+          int         xml)              /* I - Write XML nodes? */
+{
+  FILE          *fp;                    /* Intro file */
+  mxml_node_t   *function,              /* Current function */
+                *scut,                  /* Struct/class/union/typedef */
+                *arg,                   /* Current argument */
+                *description;           /* Description of function/var */
+  const char    *name,                  /* Name of function/type */
+                *targetattr;            /* Target attribute, if any */
+  int           xmlid = 1;              /* Current XML node ID */
+
+
+ /*
+  * If target is set, it is the frame file that contains the body.
+  * Otherwise, we are creating a single-file...
+  */
+
+  if (target)
+    targetattr = " target=\"body\"";
+  else
+    targetattr = "";
+
+ /*
+  * The table-of-contents is a nested unordered list.  Start by
+  * reading any intro file to see if there are any headings there.
+  */
+
+  if (!xml)
+    fputs("<h2 class=\"title\">Contents</h2>\n"
+          "<ul class=\"contents\">\n", out);
+
+  if (introfile && (fp = fopen(introfile, "r")) != NULL)
+  {
+    char        line[8192],             /* Line from file */
+                *ptr,                   /* Pointer in line */
+                *end,                   /* End of line */
+                *anchor,                /* Anchor name */
+                quote,                  /* Quote character for value */
+                level = '2',            /* Current heading level */
+                newlevel;               /* New heading level */
+    int         inelement;              /* In an element? */
+
+
+    while (fgets(line, sizeof(line), fp))
+    {
+     /*
+      * See if this line has a heading...
+      */
+
+      if ((ptr = strstr(line, "<h")) == NULL &&
+          (ptr = strstr(line, "<H")) == NULL)
+        continue;
+
+      if (ptr[2] != '2' && ptr[2] != '3')
+        continue;
+
+      newlevel = ptr[2];
+
+     /*
+      * Make sure we have the whole heading...
+      */
+
+      while (!strstr(line, "</h") && !strstr(line, "</H"))
+      {
+        end = line + strlen(line);
+
+        if (end == (line + sizeof(line) - 1) ||
+            !fgets(end, (int)(sizeof(line) - (end - line)), fp))
+          break;
+      }
+
+     /*
+      * Convert newlines and tabs to spaces...
+      */
+
+      for (ptr = line; *ptr; ptr ++)
+        if (isspace(*ptr & 255))
+          *ptr = ' ';
+
+     /*
+      * Find the anchor and text...
+      */
+
+      for (ptr = strchr(line, '<'); ptr; ptr = strchr(ptr + 1, '<'))
+        if (!strncmp(ptr, "<A NAME=", 8) || !strncmp(ptr, "<a name=", 8))
+          break;
+
+      if (!ptr)
+        continue;
+
+      ptr += 8;
+      inelement = 1;
+
+      if (*ptr == '\'' || *ptr == '\"')
+      {
+       /*
+        * Quoted anchor...
+        */
+
+        quote  = *ptr++;
+        anchor = ptr;
+
+        while (*ptr && *ptr != quote)
+          ptr ++;
+
+        if (!*ptr)
+          continue;
+
+        *ptr++ = '\0';
+      }
+      else
+      {
+       /*
+        * Non-quoted anchor...
+        */
+
+        anchor = ptr;
+
+        while (*ptr && *ptr != '>' && !isspace(*ptr & 255))
+          ptr ++;
+
+        if (!*ptr)
+          continue;
+
+        if (*ptr == '>')
+          inelement = 0;
+
+        *ptr++ = '\0';
+      }
+
+     /*
+      * Write text until we see "</A>"...
+      */
+
+      if (xml)
+      {
+        if (newlevel < level)
+          fputs("</Node>\n"
+                "</Subnodes></Node>\n", out);
+        else if (newlevel > level && newlevel == '3')
+          fputs("<Subnodes>\n", out);
+        else if (xmlid > 1)
+          fputs("</Node>\n", out);
+
+        level = newlevel;
+
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>", xmlid ++, anchor);
+
+        quote = 0;
+
+        while (*ptr)
+        {
+          if (inelement)
+          {
+            if (*ptr == quote)
+              quote = 0;
+            else if (*ptr == '>')
+              inelement = 0;
+            else if (*ptr == '\'' || *ptr == '\"')
+              quote = *ptr;
+          }
+          else if (*ptr == '<')
+          {
+            if (!strncmp(ptr, "</A>", 4) || !strncmp(ptr, "</a>", 4))
+              break;
+
+            inelement = 1;
+          }
+          else
+            putc(*ptr, out);
+
+          ptr ++;
+        }
+
+        fputs("</Name>\n", out);
+      }
+      else
+      {
+        if (newlevel < level)
+          fputs("</li>\n"
+                "</ul></li>\n", out);
+        else if (newlevel > level)
+          fputs("<ul class=\"subcontents\">\n", out);
+        else if (xmlid > 1)
+          fputs("</li>\n", out);
+
+        level = newlevel;
+        xmlid ++;
+
+        fprintf(out, "%s<li><a href=\"%s#%s\"%s>", level > '2' ? "\t" : "",
+                target ? target : "", anchor, targetattr);
+
+        quote = 0;
+
+        while (*ptr)
+        {
+          if (inelement)
+          {
+            if (*ptr == quote)
+              quote = 0;
+            else if (*ptr == '>')
+              inelement = 0;
+            else if (*ptr == '\'' || *ptr == '\"')
+              quote = *ptr;
+          }
+          else if (*ptr == '<')
+          {
+            if (!strncmp(ptr, "</A>", 4) || !strncmp(ptr, "</a>", 4))
+              break;
+
+            inelement = 1;
+          }
+          else
+            putc(*ptr, out);
+
+          ptr ++;
+        }
+
+        fputs("</a>", out);
+      }
+    }
+
+    if (level > '1')
+    {
+      if (xml)
+      {
+        fputs("</Node>\n", out);
+
+        if (level == '3')
+          fputs("</Subnodes></Node>\n", out);
+      }
+      else
+      {
+        fputs("</li>\n", out);
+
+        if (level == '3')
+          fputs("</ul></li>\n", out);
+      }
+    }
+
+    fclose(fp);
+  }
+
+ /*
+  * Next the classes...
+  */
+
+  if ((scut = find_public(doc, doc, "class")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>CLASSES</Anchor>\n"
+                   "<Name>Classes</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#CLASSES\"%s>Classes</a>"
+                   "<ul class=\"code\">\n",
+              target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "class");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Functions...
+  */
+
+  if ((function = find_public(doc, doc, "function")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>FUNCTIONS</Anchor>\n"
+                   "<Name>Functions</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#FUNCTIONS\"%s>Functions</a>"
+                   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (function)
+    {
+      name        = mxmlElementGetAttr(function, "name");
+      description = mxmlFindElement(function, function, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      function = find_public(function, doc, "function");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Data types...
+  */
+
+  if ((scut = find_public(doc, doc, "typedef")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>TYPES</Anchor>\n"
+                   "<Name>Data Types</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#TYPES\"%s>Data Types</a>"
+                   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "typedef");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Structures...
+  */
+
+  if ((scut = find_public(doc, doc, "struct")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>STRUCTURES</Anchor>\n"
+                   "<Name>Structures</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#STRUCTURES\"%s>Structures</a>"
+                   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "struct");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Unions...
+  */
+
+  if ((scut = find_public(doc, doc, "union")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>UNIONS</Anchor>\n"
+                   "<Name>Unions</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out,
+              "<li><a href=\"%s#UNIONS\"%s>Unions</a><ul class=\"code\">\n",
+              target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "union");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Globals variables...
+  */
+
+  if ((arg = find_public(doc, doc, "variable")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>VARIABLES</Anchor>\n"
+                   "<Name>Variables</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#VARIABLES\"%s>Variables</a>"
+                   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (arg)
+    {
+      name        = mxmlElementGetAttr(arg, "name");
+      description = mxmlFindElement(arg, arg, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      arg = find_public(arg, doc, "variable");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Enumerations/constants...
+  */
+
+  if ((scut = find_public(doc, doc, "enumeration")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+                   "<Path>Documentation/index.html</Path>\n"
+                   "<Anchor>ENUMERATIONS</Anchor>\n"
+                   "<Name>Constants</Name>\n"
+                   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#ENUMERATIONS\"%s>Constants</a>"
+                   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+        fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<Name>%s</Name>\n"
+                     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+        fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+                target ? target : "", name, targetattr);
+        write_description(out, description, "", 1);
+        fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "enumeration");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Close out the HTML table-of-contents list as needed...
+  */
+
+  if (!xml)
+    fputs("</ul>\n", out);
+}
+
+
+/*
+ * 'write_tokens()' - Write <Token> nodes for all APIs.
+ */
+
+static void
+write_tokens(FILE        *out,          /* I - Output file */
+             mxml_node_t *doc,          /* I - Document */
+             const char  *path)         /* I - Path to help file */
+{
+  mxml_node_t   *function,              /* Current function */
+                *scut,                  /* Struct/class/union/typedef */
+                *arg,                   /* Current argument */
+                *description,           /* Description of function/var */
+                *type,                  /* Type node */
+                *node;                  /* Current child node */
+  const char    *name,                  /* Name of function/type */
+                *cename,                /* Current class/enum name */
+                *defval;                /* Default value for argument */
+  char          prefix;                 /* Prefix for declarations */
+
+
+ /*
+  * Classes...
+  */
+
+  if ((scut = find_public(doc, doc, "class")) != NULL)
+  {
+    while (scut)
+    {
+      cename      = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/cpp/cl/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, cename, cename);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      if ((function = find_public(scut, scut, "function")) != NULL)
+      {
+        while (function)
+        {
+          name        = mxmlElementGetAttr(function, "name");
+          description = mxmlFindElement(function, function, "description",
+                                        NULL, NULL, MXML_DESCEND_FIRST);
+
+          fprintf(out, "<Token>\n"
+                       "<Path>Documentation/%s</Path>\n"
+                       "<Anchor>%s.%s</Anchor>\n"
+                       "<TokenIdentifier>//apple_ref/cpp/clm/%s/%s", path,
+                  cename, name, cename, name);
+
+          arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                                NULL, MXML_DESCEND_FIRST);
+
+          if (arg && (type = mxmlFindElement(arg, arg, "type", NULL,
+                                             NULL, MXML_DESCEND_FIRST)) != NULL)
+          {
+            for (node = type->child; node; node = node->next)
+              fputs(node->value.text.string, out);
+          }
+          else if (strcmp(cename, name) && strcmp(cename, name + 1))
+            fputs("void", out);
+
+          fputs("/", out);
+
+          for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                     MXML_DESCEND_FIRST), prefix = '(';
+               arg;
+               arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                     MXML_NO_DESCEND), prefix = ',')
+          {
+            type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                                   MXML_DESCEND_FIRST);
+
+            putc(prefix, out);
+
+            for (node = type->child; node; node = node->next)
+              fputs(node->value.text.string, out);
+
+            fputs(mxmlElementGetAttr(arg, "name"), out);
+          }
+
+          if (prefix == '(')
+            fputs("(void", out);
+
+          fputs(")</TokenIdentifier>\n"
+                "<Abstract>", out);
+          write_description(out, description, "", 1);
+          fputs("</Abstract>\n"
+                "<Declaration>", out);
+
+          arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                                NULL, MXML_DESCEND_FIRST);
+
+          if (arg)
+            write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                    NULL, MXML_DESCEND_FIRST),
+                          OUTPUT_XML);
+          else if (strcmp(cename, name) && strcmp(cename, name + 1))
+            fputs("void ", out);
+
+          fputs(name, out);
+
+          for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                     MXML_DESCEND_FIRST), prefix = '(';
+               arg;
+               arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                     MXML_NO_DESCEND), prefix = ',')
+          {
+            type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                                   MXML_DESCEND_FIRST);
+
+            putc(prefix, out);
+            if (prefix == ',')
+              putc(' ', out);
+
+            if (type->child)
+              write_element(out, doc, type, OUTPUT_XML);
+
+            fputs(mxmlElementGetAttr(arg, "name"), out);
+            if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+              fprintf(out, " %s", defval);
+          }
+
+          if (prefix == '(')
+            fputs("(void);", out);
+          else
+            fputs(");", out);
+
+          fputs("</Declaration>\n"
+                "</Token>\n", out);
+
+          function = find_public(function, doc, "function");
+        }
+      }
+      scut = find_public(scut, doc, "class");
+    }
+  }
+
+ /*
+  * Functions...
+  */
+
+  if ((function = find_public(doc, doc, "function")) != NULL)
+  {
+    while (function)
+    {
+      name        = mxmlElementGetAttr(function, "name");
+      description = mxmlFindElement(function, function, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/c/func/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "<Declaration>", out);
+
+      arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                            NULL, MXML_DESCEND_FIRST);
+
+      if (arg)
+        write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_XML);
+      else // if (strcmp(cname, name) && strcmp(cname, name + 1))
+        fputs("void ", out);
+
+      fputs(name, out);
+
+      for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                                 MXML_DESCEND_FIRST), prefix = '(';
+           arg;
+           arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                                 MXML_NO_DESCEND), prefix = ',')
+      {
+        type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+                               MXML_DESCEND_FIRST);
+
+        putc(prefix, out);
+        if (prefix == ',')
+          putc(' ', out);
+
+        if (type->child)
+          write_element(out, doc, type, OUTPUT_XML);
+
+        fputs(mxmlElementGetAttr(arg, "name"), out);
+        if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+          fprintf(out, " %s", defval);
+      }
+
+      if (prefix == '(')
+        fputs("(void);", out);
+      else
+        fputs(");", out);
+
+      fputs("</Declaration>\n"
+            "</Token>\n", out);
+
+      function = find_public(function, doc, "function");
+    }
+  }
+
+ /*
+  * Data types...
+  */
+
+  if ((scut = find_public(doc, doc, "typedef")) != NULL)
+  {
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/c/tdef/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      scut = find_public(scut, doc, "typedef");
+    }
+  }
+
+ /*
+  * Structures...
+  */
+
+  if ((scut = find_public(doc, doc, "struct")) != NULL)
+  {
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/c/tag/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      scut = find_public(scut, doc, "struct");
+    }
+  }
+
+ /*
+  * Unions...
+  */
+
+  if ((scut = find_public(doc, doc, "union")) != NULL)
+  {
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/c/tag/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      scut = find_public(scut, doc, "union");
+    }
+  }
+
+ /*
+  * Globals variables...
+  */
+
+  if ((arg = find_public(doc, doc, "variable")) != NULL)
+  {
+    while (arg)
+    {
+      name        = mxmlElementGetAttr(arg, "name");
+      description = mxmlFindElement(arg, arg, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/c/data/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      arg = find_public(arg, doc, "variable");
+    }
+  }
+
+ /*
+  * Enumerations/constants...
+  */
+
+  if ((scut = find_public(doc, doc, "enumeration")) != NULL)
+  {
+    while (scut)
+    {
+      cename      = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+                                    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+                   "<Path>Documentation/%s</Path>\n"
+                   "<Anchor>%s</Anchor>\n"
+                   "<TokenIdentifier>//apple_ref/c/tag/%s</TokenIdentifier>\n"
+                   "<Abstract>", path, cename, cename);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      for (arg = mxmlFindElement(scut, scut, "constant", NULL, NULL,
+                                 MXML_DESCEND_FIRST);
+           arg;
+           arg = mxmlFindElement(arg, scut, "constant", NULL, NULL,
+                                 MXML_NO_DESCEND))
+      {
+        name        = mxmlElementGetAttr(arg, "name");
+        description = mxmlFindElement(arg, arg, "description", NULL,
+                                      NULL, MXML_DESCEND_FIRST);
+        fprintf(out, "<Token>\n"
+                     "<Path>Documentation/%s</Path>\n"
+                     "<Anchor>%s</Anchor>\n"
+                     "<TokenIdentifier>//apple_ref/c/econst/%s</TokenIdentifier>\n"
+                     "<Abstract>", path, cename, name);
+        write_description(out, description, "", 1);
+        fputs("</Abstract>\n"
+              "</Token>\n", out);
+      }
+
+      scut = find_public(scut, doc, "enumeration");
+    }
+  }
+}
+
+
+/*
+ * 'ws_cb()' - Whitespace callback for saving.
+ */
+
+static const char *                     /* O - Whitespace string or NULL for none */
+ws_cb(mxml_node_t *node,                /* I - Element node */
+      int         where)                /* I - Where value */
+{
+  const char *name;                     /* Name of element */
+  int   depth;                          /* Depth of node */
+  static const char *spaces = "                                        ";
+                                        /* Whitespace (40 spaces) for indent */
+
+
+  name = node->value.element.name;
+
+  switch (where)
+  {
+    case MXML_WS_BEFORE_CLOSE :
+        if (strcmp(name, "argument") &&
+            strcmp(name, "class") &&
+            strcmp(name, "constant") &&
+            strcmp(name, "enumeration") &&
+            strcmp(name, "function") &&
+            strcmp(name, "mxmldoc") &&
+            strcmp(name, "namespace") &&
+            strcmp(name, "returnvalue") &&
+            strcmp(name, "struct") &&
+            strcmp(name, "typedef") &&
+            strcmp(name, "union") &&
+            strcmp(name, "variable"))
+          return (NULL);
+
+        for (depth = -4; node; node = node->parent, depth += 2);
+        if (depth > 40)
+          return (spaces);
+        else if (depth < 2)
+          return (NULL);
+        else
+          return (spaces + 40 - depth);
+
+    case MXML_WS_AFTER_CLOSE :
+        return ("\n");
+
+    case MXML_WS_BEFORE_OPEN :
+        for (depth = -4; node; node = node->parent, depth += 2);
+        if (depth > 40)
+          return (spaces);
+        else if (depth < 2)
+          return (NULL);
+        else
+          return (spaces + 40 - depth);
+
+    default :
+    case MXML_WS_AFTER_OPEN :
+        if (strcmp(name, "argument") &&
+            strcmp(name, "class") &&
+            strcmp(name, "constant") &&
+            strcmp(name, "enumeration") &&
+            strcmp(name, "function") &&
+            strcmp(name, "mxmldoc") &&
+            strcmp(name, "namespace") &&
+            strcmp(name, "returnvalue") &&
+            strcmp(name, "struct") &&
+            strcmp(name, "typedef") &&
+            strcmp(name, "union") &&
+            strcmp(name, "variable") &&
+            strncmp(name, "?xml", 4))
+          return (NULL);
+        else
+          return ("\n");
+  }
+}
+
+
+/*
+ * End of "$Id: mxmldoc.c 440 2011-08-11 18:51:26Z mike $".
+ */
diff --git a/pathologist/src/pathologist/Makefile.am b/pathologist/src/pathologist/Makefile.am
new file mode 100644
index 0000000..215d892
--- /dev/null
+++ b/pathologist/src/pathologist/Makefile.am
@@ -0,0 +1,58 @@
+INCLUDES = -I$(top_srcdir)/src/include
+
+if MINGW
+        WINFLAGS = -Wl,--no-undefined -Wl,--export-all-symbols 
+endif
+
+if USE_COVERAGE
+        AM_CFLAGS = --coverage -O0
+        XLIB = -lgcov
+endif
+
+
+if !MINGW
+if HAVE_ESMTP
+if HAVE_OPENSSL
+
+bin_PROGRAMS = \
+        pathologist
+
+pathologist_SOURCES = \
+        pathologist.c \
+        getopt.c \
+        getopt_helpers.c \
+        mail_sender.c \
+        action.c \
+        xml_writer.c \
+        edb_api.c
+
+pathologist_LDADD = \
+        $(top_builddir)/src/mi/libmi.la \
+        $(top_builddir)/src/util/libpathologistutil.la \
+        -lesmtp \
+        -lsqlite3 \
+        $(XLIB) \
+        $(GN_LIBINTL)
+
+if ENABLE_TEST_RUN
+if SEASPIDER
+TESTS = $(check_PROGRAMS)
+endif
+endif
+
+check_PROGRAMS = \
+        test_pathologist        
+
+test_pathologist_SOURCES = \
+        test_pathologist.c
+
+test_pathologist_LDADD = \
+        $(top_builddir)/src/minixml/libminixml.la
+
+EXTRA_DIST = \
+        ../../refs  
+
+
+endif
+endif
+endif
diff --git a/pathologist/src/pathologist/action.c b/pathologist/src/pathologist/action.c
new file mode 100644
index 0000000..dcd1872
--- /dev/null
+++ b/pathologist/src/pathologist/action.c
@@ -0,0 +1,1124 @@
+
+#include "monkey_common.h"
+#include "action.h"
+#include "pathologist_edb.h"
+#include "pathologist_xml_writer.h"
+#include <libesmtp.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+extern void sendMail(const char *messageContents, const char *reportFileName,
+                     const char *emailAddress);
+
+static int crashExpressionFoundInEDB = MONKEY_YES;
+static int async_c = 0;
+static int stoppedInSharedLib = MONKEY_NO;
+static int failureFunctionStartLine = 0;        // start line number of the function in which the failure occurs
+static struct WatchInfo *watchInfoListHead = NULL;
+static struct WatchInfo *watchInfoListTail = NULL;
+static struct FileName *fileNameListHead = NULL;
+static struct FileName *fileNameListTail = NULL;
+static struct ScopeEnd *scopeEndListHead = NULL;
+static struct ScopeEnd *scopeEndListTail = NULL;
+
+
+struct ScopeEnd {
+    struct ScopeEnd *next;
+    struct ScopeEnd *prev;
+
+    int lineNo;
+};
+
+
+struct FileName {
+    struct FileName *next;
+    struct FileName *prev;
+
+    const char *name;
+};
+
+
+struct Expression {
+    struct Expression *next;
+    struct Expression *prev;
+    const char *expressionSyntax;
+    const char *expressionValue;
+    int isCall;
+};
+
+
+struct Function {
+    struct Function *next;
+    struct Function *prev;
+    const char *name;
+    const char *file;
+    int line;
+    int depth;
+    struct Expression *expressionListHead;
+    struct Expression *expressionListTail;
+};
+
+struct Trace {
+    struct Trace *next;
+    struct Trace *prev;
+    struct Function *functionListHead;
+    struct Function *functionListTail;
+        struct Expression *globalsListHead;
+        struct Expression *globalsListTail;
+};
+
+
+struct Epoch {
+    struct Trace *traceListHead;
+    struct Trace *traceListTail;
+} *epoch;
+
+struct WatchInfo {
+    struct WatchInfo *next;
+    struct WatchInfo *prev;
+    int hitNumber;
+    const char *value;
+};
+
+
+static void cb_console(const char *str, void *data)
+{
+    printf("CONSOLE> %s\n", str);
+}
+
+
+/* Note that unlike what's documented in gdb docs it isn't usable. */
+static void cb_target(const char *str, void *data)
+{
+    printf("TARGET> %s\n", str);
+}
+
+
+static void cb_log(const char *str, void *data)
+{
+    printf("LOG> %s\n", str);
+}
+
+
+static void cb_to(const char *str, void *data)
+{
+    printf(">> %s", str);
+}
+
+
+static void cb_from(const char *str, void *data)
+{
+    printf("<< %s\n", str);
+}
+
+
+static void cb_async(mi_output * o, void *data)
+{
+    printf("ASYNC\n");
+    async_c++;
+}
+
+static int isInCodeBase(const char *name)
+{
+        struct FileName *fileName = fileNameListHead;
+        while (fileName) {
+                if (strstr(name, fileName->name))
+                        return MONKEY_YES;
+                fileName = fileName->next;
+        }
+        return MONKEY_NO;
+}
+
+
+static int wait_for_stop(struct MONKEY_ACTION_Context *cntxt)
+{
+    static int safetyCount = 0;
+
+    while (!mi_get_response(cntxt->gdb_handle))
+                usleep(GDB_MI_ASYNC_WAIT);
+    /* The end of the async. */
+
+    cntxt->gdb_stop_reason = mi_res_stop(cntxt->gdb_handle);
+
+    if (cntxt->gdb_stop_reason) {
+                safetyCount = 0;        // reset the Safety Count whenever you stop for a meaningful reason
+
+                switch (cntxt->gdb_stop_reason->reason) {
+                case sr_exited_normally:
+                        return GDB_STATE_EXIT_NORMALLY;
+                case sr_signal_received:
+                        //gmi_set_unwind_on_signal_on(cntxt->gdb_handle);       // Program crashed. From now on preserve stack on any further received signals
+                        break;
+                case sr_bkpt_hit:
+                        {
+                        /* continue execution */
+                        gmi_exec_continue(cntxt->gdb_handle);
+                        return wait_for_stop(cntxt);
+                        }
+                case sr_wp_trigger:
+                        {
+                        /* Execution stopped because of hitting a watch point */
+                        static int watchPointHitNumber = 0;
+                        struct WatchInfo *watchInfo =
+                                MONKEY_malloc(sizeof(struct WatchInfo));
+                        watchInfo->hitNumber = ++watchPointHitNumber;
+                        watchInfo->value = cntxt->gdb_stop_reason->wp_val;
+                        MONKEY_CONTAINER_DLL_insert(watchInfoListHead,
+                                                        watchInfoListTail, watchInfo);
+                        if (watchPointHitNumber == 1023)
+                                printf("HEY! 1023! WE ARE GETTING OUT OF THE LOOP!\n");
+                        gmi_exec_continue(cntxt->gdb_handle);
+                        return wait_for_stop(cntxt);
+                        }
+                case sr_wp_scope:
+                        gmi_exec_continue(cntxt->gdb_handle);
+                        return wait_for_stop(cntxt);
+                default:
+                        break;
+                }
+
+                /* Reaching this line means that the program has stopped abnormally
+                 * OR we are in backtracking mode, and it's a step backward */
+                cntxt->gdb_frames = gmi_stack_list_frames(cntxt->gdb_handle);
+                while(cntxt->gdb_frames && !cntxt->gdb_frames->file) {
+                        cntxt->gdb_frames = cntxt->gdb_frames->next;
+                }
+
+                if(cntxt->gdb_frames && !isInCodeBase(cntxt->gdb_frames->file)) {
+                        struct FileName* filen;
+                        for(filen=fileNameListHead; filen; filen = filen->next)
+                                if(filen->name) printf("%s\n", filen->name);
+                        while(cntxt->gdb_frames) {
+                                if(cntxt->gdb_frames->file)
+                                        printf("file: %s\nisInCodeBase: %d\n", cntxt->gdb_frames->file, isInCodeBase(cntxt->gdb_frames->file));
+                                if(cntxt->gdb_frames->file && isInCodeBase(cntxt->gdb_frames->file)) {
+                                        break;
+                                }
+                                cntxt->gdb_frames = cntxt->gdb_frames->next;
+                        }
+
+                        if (cntxt->gdb_frames && cntxt->run_reverse) {
+                                /* We are in backtracking mode, we need to move GDB from the shared library to our source code */
+                                stoppedInSharedLib = MONKEY_YES;
+                                gmi_break_insert(cntxt->gdb_handle, cntxt->gdb_frames->file,
+                                                 cntxt->gdb_frames->line);
+                                gmi_exec_continue_reverse(cntxt->gdb_handle);
+                                while (!mi_get_response(cntxt->gdb_handle))
+                                        usleep(GDB_MI_ASYNC_WAIT);
+                                cntxt->gdb_frames = gmi_stack_list_frames(cntxt->gdb_handle);
+                        }
+                }
+
+                if (NULL == cntxt->gdb_frames) {
+                        fprintf(stderr, "Cannot get stack frames from gdb. You might be debugging the wrong program.\n"); // Something really bad happened. Abort!
+                        return GDB_STATE_ERROR;
+                }
+
+                /* Change current GDB frame to the one containing source code */
+                gmi_stack_select_frame(cntxt->gdb_handle,
+                                           cntxt->gdb_frames->level);
+
+                return GDB_STATE_STOPPED;
+    }
+    else if ((MONKEY_YES == cntxt->run_reverse) && (safetyCount < GDB_SAFETY_COUNT)) {  // GDB_SAFETY_COUNT prevents infinite analysis
+        /* If the stop reason is NULL, don't bail out immediately, wait for stop again.
+         * It happens when a breakpoint is placed (for backtracking) that the program stops for an unknown reason,
+         * resulting in a NULL stop reason which causes Monkey to bail out before finishing its analysis. This else if
+         * clause prevents premature bail out
+         */
+        safetyCount++;
+        return wait_for_stop(cntxt);
+    }
+
+    return GDB_STATE_ERROR;
+}
+
+
+int
+MONKEY_ACTION_report_file(struct MONKEY_ACTION_Context *cntxt,
+                          const char *dumpFileName, int isXML)
+{
+        FILE *f;
+        f = MONKEY_XML_WRITER_create_document(dumpFileName);
+        if (NULL == f) {
+                fprintf(stderr, "Error: pathologist was not able to create report file.\n");
+                return MONKEY_NO;
+        }
+        MONKEY_XML_WRITER_write_document(f, cntxt->xml_report_node);
+        if (0 != fclose(f)) {
+                fprintf(stderr, "Error: pathologist could not close report file.\n");
+                return MONKEY_NO;
+        }
+    return MONKEY_OK;
+}
+
+
+int MONKEY_ACTION_report_email(struct MONKEY_ACTION_Context *cntxt, const char * dumpFileName)
+{
+        FILE *f;
+        MONKEY_ACTION_format_report_xml(cntxt);
+        f = MONKEY_XML_WRITER_create_document(dumpFileName);
+        MONKEY_XML_WRITER_write_document(f, cntxt->xml_report_node);
+        fclose(f);
+        sendMail(NULL, dumpFileName, cntxt->email_address);
+    return MONKEY_OK;
+}
+
+
+static int
+iterateFileNames(void *cls, int numColumns, char **colValues,
+                 char **colNames)
+{
+    struct FileName *fileName;
+    char *token;
+
+    if (NULL == colValues[0])
+        return 1;               /* Error */
+
+    // This is done to extract the only the file name from the full path coming from the Database
+    token = strrchr(colValues[0], '/');
+    if (NULL == token) {
+        token = colValues[0];
+    } else {
+        token++;
+    }
+    fileName = MONKEY_malloc(sizeof(struct FileName));
+    fileName->prev = NULL;
+    fileName->next = NULL;
+    fileName->name = MONKEY_strdup(token);
+    MONKEY_CONTAINER_DLL_insert(fileNameListHead, fileNameListTail, fileName);
+    return 0; /* OK */
+}
+
+
+static int
+outerScopesCallback(void *cls, int numColumns, char **colValues,
+                    char **colNames)
+{
+    if (NULL == colValues[0])
+        return 1;               /* Error */
+
+    struct ScopeEnd *scopeEnd = MONKEY_malloc(sizeof(struct ScopeEnd));
+    scopeEnd->lineNo = atoi(colValues[0]);
+    MONKEY_CONTAINER_DLL_insert(scopeEndListHead, scopeEndListTail,
+                                scopeEnd);
+    return 0;                   /* OK */
+}
+
+
+static int
+iterateExpressions(void *cls, int numColumns, char **colValues,
+                   char **colNames)
+{
+    struct Expression *expression;
+    struct Function *function = (struct Function *) cls;
+
+    if (NULL == colValues[0] || NULL == colValues[1])
+                return 1;               /* Error */
+
+    expression = MONKEY_malloc(sizeof(struct Expression));
+    expression->expressionSyntax = MONKEY_strdup(colValues[0]);
+    expression->isCall = atoi(colValues[1]);
+    expression->expressionValue = NULL;
+    expression->next = NULL;
+    expression->prev = NULL;
+
+    MONKEY_CONTAINER_DLL_insert(function->expressionListHead,
+                                function->expressionListTail, expression);
+
+    return 0;                   /* OK */
+}
+
+
+static int
+iterateGlobals(void *cls, int numColumns, char **colValues,
+                   char **colNames)
+{
+    struct Expression *expression;
+    struct Trace *trace = (struct Trace *) cls;
+
+    if (NULL == colValues[0] || NULL == colValues[1])
+                return 1;               /* Error */
+
+    expression = MONKEY_malloc(sizeof(struct Expression));
+    expression->expressionSyntax = MONKEY_strdup(colValues[0]);
+    expression->isCall = atoi(colValues[1]);
+    expression->expressionValue = NULL;
+    expression->next = NULL;
+    expression->prev = NULL;
+
+    MONKEY_CONTAINER_DLL_insert(trace->globalsListHead,
+                                trace->globalsListTail, expression);
+
+    return 0;                   /* OK */
+}
+
+
+static int
+scopeEndCallback(void *cls, int numColumns, char **colValues,
+                 char **colNames)
+{
+    int *scopeEnd = (int *) cls;
+
+    *scopeEnd = atoi(colValues[0]);
+    if (*scopeEnd < 0)
+        return 1;               /* Error */
+    return 0;
+}
+
+
+static int isAssignment(const char *expressionSyntax)
+{
+    return (NULL != strstr(expressionSyntax, "=")) ? MONKEY_YES : MONKEY_NO;
+}
+
+
+static struct Expression*
+analyzeExpressionValue( struct MONKEY_ACTION_Context *cntxt,
+                                        struct Expression *expr,
+                                        struct Expression **expressionListHead,
+                                        struct Expression **expressionListTail)
+{
+        MONKEY_assert(expr);
+        struct Expression *next = expr->next;
+        struct Expression *removedExpression = expr;
+
+        // We will not evaluate function calls (because GDB will evaluate by calling the function)
+        if( expr->isCall )
+                goto remove;
+
+        // We should NOT evaluate assignments, otherwise subsequent expression evaluations will be spoiled
+        else if( isAssignment(expr->expressionSyntax) )
+                goto remove;
+
+        // NULL Pointer are also ignored (cause theire NULL)
+        if (strcmp(expr->expressionSyntax, "NULL") == 0 ||
+                strcmp(expr->expressionSyntax, "0x0") == 0 ||
+                strcmp(expr->expressionSyntax, "((void*)0)") == 0)
+                goto remove;
+
+        expr->expressionValue =
+        gmi_data_evaluate_expression(   cntxt->gdb_handle,
+                                                                        expr->expressionSyntax);
+
+        // ignore trivial report entries (constants for that matter)
+        if (expr->expressionValue && strcmp(expr->expressionSyntax, expr->expressionValue) == 0)
+                goto remove;
+
+        // ignore functionpointers with their default names
+        size_t value_len; //= strlen(expr->expressionValue);
+        size_t syntax_len; //= strlen(expr->expressionSyntax);
+        if (expr->expressionValue &&
+                (value_len = strlen(expr->expressionValue)) > (syntax_len = strlen(expr->expressionSyntax)) + 2 &&
+                !strncmp(expr->expressionValue + value_len - 1, ">", 1) &&
+                !strncmp(expr->expressionValue + value_len - syntax_len - 2, "<", 1) &&
+                !strncmp(expr->expressionValue + value_len - syntax_len - 1, expr->expressionSyntax, syntax_len))
+                goto remove;
+        
+        if (NULL != expr->expressionValue
+        && (strcmp(expr->expressionValue, "0x0") == 0
+                || strcmp(expr->expressionValue, "NULL") == 0))
+        {
+                expr->expressionValue = "NULL";
+                cntxt->gdb_null_variable = expr->expressionSyntax;
+                cntxt->has_null = MONKEY_YES;
+        }
+
+        return next;
+
+remove:
+        MONKEY_CONTAINER_DLL_remove(*expressionListHead,
+                                                                *expressionListTail,
+                                                                removedExpression);
+        return next;
+}
+
+
+static int
+analyzeExpressionValues(struct Function *function,
+                         struct MONKEY_ACTION_Context *cntxt)
+{
+    struct Expression *tmp;
+
+        tmp = function->expressionListHead;
+        while (NULL != tmp) {
+                tmp = analyzeExpressionValue(cntxt, tmp, &(function->expressionListHead), &(function->expressionListTail));
+        }
+
+    return MONKEY_OK;
+}
+
+
+static int
+analyzeGlobalsValues(struct Trace *trace,
+                         struct MONKEY_ACTION_Context *cntxt)
+{
+    struct Expression *tmp;
+
+        tmp = trace->globalsListHead;
+        while (NULL != tmp) {
+                tmp = analyzeExpressionValue(cntxt, tmp, &(trace->globalsListHead), &(trace->globalsListTail));
+        }
+
+    return MONKEY_OK;
+}
+
+
+static int flushTrace(struct Trace *trace)
+{
+    struct Function *functionPtr = NULL;
+    struct Expression *expressionPtr = NULL;
+
+    while (NULL != trace->functionListHead) {
+        functionPtr = trace->functionListHead;
+        trace->functionListHead = trace->functionListHead->next;
+
+        while (NULL != functionPtr->expressionListHead) {
+            expressionPtr = functionPtr->expressionListHead;
+            functionPtr->expressionListHead =
+                functionPtr->expressionListHead->next;
+
+            MONKEY_free((char *) expressionPtr->expressionSyntax);
+            MONKEY_free(expressionPtr);
+        }
+        MONKEY_free(functionPtr);
+    }
+    return MONKEY_OK;
+}
+
+static void printTrace()
+{
+    int i = 0;
+    struct Function *functionPtr;
+    struct Expression *expressionPtr;
+    struct Trace *tracePtr = epoch->traceListHead;
+    while (NULL != tracePtr) {
+        printf("Program Stack Trace: Epoch Step %d\n", i++);
+        functionPtr = tracePtr->functionListHead;
+        while (NULL != functionPtr) {
+            printf("Function: %s, file: %s, line: %d\n", functionPtr->name,
+                   functionPtr->file, functionPtr->line);
+            printf
+                ("--------------------------------------------------------------------------------------------------\n");
+            printf("Expressions:\n");
+
+            expressionPtr = functionPtr->expressionListHead;
+            while (NULL != expressionPtr) {
+                printf("%s = %s\n",
+                       expressionPtr->expressionSyntax,
+                       (NULL ==
+                        expressionPtr->
+                        expressionValue) ? "No Value" : expressionPtr->
+                       expressionValue);
+                expressionPtr = expressionPtr->next;
+            }
+
+            functionPtr = functionPtr->next;
+        }
+        printf
+            ("############################## End Stack Trace ######################################################\n\n");
+        tracePtr = tracePtr->next;
+    }
+}
+
+static void flushScopeEndList()
+{
+        struct ScopeEnd* scopeEndPtr;
+        while (NULL != scopeEndListHead) {
+                scopeEndPtr = scopeEndListHead;
+                scopeEndListHead = scopeEndPtr->next;
+                MONKEY_free(scopeEndPtr);
+        }
+
+        scopeEndListHead = NULL;
+        scopeEndListTail = NULL;
+}
+
+int MONKEY_ACTION_inspect_expression_database(struct MONKEY_ACTION_Context *cntxt)
+{
+    int ret = MONKEY_OK;
+    int stackDepth = 0;
+        char* file_names = NULL;
+    struct Function *function = NULL;
+    struct Trace *trace = NULL;
+
+    /* Variables used across recursive calls */
+    static struct MONKEY_EDB_Context *edbCntxt;
+
+    if (NULL == epoch) {
+                epoch = MONKEY_malloc(sizeof(struct Epoch));
+                epoch->traceListHead = NULL;
+                epoch->traceListTail = NULL;
+    }
+
+        // Initialize the trace structure for this particular epoch step
+        trace = MONKEY_malloc(sizeof(struct Trace));
+        trace->globalsListHead = NULL;
+        trace->globalsListTail = NULL;
+        MONKEY_CONTAINER_DLL_insert_tail(epoch->traceListHead,
+                                         epoch->traceListTail, trace);
+
+
+        // Create a connection to the Expression Database
+        edbCntxt = MONKEY_EDB_connect(cntxt->expression_database_path);
+        if (NULL == edbCntxt) {
+                fprintf(stderr, "Unable to connect to Expression Database file!\n");
+                ret = MONKEY_NO;
+                goto cleanup;
+        }
+
+        while( cntxt->gdb_frames && stackDepth <= cntxt->scope_depth) {
+                gmi_stack_select_frame(cntxt->gdb_handle, cntxt->gdb_frames->level);
+        gmi_stack_info_frame(cntxt->gdb_handle);
+
+                // build the function struct
+                function = MONKEY_malloc(sizeof(struct Function));
+                function->depth = stackDepth++;
+                function->line = cntxt->gdb_frames->line;
+                function->name = cntxt->gdb_frames->func;
+                function->file = cntxt->gdb_frames->file;
+                function->expressionListHead = NULL;
+                function->expressionListTail = NULL;
+                function->next = NULL;
+                function->prev = NULL;
+                MONKEY_CONTAINER_DLL_insert_tail(trace->functionListHead,
+                                                 trace->functionListTail, function);
+
+                // Retrieve scope expressions from the database
+                MONKEY_EDB_get_expressions(edbCntxt,
+                                                                   cntxt->gdb_frames->file,
+                                                                   cntxt->gdb_frames->line,
+                                                                   &iterateExpressions, function);
+
+                // Do value analysis for relevant expressions
+                analyzeExpressionValues(function, cntxt);
+
+                // add current filename to the list
+                char* tmp = file_names;
+                MONKEY_asprintf(&file_names,
+                                                "%s OR file_name LIKE \'%%%s\'",
+                                                file_names,
+                                                cntxt->gdb_frames->file);
+                MONKEY_free_non_null(tmp);
+
+                /* Now, dive deeper into the stack trace */
+                cntxt->gdb_frames = cntxt->gdb_frames->next;
+        }
+
+
+        // Retrieve globals from the database
+        file_names += 10;  // cut the first 10 chars "(null) OR "
+        MONKEY_EDB_get_globals( edbCntxt,
+                                                        file_names,
+                                                        &iterateGlobals, trace);
+        file_names -= 10;
+
+        // Do value analysis for globals
+        analyzeGlobalsValues(trace, cntxt);
+        
+cleanup:
+        MONKEY_EDB_disconnect(edbCntxt);
+        MONKEY_free_non_null(file_names);
+    return ret;
+}
+
+
+int MONKEY_ACTION_start_reverse_execution(struct MONKEY_ACTION_Context
+                                          *cntxt)
+{
+    const char *failureFile = epoch->traceListHead->functionListHead->file;
+    const char *failureFunction =
+        epoch->traceListHead->functionListHead->name;
+    struct Trace *tracePtr = epoch->traceListHead;
+    int oldLine;
+
+    /*
+     * We execute one step back operation before starting analysis. We do that to go to the expression before the one where the crash occurred.
+     * Because we already have the expression where the crash happened in our stack structure from the previous epoch step (the initial epoch)
+     */
+    if (MONKEY_NO == stoppedInSharedLib) {
+                if (MONKEY_NO != gmi_exec_next_reverse(cntxt->gdb_handle)) {
+                        while (!mi_get_response(cntxt->gdb_handle))
+                                usleep(GDB_MI_ASYNC_WAIT);
+                } else {
+                        fprintf(stderr, "Error: Reverse Execution has failed! Backtracking might not be supported for the current architecture.\n");
+                        if (MONKEY_YES == cntxt->gdb_connected) {
+                                mi_disconnect(cntxt->gdb_handle);       // No need for gdb mi at this point!
+                                cntxt->gdb_connected = MONKEY_NO;
+                        }
+                        return MONKEY_NO;
+                }
+    }
+
+    /* Do reverse execution for all expressions in the function in which the failure occurred */
+    do {
+        oldLine = tracePtr->functionListHead->line;
+                if (MONKEY_NO != gmi_exec_next_reverse(cntxt->gdb_handle)) {
+                        if (GDB_STATE_ERROR == wait_for_stop(cntxt)) {
+                                fprintf(stderr, "Error: Analysis during Reverse Execution has failed!\n");
+                                return MONKEY_NO;
+                        }
+                        if (oldLine == cntxt->gdb_frames->line)
+                                break;// We reached the end of record history TODO: DIRTY SOLUTION! WILL FAIL IF TWO EXPRESSIONS ON THE SAME LINE
+                        MONKEY_ACTION_inspect_expression_database(cntxt);
+                } else {
+                        fprintf(stderr, "Error: Reverse Execution has failed!\n");
+                        return MONKEY_NO;
+                }
+
+        tracePtr = tracePtr->next; // tracePtr will have the new trace added after examining the expression database for this reverse execution step
+    } while ((NULL != tracePtr)
+             && (strcmp(failureFile, tracePtr->functionListHead->file) ==
+                 0)
+             && (strcmp(failureFunction, tracePtr->functionListHead->name)
+                 == 0));
+
+    // stop recording and return
+    gmi_exec_record_stop(cntxt->gdb_handle);
+    return MONKEY_OK;
+}
+
+int MONKEY_ACTION_rerun_with_valgrind(struct MONKEY_ACTION_Context
+                                      *cntxt)
+{
+    char *valgrindCommand;
+    FILE *valgrindPipe;
+    const char *valgrindPath = cntxt->valgrind_binary_path;
+    struct stat buf;
+
+    if (NULL == valgrindPath)
+        valgrindPath = "/usr/bin/valgrind";     /* Assumption for valgrind installation */
+
+    /* Check if Valgrind is installed */
+    if (stat(valgrindPath, &buf) != 0 && errno == ENOENT ) {
+        fprintf(stderr,
+                "Warning: Valgrind is not installed. Memory check aborted!\n");
+        return MONKEY_NO;
+    }
+
+    MONKEY_asprintf(&cntxt->valgrind_output_tmp_file_name, "%d", rand());
+    cntxt->debug_mode = DEBUG_MODE_VALGRIND;
+    MONKEY_asprintf(&valgrindCommand,
+                    "%s --leak-check=yes --log-file=%s %s", valgrindPath,
+                    cntxt->valgrind_output_tmp_file_name,
+                    cntxt->binary_name);
+    valgrindPipe = popen(valgrindCommand, "r");
+    if (NULL == valgrindPipe) {
+        fprintf(stderr, "Error in running Valgrind! Memory check aborted!\n");
+        MONKEY_free(valgrindCommand);
+        return MONKEY_NO;
+    }
+
+    pclose(valgrindPipe);
+    MONKEY_free(valgrindCommand);
+    return MONKEY_OK;
+}
+
+
+int MONKEY_ACTION_rerun_with_gdb(struct MONKEY_ACTION_Context
+                                 *cntxt)
+{
+    struct MONKEY_EDB_Context *edbCntxt;
+    struct stat buf;
+
+    /* Check if gdb is installed */
+    if (NULL == cntxt->gdb_binary_path) {
+        cntxt->gdb_binary_path = "/usr/bin/gdb"; /* Assumption for gdb default installation */
+    }
+        if (stat(cntxt->gdb_binary_path, &buf) != 0 && errno == ENOENT ) {
+                fprintf(stderr,
+                        "Error: gdb is not installed!\n");
+                return MONKEY_NO;
+        }
+
+    epoch = NULL;               /* Initializing epoch Data Structure */
+    cntxt->debug_mode = DEBUG_MODE_GDB;
+    /* This is like a file-handle for fopen.
+       Here we have all the state of gdb "connection". */
+    if (NULL != cntxt->gdb_binary_path)
+        mi_set_gdb_exe(cntxt->gdb_binary_path);
+    int ret;
+
+    /* Connect to gdb child. */
+    cntxt->gdb_handle = mi_connect_local();
+    if (!cntxt->gdb_handle) {
+        fprintf(stderr, "Error: failed to connect to gdb!\n");
+        return MONKEY_NO;
+    }
+    fprintf(stderr, "Info: Connected to gdb!\n");
+    cntxt->gdb_connected = MONKEY_YES;
+
+    /* Set all callbacks. */
+    mi_set_console_cb(cntxt->gdb_handle, cb_console, NULL);
+    mi_set_target_cb(cntxt->gdb_handle, cb_target, NULL);
+    mi_set_log_cb(cntxt->gdb_handle, cb_log, NULL);
+    mi_set_async_cb(cntxt->gdb_handle, cb_async, NULL);
+    mi_set_to_gdb_cb(cntxt->gdb_handle, cb_to, NULL);
+    mi_set_from_gdb_cb(cntxt->gdb_handle, cb_from, NULL);
+
+    /* Set the name of the child and the command line arguments. */
+    if (!gmi_set_exec(cntxt->gdb_handle, cntxt->binary_name, cntxt->binaryArgs)) {
+                fprintf(stderr, "Error: could not set gdb exec y args\n");
+                goto fail;
+    }
+
+    /* Tell gdb to attach the child to a terminal. */
+    if (!gmi_target_terminal(cntxt->gdb_handle, ttyname(STDIN_FILENO))) {
+                fprintf(stderr, "Error: could not select gdb target terminal\n");
+                goto fail;
+    }
+
+
+    if (MONKEY_YES == cntxt->run_reverse) {
+                /* If Backtracking is enabled, we must set a breakpoint at the main function, starting the program, then starting recording */
+                mi_bkpt *bp = gmi_break_insert_full(cntxt->gdb_handle, 0, 0, NULL, -1, -1, "main");
+                if (NULL == bp) {
+                        fprintf(stderr, "Error: gdb could not set a breakpoint at function:%s\n",
+                           cntxt->inspect_function);
+                        goto fail;
+                }
+                mi_free_bkpt(bp);
+    }
+
+
+    if ((NULL != cntxt->inspect_expression) && (NULL != cntxt->inspect_function)) {
+                /* Setting a breakpoint at the function containing the expression to inspect */
+                mi_bkpt *bp = gmi_break_insert_full(cntxt->gdb_handle, 0, 0, NULL, -1, -1, cntxt->inspect_function);
+                if (NULL == bp) {
+                        fprintf(stderr, "Error: gdb could not set a breakpoint at function:%s\n", cntxt->inspect_function);
+                        goto fail;
+                }
+                mi_free_bkpt(bp);
+    }
+
+    /* Prepare a list of the file names for the source files we are analyzing */
+    edbCntxt = MONKEY_EDB_connect(cntxt->expression_database_path);
+    if (NULL == edbCntxt) {
+                fprintf(stderr,
+                        "Unable to connect to Expression Database file!\n");
+                goto fail;
+    }
+
+    if (MONKEY_OK != MONKEY_EDB_get_file_names(edbCntxt, &iterateFileNames, NULL)) {
+        fprintf(stderr, "Error: Pathologist could not retrieve source file names from expression database!\n");
+                goto fail;
+    }
+    MONKEY_EDB_disconnect(edbCntxt);
+
+
+    /* Run the program. */
+    if (!gmi_exec_run(cntxt->gdb_handle)) {
+                fprintf(stderr, "Error: gdb could not run the target program!\n");
+                goto fail;
+    }
+
+    /* Backtracking is issued after running the program */
+    if (MONKEY_YES == cntxt->run_reverse) {
+                gmi_exec_record_process(cntxt->gdb_handle);
+    }
+
+    /* Here we should be stopped when the program crashes */
+    ret = wait_for_stop(cntxt);
+    if (ret == GDB_STATE_ERROR || ret == GDB_STATE_EXIT_NORMALLY) {
+                if (MONKEY_YES == cntxt->gdb_connected) {
+                        mi_disconnect(cntxt->gdb_handle);
+                        cntxt->gdb_connected = MONKEY_NO;
+                }
+    }
+
+    return ret;
+
+        // cleanup and abort
+fail:
+        if (MONKEY_YES == cntxt->gdb_connected) {
+                mi_disconnect(cntxt->gdb_handle);
+                cntxt->gdb_connected = MONKEY_NO;
+        }
+        return MONKEY_NO;
+}
+
+
+static const char *expressionListToString(struct Expression *head)
+{
+    char *string = MONKEY_strdup("");
+    char *strTmp;
+    struct Expression *tmp;
+
+    for (tmp = head; NULL != tmp; tmp = tmp->next) {
+        MONKEY_asprintf(&strTmp,
+                        "%s%s => %s\n",
+                        string,
+                        tmp->expressionSyntax,
+                        NULL ==
+                        tmp->
+                        expressionValue ? "Not evaluated" :
+                        tmp->expressionValue);
+        MONKEY_free(string);
+        string = strTmp;
+    }
+    return string;
+}
+
+#if 0
+static int getWatchInfoListSize(struct WatchInfo *head)
+{
+    int count = 0;
+    int largestStr = 0;
+    struct WatchInfo *tmp = head;
+
+    while (NULL != tmp) {
+        if (largestStr < strlen(tmp->value))
+            largestStr = strlen(tmp->value);
+        tmp = tmp->next;
+        count++;
+    }
+
+    return count * largestStr;
+}
+
+static const char *watchInfoListToString(struct WatchInfo *head)
+{
+    char *string = MONKEY_malloc(getWatchInfoListSize(head));
+    char *strTmp;
+    struct WatchInfo *tmp = head;
+
+    MONKEY_asprintf(&strTmp, "%s\t \t%s\n", tmp->hitNumber, tmp->value);
+    strcpy(string, strTmp);
+    MONKEY_free(strTmp);
+    tmp = tmp->next;
+
+    while (NULL != tmp) {
+        MONKEY_asprintf(&strTmp, "%s\t \t%s\n", tmp->hitNumber,
+                        tmp->value);
+        strcat(string, strTmp);
+        MONKEY_free(strTmp);
+        tmp = tmp->next;
+    }
+
+    return string;
+}
+#endif
+
+static const char *getValgrindOutput(struct MONKEY_ACTION_Context *cntxt)
+{
+    char *valgrindOutput;
+    int size;
+    FILE *valgrindFile = fopen(cntxt->valgrind_output_tmp_file_name, "r");
+    fseek(valgrindFile, 0L, SEEK_END);
+    size = ftell(valgrindFile);
+    fseek(valgrindFile, 0L, SEEK_SET);
+
+    valgrindOutput = MONKEY_malloc(size);
+    fread(valgrindOutput, size - 1, 1, valgrindFile);
+    fclose(valgrindFile);
+    return valgrindOutput;
+}
+
+
+static struct MONKEY_XML_Node *createXmlSimpleNode(const char *nodeName,
+                                                   const char
+                                                   *nodeInnerText)
+{
+    struct MONKEY_XML_Node *node =
+        MONKEY_XML_WRITER_new_node(nodeName, nodeInnerText);
+    return node;
+}
+
+
+static struct MONKEY_XML_Node *createXmlCrashNode(const char *category,
+                                                  const char *function,
+                                                  int line,
+                                                  const char *file)
+{
+    struct MONKEY_XML_Node *node;
+    char *lineStr;
+
+    MONKEY_asprintf(&lineStr, "%d", line);
+    node = MONKEY_XML_WRITER_new_node("crash", NULL);
+    MONKEY_XML_WRITER_add_attribute(node, "category", category);
+    MONKEY_XML_WRITER_add_attribute(node, "function", function);
+    MONKEY_XML_WRITER_add_attribute(node, "line", lineStr);
+    MONKEY_XML_WRITER_add_attribute(node, "file", file);
+    return node;
+}
+
+
+static struct MONKEY_XML_Node *createXmlEpochStep(int step)
+{
+    struct MONKEY_XML_Node *node;
+    char *stepStr;
+    MONKEY_asprintf(&stepStr, "%d", step);
+    node = MONKEY_XML_WRITER_new_node("epoch", NULL);
+    MONKEY_XML_WRITER_add_attribute(node, "step", stepStr);
+    return node;
+}
+
+
+static struct MONKEY_XML_Node *createXmlFunctionNode(const char *name,
+                                                     int line,
+                                                     const char *file,
+                                                     int depth)
+{
+    struct MONKEY_XML_Node *node;
+    char *lineStr;
+    char *depthStr;
+
+    MONKEY_asprintf(&lineStr, "%d", line);
+    MONKEY_asprintf(&depthStr, "%d", depth);
+    node = MONKEY_XML_WRITER_new_node("function", NULL);
+    MONKEY_XML_WRITER_add_attribute(node, "name", name);
+    MONKEY_XML_WRITER_add_attribute(node, "line", lineStr);
+    MONKEY_XML_WRITER_add_attribute(node, "file", file);
+    MONKEY_XML_WRITER_add_attribute(node, "depth", depthStr);
+    return node;
+}
+
+
+static struct MONKEY_XML_Node *createXmlExpressionNode(const char *name,
+                                                       const char *value)
+{
+    struct MONKEY_XML_Node *node;
+
+    node = MONKEY_XML_WRITER_new_node("expression", value);
+    MONKEY_XML_WRITER_add_attribute(node, "name", name);
+    return node;
+}
+
+
+static struct MONKEY_XML_Node *createXmlGlobalExpressionNode(const char *name,
+                                                        const char *value)
+{
+    struct MONKEY_XML_Node *node;
+
+    node = MONKEY_XML_WRITER_new_node("expression", value);
+    MONKEY_XML_WRITER_add_attribute(node, "name", name);
+    return node;
+}
+
+
+int MONKEY_ACTION_is_Nullpointer(struct MONKEY_ACTION_Context* cntxt)
+{
+        mi_asm_insns* disassembled_code = gmi_data_disassemble_se(cntxt->gdb_handle, "$pc", "$pc+1", 0);
+        char* reg;
+        while(reg = strstr(disassembled_code->ins->inst, "(%")) {
+                //printf("%s\n", reg);
+                reg++;
+                size_t len = strcspn(reg, "),");
+                reg[0]='$';
+                reg[len]='\0';
+                char* val = gmi_data_evaluate_expression(cntxt->gdb_handle, reg);
+                //printf("%s\n", val);
+                if( !strcmp(val, "0") ) return 1;
+        }
+        return 0;
+}
+
+
+int MONKEY_ACTION_format_report_xml(struct MONKEY_ACTION_Context
+                                    *cntxt)
+{
+    int i = 0;
+    struct MONKEY_XML_Node *node;
+    struct MONKEY_XML_Node *historyNode;
+    struct MONKEY_XML_Node *traceNode;
+    struct MONKEY_XML_Node *globalsNode;
+    struct Trace *tracePtr = epoch->traceListHead;
+    struct Function *functionPtr = tracePtr->functionListHead;
+    struct Expression *expressionPtr;
+
+
+    switch (cntxt->bug_detected) {
+        case BUG_NULL_POINTER:
+                cntxt->xml_report_node = createXmlCrashNode("npe", functionPtr->name, functionPtr->line, functionPtr->file);
+                break;
+    case BUG_BAD_MEM_ACCESS:
+                cntxt->xml_report_node = createXmlCrashNode("Bad memory access", functionPtr->name, functionPtr->line, functionPtr->file);
+                node = MONKEY_XML_WRITER_add_child(cntxt->xml_report_node, createXmlSimpleNode("valgrind", getValgrindOutput(cntxt)));
+                break;
+    case BUG_ABORT:
+                cntxt->xml_report_node = createXmlCrashNode("Assertion Failure", functionPtr->name, functionPtr->line, functionPtr->file);
+                break;
+    case BUG_ARITHMETIC:
+                cntxt->xml_report_node = createXmlCrashNode("Division By Zero", functionPtr->name, functionPtr->line, functionPtr->file);
+                break;
+    case BUG_SIG_BUS:
+        cntxt->xml_report_node = createXmlCrashNode("Bus Error", functionPtr->name, functionPtr->line, functionPtr->file);
+                break;
+    default:
+        cntxt->xml_report_node = createXmlCrashNode("Unknown", functionPtr->name, functionPtr->line, functionPtr->file);
+        break;
+    }
+
+    historyNode = MONKEY_XML_WRITER_add_child(cntxt->xml_report_node, createXmlSimpleNode("history", NULL));
+
+    /* Adding Stack Trace Nodes to XML Report */
+    while (NULL != tracePtr) {
+                node = MONKEY_XML_WRITER_add_child(historyNode, createXmlEpochStep(i));
+                traceNode = MONKEY_XML_WRITER_add_child(node, createXmlSimpleNode("trace", NULL));
+                globalsNode = MONKEY_XML_WRITER_add_child(node, createXmlSimpleNode("globals", NULL));
+
+                functionPtr = tracePtr->functionListHead;
+                while (NULL != functionPtr) {
+                        node = MONKEY_XML_WRITER_add_child(traceNode, createXmlFunctionNode(functionPtr->name,
+                                                                                                                                                                functionPtr->line,
+                                                                                                                                                                functionPtr->file,
+                                                                                                                                                                functionPtr->depth));
+                        node = MONKEY_XML_WRITER_add_child(node, createXmlSimpleNode("expressions", NULL));
+
+                        expressionPtr = functionPtr->expressionListHead;
+                        while (NULL != expressionPtr) {
+                                // ignore non helpful expressions
+                                if( expressionPtr->expressionValue )
+                                        MONKEY_XML_WRITER_add_child(node, createXmlExpressionNode(expressionPtr->expressionSyntax, expressionPtr->expressionValue));
+                                expressionPtr = expressionPtr->next;
+                        }
+
+                        functionPtr = functionPtr->next;
+                }
+
+                expressionPtr = tracePtr->globalsListHead;
+                while( expressionPtr ) {
+                        if( expressionPtr->expressionValue )
+                                MONKEY_XML_WRITER_add_child(globalsNode, createXmlGlobalExpressionNode(expressionPtr->expressionSyntax, expressionPtr->expressionValue));
+                        expressionPtr = expressionPtr->next;
+                }
+                
+
+                tracePtr = tracePtr->next;
+                i++;
+    }
+    return MONKEY_OK;
+}
+
+
+
+
+int MONKEY_ACTION_delete_context(struct MONKEY_ACTION_Context
+                                 *cntxt)
+{
+        if (MONKEY_YES == cntxt->gdb_connected) {
+                mi_disconnect(cntxt->gdb_handle);
+                cntxt->gdb_connected = MONKEY_NO;
+        }
+    if (NULL != cntxt->debug_report)
+        MONKEY_free(cntxt->debug_report);
+    if (NULL != cntxt->valgrind_output_tmp_file_name) {
+        remove(cntxt->valgrind_output_tmp_file_name);
+        MONKEY_free(cntxt->valgrind_output_tmp_file_name);
+    }
+    if (NULL != cntxt->xml_report_node)
+        MONKEY_XML_WRITER_delete_tree(cntxt->xml_report_node);
+    if (NULL != cntxt->binaryArgs)
+        MONKEY_free(cntxt->binaryArgs);
+
+    MONKEY_free(cntxt);
+    return MONKEY_OK;
+}
+
+
+int MONKEY_ACTION_check_bug_redundancy()
+{
+    return MONKEY_OK;
+}
diff --git a/pathologist/src/pathologist/action.h b/pathologist/src/pathologist/action.h
new file mode 100644
index 0000000..57b748b
--- /dev/null
+++ b/pathologist/src/pathologist/action.h
@@ -0,0 +1,100 @@
+/**
+ * @file monkey/MONKEY_action.h
+ * @brief Monkey API for actions taken by Monkey while debugging
+ */
+
+#ifndef MONKEY_ACTION_H
+#define MONKEY_ACTION_H
+
+#include "gdbmi.h"
+#include "pathologist_xml_writer.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+/* Debug constants */
+#define DEBUG_MODE_GDB 0
+#define GDB_STATE_STOPPED 1
+#define GDB_STATE_EXIT_NORMALLY 2
+#define GDB_STATE_ERROR 3
+#define GDB_SAFETY_COUNT 2
+#define DEBUG_MODE_VALGRIND 4
+#define DEBUG_MODE_REPORT_READY 5
+#define NO_BUG_DETECTED -1
+#define BUG_NULL_POINTER 6
+#define BUG_ABORT 7
+#define BUG_ARITHMETIC 8
+#define BUG_BAD_MEM_ACCESS 9
+#define BUG_SIG_BUS 10
+#define GDB_MI_ASYNC_WAIT 5
+
+/**
+ * Context for the Action API
+ */
+struct MONKEY_ACTION_Context
+{
+  const char *binary_name;
+  char *binaryArgs;
+  const char *email_address;
+  const char *expression_database_path;
+  const char *gdb_binary_path;
+  const char *valgrind_binary_path;
+  const char *inspect_expression;
+  const char *inspect_function;
+  int debug_mode;
+  int bug_detected;
+  int has_null;
+  char *debug_report;
+  struct MONKEY_XML_Node *xml_report_node;
+
+  /* gdb debugging attributes */
+  int run_reverse;
+  int scope_depth;
+  mi_h *gdb_handle;
+  int gdb_connected;
+  const char *gdb_in_use;
+  mi_stop *gdb_stop_reason;
+  mi_frames *gdb_frames;
+  const char *gdb_null_variable;
+
+  /* Valgrind memcheck attributes */
+  char* valgrind_output_tmp_file_name;
+};
+
+
+int MONKEY_ACTION_report_file (struct MONKEY_ACTION_Context
+                                      *cntxt, const char *dumpFileName, int isXML);
+int MONKEY_ACTION_report_email (struct MONKEY_ACTION_Context
+                                       *cntxt, const char *dumpFileName);
+int MONKEY_ACTION_inspect_expression_database (struct
+                                                      MONKEY_ACTION_Context
+                                                      *cntxt);
+int MONKEY_ACTION_rerun_with_gdb (struct MONKEY_ACTION_Context
+                                         *cntxt);
+int MONKEY_ACTION_start_reverse_execution(struct MONKEY_ACTION_Context * cntxt);
+int MONKEY_ACTION_rerun_with_valgrind (struct
+                                              MONKEY_ACTION_Context
+                                              *cntxt);
+int MONKEY_ACTION_format_report (struct MONKEY_ACTION_Context
+                                        *cntxt);
+int
+MONKEY_ACTION_format_report_xml (struct MONKEY_ACTION_Context
+                                        *cntxt);
+int MONKEY_ACTION_delete_context(struct MONKEY_ACTION_Context *cntxt);
+
+int MONKEY_ACTION_check_bug_redundancy (void);
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/pathologist/src/pathologist/edb_api.c b/pathologist/src/pathologist/edb_api.c
new file mode 100644
index 0000000..5af26de
--- /dev/null
+++ b/pathologist/src/pathologist/edb_api.c
@@ -0,0 +1,368 @@
+/**
+ * @file monkey/edb_api.c
+ * @brief Monkey API for accessing the Expression Database (edb)
+ */
+
+#include "monkey_common.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <sqlite3.h>
+#include "pathologist_edb.h"
+
+
+/**
+ * Context for Database connection and Expressions
+ */
+struct MONKEY_EDB_Context
+{
+  /**
+   *  Database connection 
+   */
+  sqlite3 *db_handle;
+};
+
+
+/**
+ * Establish a connection to the Expression Database
+ *
+ * @param db_file_name path the Expression Database file
+ * @return context to use for Accessing the Expression Database, NULL on error
+ */
+struct MONKEY_EDB_Context *
+MONKEY_EDB_connect (const char *db_file_name)
+{
+  int err;
+  struct MONKEY_EDB_Context *ctxt =
+    MONKEY_malloc (sizeof (struct MONKEY_EDB_Context));
+
+  err = sqlite3_open (db_file_name, &ctxt->db_handle);
+  if (err)
+    {
+      fprintf(stderr,
+                  "Cannot open Expression Database. `%s'\n",
+                  sqlite3_errmsg (ctxt->db_handle));
+      return NULL;
+    }
+  return ctxt;
+}
+
+
+/**
+ * Disconnect from Database, and cleanup resources
+ *
+ * @param context context containing the Expression Database handle
+ * @return MONKEY_OK on success, MONKEY_NO on failure
+ */
+int
+MONKEY_EDB_disconnect (struct MONKEY_EDB_Context *cntxt)
+{
+  sqlite3_close (cntxt->db_handle);
+  MONKEY_free (cntxt);
+  return MONKEY_OK;
+}
+
+
+
+int
+MONKEY_EDB_get_file_names (struct MONKEY_EDB_Context *cntxt,
+                                  MONKEY_FileIterator iter,
+                                  void *iter_cls)
+{
+  int err;
+  char *errMsg;
+  char *query;
+
+  if (MONKEY_asprintf (&query, "select distinct file_name from Expression") == -1)
+    {
+      fprintf(stderr,
+                  "Memory allocation problem occurred during creating database query!\n");
+      return MONKEY_NO;
+    }
+
+  err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+  if (err)
+    {
+      fprintf(stderr,
+                  "Error occurred while executing Database query. `%s'",
+                  errMsg);
+      return MONKEY_NO;
+    }
+  return MONKEY_OK;
+}
+
+
+
+int
+MONKEY_EDB_get_all_outer_scopes(struct MONKEY_EDB_Context
+                *cntxt, const char *file_name,
+                int function_beginning,
+                int scope_in_question_start,
+                int scope_in_question_end,
+                MONKEY_ExpressionIterator
+                iter, void *iter_cls)
+{
+          int err;
+          char *errMsg;
+          char *query;
+
+          if (MONKEY_asprintf
+                  (&query,
+                   "select distinct end_lineno from Expression where file_name LIKE \'%%%s\' and start_lineno >= %d and start_lineno < %d and end_lineno > %d order by end_lineno",
+                   file_name, function_beginning, scope_in_question_start, scope_in_question_end) == -1)
+                {
+                  fprintf(stderr,
+                          "Memory allocation problem occurred during creating database query!\n");
+                  return MONKEY_NO;
+                }
+
+          err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+          if (err)
+                {
+                  fprintf(stderr,
+                          "Error occurred while executing Database query. `%s'",
+                          errMsg);
+                  return MONKEY_NO;
+                }
+          return MONKEY_OK;
+}
+
+int
+MONKEY_EDB_expression_function_end_scope(struct MONKEY_EDB_Context
+                *cntxt, const char *file_name,
+                int start_lineno,
+                MONKEY_ExpressionIterator
+                iter, void *iter_cls)
+{
+          int err;
+          char *errMsg;
+          char *query;
+
+          if (MONKEY_asprintf
+              (&query,
+               "select MAX(end_lineno) from Expression where file_name LIKE \'%%%s\' and start_lineno < %d and end_lineno != 32767",
+               file_name, start_lineno) == -1)
+            {
+              fprintf(stderr,
+                          "Memory allocation problem occurred during creating database query!\n");
+              return MONKEY_NO;
+            }
+
+          err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+          if (err)
+            {
+              fprintf(stderr,
+                          "Error occurred while executing Database query. `%s'",
+                          errMsg);
+              return MONKEY_NO;
+            }
+          return MONKEY_OK;
+}
+
+int
+MONKEY_EDB_function_start_line_for_scope(struct MONKEY_EDB_Context
+                *cntxt, const char *file_name,
+                int scope_end,
+                MONKEY_ExpressionIterator
+                iter, void *iter_cls)
+{
+          int err;
+          char *errMsg;
+          char *query;
+
+          if (MONKEY_asprintf
+              (&query,
+               "select MIN(start_lineno) from Expression where file_name LIKE \'%%%s\' and end_lineno >= %d",
+               file_name, scope_end) == -1)
+            {
+              fprintf(stderr,
+                          "Memory allocation problem occurred during creating database query!\n");
+              return MONKEY_NO;
+            }
+
+          err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+          if (err)
+            {
+              fprintf(stderr,
+                          "Error occurred while executing Database query. `%s'",
+                          errMsg);
+              return MONKEY_NO;
+            }
+          return MONKEY_OK;
+}
+
+
+/**
+ * Return the line number of the end-of-scope for the expression indicated by start_line_no
+ *
+ * @param cntxt context containing the Expression Database handle
+ * @param file_name path to the file in which the expression in question exists
+ * @param start_line_no expression's line
+ * @param iter callback function, iterator for values returned from the Database
+ * @param iter_cls closure for the expression iterator, will contain the scope-end line number
+ * @return MONKEY_OK on success, MONKEY_NO on failure
+ */
+int
+MONKEY_EDB_get_expression_scope_end (struct MONKEY_EDB_Context
+                                            *cntxt, const char *file_name,
+                                            int start_line_no,
+                                            MONKEY_ExpressionIterator
+                                            iter, void *iter_cls)
+{
+  int err;
+  char *errMsg;
+  char *query;
+
+  if (MONKEY_asprintf
+      (&query,
+       "select min(end_lineno) from Expression where file_name LIKE \'%%%s\' and start_lineno = %d",
+       file_name, start_line_no) == -1)
+    {
+      fprintf(stderr,
+                  "Memory allocation problem occurred during creating database query!\n");
+      return MONKEY_NO;
+    }
+
+  err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+  MONKEY_free (query);
+
+  if (err)
+    {
+      fprintf(stderr,
+                  "Error occurred while executing Database query. `%s'",
+                  errMsg);
+      return MONKEY_NO;
+    }
+  return MONKEY_OK;
+}
+
+
+int
+MONKEY_EDB_get_expression_scope_end_for_expression (struct MONKEY_EDB_Context
+                                            *cntxt, const char *file_name,
+                                            const char * expr_syntax,
+                                            MONKEY_ExpressionIterator
+                                            iter, void *iter_cls)
+{
+  int err;
+  char *errMsg;
+  char *query;
+
+  if (MONKEY_asprintf
+      (&query,
+       "select end_lineno from Expression where file_name LIKE \'%%%s\' and expr_syntax = %s",
+       file_name, expr_syntax) == -1)
+    {
+      fprintf(stderr,
+                  "Memory allocation problem occurred during creating database query!\n");
+      return MONKEY_NO;
+    }
+
+  err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+  MONKEY_free (query);
+
+  if (err)
+    {
+      fprintf(stderr,
+                  "Error occurred while executing Database query. `%s'",
+                  errMsg);
+      return MONKEY_NO;
+    }
+  return MONKEY_OK;
+}
+
+
+int
+MONKEY_EDB_get_globals( struct MONKEY_EDB_Context *cntxt,
+                                                const char *file_names,
+                                                MONKEY_ExpressionIterator iter,
+                                                void *iter_cls) {
+        int ret = MONKEY_OK;
+        char *errMsg;
+        char *query;
+        if( MONKEY_asprintf(&query,
+                                                "SELECT DISTINCT expr_syntax, is_call FROM Expression WHERE (%s) AND start_lineno = 0 AND end_lineno = 32767",
+                                                file_names) == -1 ) {
+                fprintf(stderr, "Memory allocation problem occurred!\n");
+                ret = MONKEY_NO;
+                goto fin;
+        }
+
+        if( sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg) )   {
+                fprintf(stderr, "Error occurred while executing Database query. `%s'", errMsg);
+                ret = MONKEY_NO;
+                goto fin;
+        }
+fin:
+        MONKEY_free_non_null(query);
+        return MONKEY_NO;
+}
+
+/**
+ * Run an SQLite query to retrieve those expressions that are previous to
+ * given expression and are in the same function of the given expression
+ * 
+ * @param cntxt context containing the Expression Database handle
+ * @param file_name path to the file in which the expression in question exists
+ * @param start_line_no expression beginning line
+ * @param iter callback function, iterator for expressions returned from the Database
+ * @param iter_cls closure for the expression iterator
+ * @return MONKEY_OK success, MONKEY_NO failure
+ */
+int
+MONKEY_EDB_get_expressions (struct MONKEY_EDB_Context *cntxt,
+                                   const char *file_name, int start_line_no,
+                                   MONKEY_ExpressionIterator iter,
+                                   void *iter_cls)
+{
+  int err;
+  char *errMsg;
+  char *query;
+  if (MONKEY_asprintf
+      (&query,
+       "select distinct expr_syntax, is_call from Expression where file_name LIKE \'%%%s\' and start_lineno <= %d and end_lineno >= %d and end_lineno != 32767",
+       file_name, start_line_no, start_line_no) == -1)
+    {
+      fprintf(stderr, "Memory allocation problem occurred!\n");
+      return MONKEY_NO;
+    }
+
+  err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+  if (err)
+    {
+      fprintf(stderr, "Error occurred while executing Database query. `%s'\n", errMsg);
+      return MONKEY_NO;
+    }
+  return MONKEY_OK;
+}
+
+
+int
+MONKEY_EDB_get_sub_expressions (struct MONKEY_EDB_Context
+                                       *cntxt, const char *file_name,
+                                       int start_line_no, int end_line_no,
+                                       MONKEY_ExpressionIterator iter,
+                                       void *iter_cls)
+{
+  int err;
+  char *errMsg;
+  char *query;
+  if (MONKEY_asprintf
+      (&query,
+       "select expr_syntax, start_lineno, is_call from Expression where file_name LIKE \'%%%s\' and start_lineno = %d and end_lineno = %d",
+       file_name, start_line_no, end_line_no) == -1)
+    {
+      fprintf(stderr,
+                  "Memory allocation problem occurred!\n");
+      return MONKEY_NO;
+    }
+
+  err = sqlite3_exec (cntxt->db_handle, query, iter, iter_cls, &errMsg);
+  if (err)
+    {
+      fprintf(stderr,
+                  "Error occurred while executing Database query. `%s'",
+                  errMsg);
+      return MONKEY_NO;
+    }
+  return MONKEY_OK;
+}
diff --git a/pathologist/src/pathologist/getopt.c b/pathologist/src/pathologist/getopt.c
new file mode 100644
index 0000000..d7a037c
--- /dev/null
+++ b/pathologist/src/pathologist/getopt.c
@@ -0,0 +1,1047 @@
+/* Getopt for GNU.
+   NOTE: getopt is now part of the C library, so if you don't know what
+   "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
+   before changing it!
+
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
+     Free Software Foundation, Inc.
+
+NOTE: The canonical source of this file is maintained with the GNU C Library.
+Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+USA.
+
+
+This code was heavily modified for GNUnet.
+Copyright (C) 2006 Christian Grothoff
+*/
+
+/**
+ * @file util/getopt.c
+ * @brief GNU style option parsing
+ *
+ * TODO: get rid of statics (make reentrant) and
+ * replace main GNU getopt parser with one that
+ * actually fits our API.
+ */
+
+#include "platform.h"
+#include "monkey_common.h"
+#include "monkey_getopt_lib.h"
+
+#ifdef VMS
+#include <unixlib.h>
+#if HAVE_STRING_H - 0
+#include <string.h>
+#endif
+#endif
+
+#define LOG(kind,...) MONKEY_log_from (kind, "util", __VA_ARGS__)
+
+#define LOG_STRERROR(kind,syscall) MONKEY_log_from_strerror (kind, "util", syscall)
+
+#if defined (WIN32) && !defined (__CYGWIN32__)
+/* It's not Unix, really.  See?  Capital letters.  */
+#include <windows.h>
+#define getpid() GetCurrentProcessId()
+#endif
+
+#ifndef _
+/* This is for other GNU distributions with internationalized messages.
+   When compiling libc, the _ macro is predefined.  */
+#ifdef HAVE_LIBINTL_H
+#include <libintl.h>
+#define _(msgid)  gettext (msgid)
+#else
+#define _(msgid)  (msgid)
+#endif
+#endif
+
+/* Describe the long-named options requested by the application.
+   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+   of `struct GNoption' terminated by an element containing a name which is
+   zero.
+
+   The field `has_arg' is:
+   no_argument          (or 0) if the option does not take an argument,
+   required_argument  (or 1) if the option requires an argument,
+   optional_argument   (or 2) if the option takes an optional argument.
+
+   If the field `flag' is not NULL, it points to a variable that is set
+   to the value given in the field `val' when the option is found, but
+   left unchanged if the option is not found.
+
+   To have a long-named option do something other than set an `int' to
+   a compiled-in constant, such as set a value from `GNoptarg', set the
+   option's `flag' field to zero and its `val' field to a nonzero
+   value (the equivalent single-letter option character, if there is
+   one).  For long options that have a zero `flag' field, `getopt'
+   returns the contents of the `val' field.  */
+
+struct GNoption
+{
+  const char *name;
+  /* has_arg can't be an enum because some compilers complain about
+   * type mismatches in all the code that assumes it is an int.  */
+  int has_arg;
+  int *flag;
+  int val;
+};
+
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+   but it behaves differently for the user, since it allows the user
+   to intersperse the options with the other arguments.
+
+   As `getopt' works, it permutes the elements of ARGV so that,
+   when it is done, all the options precede everything else.  Thus
+   all application programs are extended to handle flexible argument order.
+
+   Setting the environment variable POSIXLY_CORRECT disables permutation.
+   Then the behavior is completely standard.
+
+   GNU application programs can use a third alternative mode in which
+   they can distinguish the relative order of options and other arguments.  */
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+static char *GNoptarg = NULL;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns -1, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `GNoptind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+/* 1003.2 says this must be 1 before any call.  */
+static int GNoptind = 1;
+
+/* The next char to be scanned in the option-element
+   in which the last option character we returned was found.
+   This allows us to pick up the scan where we left off.
+
+   If this is zero, or a null string, it means resume the scan
+   by advancing to the next ARGV-element.  */
+
+static char *nextchar;
+
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+
+   If the caller did not specify anything,
+   the default is REQUIRE_ORDER if the environment variable
+   POSIXLY_CORRECT is defined, PERMUTE otherwise.
+
+   REQUIRE_ORDER means don't recognize them as options;
+   stop option processing when the first non-option is seen.
+   This is what Unix does.
+   This mode of operation is selected by either setting the environment
+   variable POSIXLY_CORRECT, or using `+' as the first character
+   of the list of option characters.
+
+   PERMUTE is the default.  We MONKEY_CRYPTO_random_permute the contents of ARGV as we scan,
+   so that eventually all the non-options are at the end.  This allows options
+   to be given in any order, even with programs that were not written to
+   expect this.
+
+   RETURN_IN_ORDER is an option available to programs that were written
+   to expect GNoptions and other ARGV-elements in any order and that care about
+   the ordering of the two.  We describe each non-option ARGV-element
+   as if it were the argument of an option with character code 1.
+   Using `-' as the first character of the list of option characters
+   selects this mode of operation.
+
+   The special argument `--' forces an end of option-scanning regardless
+   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
+   `--' can cause `getopt' to return -1 with `GNoptind' != ARGC.  */
+
+static enum
+{
+  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+} ordering;
+
+/* Value of POSIXLY_CORRECT environment variable.  */
+static char *posixly_correct;
+
+#ifdef  __GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+   because there are many ways it can cause trouble.
+   On some systems, it contains special magic macros that don't work
+   in GCC.  */
+#include <string.h>
+#define  my_index       strchr
+#else
+
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
+
+char *
+getenv ();
+
+static char *
+my_index (const char *str,
+          int chr)
+{
+  while (*str)
+  {
+    if (*str == chr)
+      return (char *) str;
+    str++;
+  }
+  return 0;
+}
+
+/* If using GCC, we can safely declare strlen this way.
+   If not using GCC, it is ok not to declare it.  */
+#ifdef __GNUC__
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+   That was relevant to code that was here before.  */
+#if !defined (__STDC__) || !__STDC__
+/* gcc with -traditional declares the built-in strlen to return int,
+   and has done so at least since version 2.4.5. -- rms.  */
+extern int
+strlen (const char *);
+#endif /* not __STDC__ */
+#endif /* __GNUC__ */
+
+#endif /* not __GNU_LIBRARY__ */
+
+/* Handle permutation of arguments.  */
+
+/* Describe the part of ARGV that contains non-options that have
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+   `last_nonopt' is the index after the last of them.  */
+
+static int first_nonopt;
+static int last_nonopt;
+
+#ifdef _LIBC
+/* Bash 2.0 gives us an environment variable containing flags
+   indicating ARGV elements that should not be considered arguments.  */
+
+/* Defined in getopt_init.c  */
+extern char *__getopt_nonoption_flags;
+
+static int nonoption_flags_max_len;
+static int nonoption_flags_len;
+
+static int original_argc;
+static char *const *original_argv;
+
+extern pid_t __libc_pid;
+
+/* Make sure the environment variable bash 2.0 puts in the environment
+   is valid for the getopt call we must make sure that the ARGV passed
+   to getopt is that one passed to the process.  */
+static void MONKEY_UNUSED
+store_args_and_env (int argc, char *const *argv)
+{
+  /* XXX This is no good solution.  We should rather copy the args so
+   * that we can compare them later.  But we must not use malloc(3).  */
+  original_argc = argc;
+  original_argv = argv;
+}
+
+text_set_element (__libc_subinit, store_args_and_env);
+
+#define SWAP_FLAGS(ch1, ch2) \
+  if (nonoption_flags_len > 0)                                                \
+    {                                                                 \
+      char __tmp = __getopt_nonoption_flags[ch1];                     \
+      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];        \
+      __getopt_nonoption_flags[ch2] = __tmp;                          \
+    }
+#else /* !_LIBC */
+#define SWAP_FLAGS(ch1, ch2)
+#endif /* _LIBC */
+
+/* Exchange two adjacent subsequences of ARGV.
+   One subsequence is elements [first_nonopt,last_nonopt)
+   which contains all the non-options that have been skipped so far.
+   The other is elements [last_nonopt,GNoptind), which contains all
+   the options processed since those non-options were skipped.
+
+   `first_nonopt' and `last_nonopt' are relocated so that they describe
+   the new indices of the non-options in ARGV after they are moved.  */
+
+#if defined (__STDC__) && __STDC__
+static void
+exchange (char **);
+#endif
+
+static void
+exchange (char **argv)
+{
+  int bottom = first_nonopt;
+  int middle = last_nonopt;
+  int top = GNoptind;
+  char *tem;
+
+  /* Exchange the shorter segment with the far end of the longer segment.
+   * That puts the shorter segment into the right place.
+   * It leaves the longer segment in the right place overall,
+   * but it consists of two parts that need to be swapped next.  */
+
+#ifdef _LIBC
+  /* First make sure the handling of the `__getopt_nonoption_flags'
+   * string can work normally.  Our top argument must be in the range
+   * of the string.  */
+  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
+  {
+    /* We must extend the array.  The user plays games with us and
+     * presents new arguments.  */
+    char *new_str = malloc (top + 1);
+
+    if (new_str == NULL)
+      nonoption_flags_len = nonoption_flags_max_len = 0;
+    else
+    {
+      memcpy (new_str, __getopt_nonoption_flags, nonoption_flags_max_len);
+      memset (&new_str[nonoption_flags_max_len], '\0',
+              top + 1 - nonoption_flags_max_len);
+      nonoption_flags_max_len = top + 1;
+      __getopt_nonoption_flags = new_str;
+    }
+  }
+#endif
+
+  while (top > middle && middle > bottom)
+  {
+    if (top - middle > middle - bottom)
+    {
+      /* Bottom segment is the short one.  */
+      int len = middle - bottom;
+      register int i;
+
+      /* Swap it with the top part of the top segment.  */
+      for (i = 0; i < len; i++)
+      {
+        tem = argv[bottom + i];
+        argv[bottom + i] = argv[top - (middle - bottom) + i];
+        argv[top - (middle - bottom) + i] = tem;
+        SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
+      }
+      /* Exclude the moved bottom segment from further swapping.  */
+      top -= len;
+    }
+    else
+    {
+      /* Top segment is the short one.  */
+      int len = top - middle;
+      register int i;
+
+      /* Swap it with the bottom part of the bottom segment.  */
+      for (i = 0; i < len; i++)
+      {
+        tem = argv[bottom + i];
+        argv[bottom + i] = argv[middle + i];
+        argv[middle + i] = tem;
+        SWAP_FLAGS (bottom + i, middle + i);
+      }
+      /* Exclude the moved top segment from further swapping.  */
+      bottom += len;
+    }
+  }
+
+  /* Update records for the slots the non-options now occupy.  */
+
+  first_nonopt += (GNoptind - last_nonopt);
+  last_nonopt = GNoptind;
+}
+
+/* Initialize the internal data when the first call is made.  */
+
+#if defined (__STDC__) && __STDC__
+static const char *
+_getopt_initialize (int, char *const *, const char *);
+#endif
+static const char *
+_getopt_initialize (int argc,
+                    char *const *argv,
+                    const char *optstring)
+{
+  /* Start processing options with ARGV-element 1 (since ARGV-element 0
+   * is the program name); the sequence of previously skipped
+   * non-option ARGV-elements is empty.  */
+
+  first_nonopt = last_nonopt = GNoptind;
+
+  nextchar = NULL;
+
+  posixly_correct = getenv ("POSIXLY_CORRECT");
+
+  /* Determine how to handle the ordering of options and nonoptions.  */
+
+  if (optstring[0] == '-')
+  {
+    ordering = RETURN_IN_ORDER;
+    ++optstring;
+  }
+  else if (optstring[0] == '+')
+  {
+    ordering = REQUIRE_ORDER;
+    ++optstring;
+  }
+  else if (posixly_correct != NULL)
+    ordering = REQUIRE_ORDER;
+  else
+    ordering = PERMUTE;
+
+#ifdef _LIBC
+  if (posixly_correct == NULL && argc == original_argc && argv == original_argv)
+  {
+    if (nonoption_flags_max_len == 0)
+    {
+      if (__getopt_nonoption_flags == NULL ||
+          __getopt_nonoption_flags[0] == '\0')
+        nonoption_flags_max_len = -1;
+      else
+      {
+        const char *orig_str = __getopt_nonoption_flags;
+        int len = nonoption_flags_max_len = strlen (orig_str);
+
+        if (nonoption_flags_max_len < argc)
+          nonoption_flags_max_len = argc;
+        __getopt_nonoption_flags = (char *) malloc (nonoption_flags_max_len);
+        if (__getopt_nonoption_flags == NULL)
+          nonoption_flags_max_len = -1;
+        else
+        {
+          memcpy (__getopt_nonoption_flags, orig_str, len);
+          memset (&__getopt_nonoption_flags[len], '\0',
+                  nonoption_flags_max_len - len);
+        }
+      }
+    }
+    nonoption_flags_len = nonoption_flags_max_len;
+  }
+  else
+    nonoption_flags_len = 0;
+#endif
+
+  return optstring;
+}
+
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+   given in OPTSTRING.
+
+   If an element of ARGV starts with '-', and is not exactly "-" or "--",
+   then it is an option element.  The characters of this element
+   (aside from the initial '-') are option characters.  If `getopt'
+   is called repeatedly, it returns successively each of the option characters
+   from each of the option elements.
+
+   If `getopt' finds another option character, it returns that character,
+   updating `GNoptind' and `nextchar' so that the next call to `getopt' can
+   resume the scan with the following option character or ARGV-element.
+
+   If there are no more option characters, `getopt' returns -1.
+   Then `GNoptind' is the index in ARGV of the first ARGV-element
+   that is not an option.  (The ARGV-elements have been permuted
+   so that those that are not options now come last.)
+
+   OPTSTRING is a string containing the legitimate option characters.
+   If an option character is seen that is not listed in OPTSTRING,
+   return '?' after printing an error message.  If you set `GNopterr' to
+   zero, the error message is suppressed but we still return '?'.
+
+   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+   so the following text in the same ARGV-element, or the text of the following
+   ARGV-element, is returned in `GNoptarg'.  Two colons mean an option that
+   wants an optional arg; if there is text in the current ARGV-element,
+   it is returned in `GNoptarg', otherwise `GNoptarg' is set to zero.
+
+   If OPTSTRING starts with `-' or `+', it requests different methods of
+   handling the non-option ARGV-elements.
+   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+
+   Long-named options begin with `--' instead of `-'.
+   Their names may be abbreviated as long as the abbreviation is unique
+   or is an exact match for some defined option.  If they have an
+   argument, it follows the option name in the same ARGV-element, separated
+   from the option name by a `=', or else the in next ARGV-element.
+   When `getopt' finds a long-named option, it returns 0 if that option's
+   `flag' field is nonzero, the value of the option's `val' field
+   if the `flag' field is zero.
+
+   The elements of ARGV aren't really const, because we MONKEY_CRYPTO_random_permute them.
+   But we pretend they're const in the prototype to be compatible
+   with other systems.
+
+   LONGOPTS is a vector of `struct GNoption' terminated by an
+   element containing a name which is zero.
+
+   LONGIND returns the index in LONGOPT of the long-named option found.
+   It is only valid when a long-named option has been found by the most
+   recent call.
+
+   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+   long-named options.  */
+
+static int
+GN_getopt_internal (int argc, char *const *argv, const char *optstring,
+                    const struct GNoption *longopts, int *longind,
+                    int long_only)
+{
+  static int __getopt_initialized = 0;
+  static int GNopterr = 1;
+
+  GNoptarg = NULL;
+
+  if (GNoptind == 0 || !__getopt_initialized)
+  {
+    if (GNoptind == 0)
+      GNoptind = 1;             /* Don't scan ARGV[0], the program name.  */
+    optstring = _getopt_initialize (argc, argv, optstring);
+    __getopt_initialized = 1;
+  }
+
+  /* Test whether ARGV[GNoptind] points to a non-option argument.
+   * Either it does not have option syntax, or there is an environment flag
+   * from the shell indicating it is not an option.  The later information
+   * is only used when the used in the GNU libc.  */
+#ifdef _LIBC
+#define NONOPTION_P (argv[GNoptind][0] != '-' || argv[GNoptind][1] == '\0'        \
+             || (GNoptind < nonoption_flags_len                       \
+                 && __getopt_nonoption_flags[GNoptind] == '1'))
+#else
+#define NONOPTION_P (argv[GNoptind][0] != '-' || argv[GNoptind][1] == '\0')
+#endif
+
+  if (nextchar == NULL || *nextchar == '\0')
+  {
+    /* Advance to the next ARGV-element.  */
+
+    /* Give FIRST_NONOPT & LAST_NONOPT rational values if GNoptind has been
+     * moved back by the user (who may also have changed the arguments).  */
+    if (last_nonopt > GNoptind)
+      last_nonopt = GNoptind;
+    if (first_nonopt > GNoptind)
+      first_nonopt = GNoptind;
+
+    if (ordering == PERMUTE)
+    {
+      /* If we have just processed some options following some non-options,
+       * exchange them so that the options come first.  */
+
+      if (first_nonopt != last_nonopt && last_nonopt != GNoptind)
+        exchange ((char **) argv);
+      else if (last_nonopt != GNoptind)
+        first_nonopt = GNoptind;
+
+      /* Skip any additional non-options
+       * and extend the range of non-options previously skipped.  */
+
+      while (GNoptind < argc && NONOPTION_P)
+        GNoptind++;
+      last_nonopt = GNoptind;
+    }
+
+    /* The special ARGV-element `--' means premature end of options.
+     * Skip it like a null option,
+     * then exchange with previous non-options as if it were an option,
+     * then skip everything else like a non-option.  */
+    if (GNoptind != argc && !strcmp (argv[GNoptind], "--"))
+    {
+      GNoptind++;
+
+      if (first_nonopt != last_nonopt && last_nonopt != GNoptind)
+        exchange ((char **) argv);
+      else if (first_nonopt == last_nonopt)
+        first_nonopt = GNoptind;
+      last_nonopt = argc;
+
+      GNoptind = argc;
+    }
+
+    /* If we have done all the ARGV-elements, stop the scan
+     * and back over any non-options that we skipped and permuted.  */
+
+    if (GNoptind == argc)
+    {
+      /* Set the next-arg-index to point at the non-options
+       * that we previously skipped, so the caller will digest them.  */
+      if (first_nonopt != last_nonopt)
+        GNoptind = first_nonopt;
+      return -1;
+    }
+
+    /* If we have come to a non-option and did not permute it,
+     * either stop the scan or describe it to the caller and pass it by.  */
+
+    if (NONOPTION_P)
+    {
+      if (ordering == REQUIRE_ORDER)
+        return -1;
+      GNoptarg = argv[GNoptind++];
+      return 1;
+    }
+
+    /* We have found another option-ARGV-element.
+     * Skip the initial punctuation.  */
+
+    nextchar =
+        (argv[GNoptind] + 1 + (longopts != NULL && argv[GNoptind][1] == '-'));
+  }
+
+  /* Decode the current option-ARGV-element.  */
+
+  /* Check whether the ARGV-element is a long option.
+   *
+   * If long_only and the ARGV-element has the form "-f", where f is
+   * a valid short option, don't consider it an abbreviated form of
+   * a long option that starts with f.  Otherwise there would be no
+   * way to give the -f short option.
+   *
+   * On the other hand, if there's a long option "fubar" and
+   * the ARGV-element is "-fu", do consider that an abbreviation of
+   * the long option, just like "--fu", and not "-f" with arg "u".
+   *
+   * This distinction seems to be the most useful approach.  */
+
+  if (longopts != NULL &&
+      (argv[GNoptind][1] == '-' ||
+       (long_only &&
+        (argv[GNoptind][2] || !my_index (optstring, argv[GNoptind][1])))))
+  {
+    char *nameend;
+    const struct GNoption *p;
+    const struct GNoption *pfound = NULL;
+    int exact = 0;
+    int ambig = 0;
+    int indfound = -1;
+    int option_index;
+
+    for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+      /* Do nothing.  */ ;
+
+    /* Test all long options for either exact match
+     * or abbreviated matches.  */
+    for (p = longopts, option_index = 0; p->name; p++, option_index++)
+      if (!strncmp (p->name, nextchar, nameend - nextchar))
+      {
+        if ((unsigned int) (nameend - nextchar) ==
+            (unsigned int) strlen (p->name))
+        {
+          /* Exact match found.  */
+          pfound = p;
+          indfound = option_index;
+          exact = 1;
+          break;
+        }
+        else if (pfound == NULL)
+        {
+          /* First nonexact match found.  */
+          pfound = p;
+          indfound = option_index;
+        }
+        else
+          /* Second or later nonexact match found.  */
+          ambig = 1;
+      }
+
+    if (ambig && !exact)
+    {
+      if (GNopterr)
+        FPRINTF (stderr, _("%s: option `%s' is ambiguous\n"), argv[0],
+                 argv[GNoptind]);
+      nextchar += strlen (nextchar);
+      GNoptind++;
+      return '?';
+    }
+
+    if (pfound != NULL)
+    {
+      option_index = indfound;
+      GNoptind++;
+      if (*nameend)
+      {
+        /* Don't test has_arg with >, because some C compilers don't
+         * allow it to be used on enums.  */
+        if (pfound->has_arg)
+          GNoptarg = nameend + 1;
+        else
+        {
+          if (GNopterr)
+          {
+            if (argv[GNoptind - 1][1] == '-')
+              /* --option */
+              FPRINTF (stderr,
+                       _("%s: option `--%s' does not allow an argument\n"),
+                       argv[0], pfound->name);
+            else
+              /* +option or -option */
+              FPRINTF (stderr,
+                       _("%s: option `%c%s' does not allow an argument\n"),
+                       argv[0], argv[GNoptind - 1][0], pfound->name);
+          }
+          nextchar += strlen (nextchar);
+          return '?';
+        }
+      }
+      else if (pfound->has_arg == 1)
+      {
+        if (GNoptind < argc)
+        {
+          GNoptarg = argv[GNoptind++];
+        }
+        else
+        {
+          if (GNopterr)
+          {
+            FPRINTF (stderr, _("%s: option `%s' requires an argument\n"),
+                     argv[0], argv[GNoptind - 1]);
+          }
+          nextchar += strlen (nextchar);
+          return (optstring[0] == ':') ? ':' : '?';
+        }
+      }
+      nextchar += strlen (nextchar);
+      if (longind != NULL)
+        *longind = option_index;
+      if (pfound->flag)
+      {
+        *(pfound->flag) = pfound->val;
+        return 0;
+      }
+      return pfound->val;
+    }
+
+    /* Can't find it as a long option.  If this is not getopt_long_only,
+     * or the option starts with '--' or is not a valid short
+     * option, then it's an error.
+     * Otherwise interpret it as a short option.  */
+    if (!long_only || argv[GNoptind][1] == '-' ||
+        my_index (optstring, *nextchar) == NULL)
+    {
+      if (GNopterr)
+      {
+        if (argv[GNoptind][1] == '-')
+          /* --option */
+          FPRINTF (stderr, _("%s: unrecognized option `--%s'\n"), argv[0],
+                   nextchar);
+        else
+          /* +option or -option */
+          FPRINTF (stderr, _("%s: unrecognized option `%c%s'\n"), argv[0],
+                   argv[GNoptind][0], nextchar);
+      }
+      nextchar = (char *) "";
+      GNoptind++;
+      return '?';
+    }
+  }
+
+  /* Look at and handle the next short option-character.  */
+
+  {
+    char c = *nextchar++;
+    char *temp = my_index (optstring, c);
+
+    /* Increment `GNoptind' when we start to process its last character.  */
+    if (*nextchar == '\0')
+      ++GNoptind;
+
+    if (temp == NULL || c == ':')
+    {
+      if (GNopterr)
+      {
+        if (posixly_correct)
+          /* 1003.2 specifies the format of this message.  */
+          FPRINTF (stderr, _("%s: illegal option -- %c\n"), argv[0], c);
+        else
+          FPRINTF (stderr, _("%s: invalid option -- %c\n"), argv[0], c);
+      }
+      return '?';
+    }
+    /* Convenience. Treat POSIX -W foo same as long option --foo */
+    if (temp[0] == 'W' && temp[1] == ';')
+    {
+      char *nameend;
+      const struct GNoption *p;
+      const struct GNoption *pfound = NULL;
+      int exact = 0;
+      int ambig = 0;
+      int indfound = 0;
+      int option_index;
+
+      /* This is an option that requires an argument.  */
+      if (*nextchar != '\0')
+      {
+        GNoptarg = nextchar;
+        /* If we end this ARGV-element by taking the rest as an arg,
+         * we must advance to the next element now.  */
+        GNoptind++;
+      }
+      else if (GNoptind == argc)
+      {
+        if (GNopterr)
+        {
+          /* 1003.2 specifies the format of this message.  */
+          FPRINTF (stderr, _("%s: option requires an argument -- %c\n"),
+                   argv[0], c);
+        }
+        if (optstring[0] == ':')
+          c = ':';
+        else
+          c = '?';
+        return c;
+      }
+      else
+        /* We already incremented `GNoptind' once;
+         * increment it again when taking next ARGV-elt as argument.  */
+        GNoptarg = argv[GNoptind++];
+
+      /* GNoptarg is now the argument, see if it's in the
+       * table of longopts.  */
+
+      for (nextchar = nameend = GNoptarg; *nameend && *nameend != '=';
+           nameend++)
+        /* Do nothing.  */ ;
+
+      /* Test all long options for either exact match
+       * or abbreviated matches.  */
+      if (longopts != NULL)
+        for (p = longopts, option_index = 0; p->name; p++, option_index++)
+          if (!strncmp (p->name, nextchar, nameend - nextchar))
+          {
+            if ((unsigned int) (nameend - nextchar) == strlen (p->name))
+            {
+              /* Exact match found.  */
+              pfound = p;
+              indfound = option_index;
+              exact = 1;
+              break;
+            }
+            else if (pfound == NULL)
+            {
+              /* First nonexact match found.  */
+              pfound = p;
+              indfound = option_index;
+            }
+            else
+              /* Second or later nonexact match found.  */
+              ambig = 1;
+          }
+      if (ambig && !exact)
+      {
+        if (GNopterr)
+          FPRINTF (stderr, _("%s: option `-W %s' is ambiguous\n"), argv[0],
+                   argv[GNoptind]);
+        nextchar += strlen (nextchar);
+        GNoptind++;
+        return '?';
+      }
+      if (pfound != NULL)
+      {
+        option_index = indfound;
+        if (*nameend)
+        {
+          /* Don't test has_arg with >, because some C compilers don't
+           * allow it to be used on enums.  */
+          if (pfound->has_arg)
+            GNoptarg = nameend + 1;
+          else
+          {
+            if (GNopterr)
+              FPRINTF (stderr, _("\
+%s: option `-W %s' does not allow an argument\n"), argv[0], pfound->name);
+
+            nextchar += strlen (nextchar);
+            return '?';
+          }
+        }
+        else if (pfound->has_arg == 1)
+        {
+          if (GNoptind < argc)
+            GNoptarg = argv[GNoptind++];
+          else
+          {
+            if (GNopterr)
+              FPRINTF (stderr, _("%s: option `%s' requires an argument\n"),
+                       argv[0], argv[GNoptind - 1]);
+            nextchar += strlen (nextchar);
+            return optstring[0] == ':' ? ':' : '?';
+          }
+        }
+        nextchar += strlen (nextchar);
+        if (longind != NULL)
+          *longind = option_index;
+        if (pfound->flag)
+        {
+          *(pfound->flag) = pfound->val;
+          return 0;
+        }
+        return pfound->val;
+      }
+      nextchar = NULL;
+      return 'W';               /* Let the application handle it.   */
+    }
+    if (temp[1] == ':')
+    {
+      if (temp[2] == ':')
+      {
+        /* This is an option that accepts an argument optionally.  */
+        if (*nextchar != '\0')
+        {
+          GNoptarg = nextchar;
+          GNoptind++;
+        }
+        else
+          GNoptarg = NULL;
+        nextchar = NULL;
+      }
+      else
+      {
+        /* This is an option that requires an argument.  */
+        if (*nextchar != '\0')
+        {
+          GNoptarg = nextchar;
+          /* If we end this ARGV-element by taking the rest as an arg,
+           * we must advance to the next element now.  */
+          GNoptind++;
+        }
+        else if (GNoptind == argc)
+        {
+          if (GNopterr)
+          {
+            /* 1003.2 specifies the format of this message.  */
+            FPRINTF (stderr, _("%s: option requires an argument -- %c\n"),
+                     argv[0], c);
+          }
+          if (optstring[0] == ':')
+            c = ':';
+          else
+            c = '?';
+        }
+        else
+          /* We already incremented `GNoptind' once;
+           * increment it again when taking next ARGV-elt as argument.  */
+          GNoptarg = argv[GNoptind++];
+        nextchar = NULL;
+      }
+    }
+    return c;
+  }
+}
+
+static int
+GNgetopt_long (int argc, char *const *argv, const char *options,
+               const struct GNoption *long_options, int *opt_index)
+{
+  return GN_getopt_internal (argc, argv, options, long_options, opt_index, 0);
+}
+
+/* ******************** now the GNUnet specific modifications... ********************* */
+
+/**
+ * Parse the command line.
+ *
+ * @param binaryOptions Name of application with option summary
+ * @param allOptions defined options and handlers
+ * @param argc number of arguments
+ * @param argv actual arguments
+ * @return index into argv with first non-option
+ *   argument, or -1 on error
+ */
+int
+MONKEY_GETOPT_run (const char *binaryOptions,
+                   const struct MONKEY_GETOPT_CommandLineOption *allOptions,
+                   unsigned int argc, char *const *argv)
+{
+  struct GNoption *long_options;
+  struct MONKEY_GETOPT_CommandLineProcessorContext clpc;
+  int count;
+  int i;
+  char *shorts;
+  int spos;
+  int cont;
+  int c;
+
+//  MONKEY_assert (argc > 0);
+  GNoptind = 0;
+  clpc.binaryName = argv[0];
+  clpc.binaryOptions = binaryOptions;
+  clpc.allOptions = allOptions;
+  clpc.argv = argv;
+  clpc.argc = argc;
+  count = 0;
+  while (allOptions[count].name != NULL)
+    count++;
+  long_options = malloc (sizeof (struct GNoption) * (count + 1));
+  shorts = malloc (count * 2 + 1);
+  spos = 0;
+  for (i = 0; i < count; i++)
+  {
+    long_options[i].name = allOptions[i].name;
+    long_options[i].has_arg = allOptions[i].require_argument;
+    long_options[i].flag = NULL;
+    long_options[i].val = allOptions[i].shortName;
+    shorts[spos++] = allOptions[i].shortName;
+    if (allOptions[i].require_argument != 0)
+      shorts[spos++] = ':';
+  }
+  long_options[count].name = NULL;
+  long_options[count].has_arg = 0;
+  long_options[count].flag = NULL;
+  long_options[count].val = '\0';
+  shorts[spos] = '\0';
+  cont = MONKEY_OK;
+  /* main getopt loop */
+  while (cont == MONKEY_OK)
+  {
+    int option_index = 0;
+
+    c = GNgetopt_long (argc, argv, shorts, long_options, &option_index);
+
+    if (c == MONKEY_SYSERR)
+      break;                    /* No more flags to process */
+
+    for (i = 0; i < count; i++)
+    {
+      clpc.currentArgument = GNoptind - 1;
+      if ((char) c == allOptions[i].shortName)
+      {
+        cont =
+            allOptions[i].processor (&clpc, allOptions[i].scls,
+                                     allOptions[i].name, GNoptarg);
+        break;
+      }
+    }
+    if (i == count)
+    {
+      FPRINTF (stderr, _("Use %s to get a list of options.\n"), "--help");
+      cont = MONKEY_SYSERR;
+    }
+  }
+
+  free (shorts);
+  free (long_options);
+  if (cont == MONKEY_SYSERR)
+    return MONKEY_SYSERR;
+  return GNoptind;
+}
+
+/* end of getopt.c */
diff --git a/pathologist/src/pathologist/getopt_helpers.c b/pathologist/src/pathologist/getopt_helpers.c
new file mode 100644
index 0000000..50d02d8
--- /dev/null
+++ b/pathologist/src/pathologist/getopt_helpers.c
@@ -0,0 +1,294 @@
+/*
+     This file is part of GNUnet
+     (C) 2006, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file src/util/getopt_helpers.c
+ * @brief implements command line that sets option
+ * @author Christian Grothoff
+ */
+
+#include <string.h>
+#include "platform.h"
+#include "monkey_common.h"
+#include "monkey_getopt_lib.h"
+
+#define LOG(kind,...) MONKEY_log_from (kind, "util", __VA_ARGS__)
+
+
+/**
+ * Print out program version (implements --version).
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (points to version string)
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_SYSERR (do not continue)
+ */
+int
+MONKEY_GETOPT_print_version_ (struct MONKEY_GETOPT_CommandLineProcessorContext
+                              *ctx, void *scls, const char *option,
+                              const char *value)
+{
+  const char *version = scls;
+
+  printf ("%s v%s\n", ctx->binaryName, version);
+  return MONKEY_SYSERR;
+}
+
+
+
+#define BORDER 29
+
+/**
+ * Print out details on command line options (implements --help).
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (points to about text)
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_SYSERR (do not continue)
+ */
+int
+MONKEY_GETOPT_format_help_ (struct MONKEY_GETOPT_CommandLineProcessorContext
+                            *ctx, void *scls, const char *option,
+                            const char *value)
+{
+  const char *about = scls;
+  size_t slen;
+  unsigned int i;
+  int j;
+  size_t ml;
+  size_t p;
+  char *scp;
+  const char *trans;
+  const struct MONKEY_GETOPT_CommandLineOption *opt;
+
+  if (NULL != about)
+  {
+    printf ("%s\n%s\n", ctx->binaryOptions, about);
+    printf ("Arguments mandatory for long options are also mandatory for short options.\n");
+  }
+  i = 0;
+  opt = ctx->allOptions;
+  while (opt[i].description != NULL)
+  {
+    if (opt[i].shortName == '\0')
+      printf ("      ");
+    else
+      printf ("  -%c, ", opt[i].shortName);
+    printf ("--%s", opt[i].name);
+    slen = 8 + strlen (opt[i].name);
+    if (opt[i].argumentHelp != NULL)
+    {
+      printf ("=%s", opt[i].argumentHelp);
+      slen += 1 + strlen (opt[i].argumentHelp);
+    }
+    if (slen > BORDER)
+    {
+      printf ("\n%*s", BORDER, "");
+      slen = BORDER;
+    }
+    if (slen < BORDER)
+    {
+      printf ("%*s", (int) (BORDER - slen), "");
+      slen = BORDER;
+    }
+    if (0 < strlen (opt[i].description))
+      trans = opt[i].description;
+    else
+      trans = "";
+    ml = strlen (trans);
+    p = 0;
+OUTER:
+    while (ml - p > 78 - slen)
+    {
+      for (j = p + 78 - slen; j > p; j--)
+      {
+        if (isspace ((unsigned char) trans[j]))
+        {
+          scp = malloc (j - p + 1);
+          memcpy (scp, &trans[p], j - p);
+          scp[j - p] = '\0';
+          printf ("%s\n%*s", scp, BORDER + 2, "");
+          free (scp);
+          p = j + 1;
+          slen = BORDER + 2;
+          goto OUTER;
+        }
+      }
+      /* could not find space to break line */
+      scp = malloc (78 - slen + 1);
+      memcpy (scp, &trans[p], 78 - slen);
+      scp[78 - slen] = '\0';
+      printf ("%s\n%*s", scp, BORDER + 2, "");
+      free (scp);
+      slen = BORDER + 2;
+      p = p + 78 - slen;
+    }
+    /* print rest */
+    if (p < ml)
+      printf ("%s\n", &trans[p]);
+    if (strlen (trans) == 0)
+      printf ("\n");
+    i++;
+  }
+  printf ("Report bugs to gnunet-developers@gnu.org.\n"
+          "GNUnet home page: http://www.gnu.org/software/gnunet/\n"
+          "General help using GNU software: http://www.gnu.org/gethelp/\n");
+  return MONKEY_SYSERR;
+}
+
+
+/**
+ * Set an option of type 'unsigned int' from the command line. Each
+ * time the option flag is given, the value is incremented by one.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'int'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'int')
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_OK
+ */
+int
+MONKEY_GETOPT_increment_value (struct MONKEY_GETOPT_CommandLineProcessorContext
+                               *ctx, void *scls, const char *option,
+                               const char *value)
+{
+  int *val = scls;
+
+  (*val)++;
+  return MONKEY_OK;
+}
+
+
+/**
+ * Set an option of type 'int' from the command line to 1 if the
+ * given option is present.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'int'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'int')
+ * @param option name of the option
+ * @param value not used (NULL)
+ * @return MONKEY_OK
+ */
+int
+MONKEY_GETOPT_set_one (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                       void *scls, const char *option, const char *value)
+{
+  int *val = scls;
+
+  *val = 1;
+  return MONKEY_OK;
+}
+
+
+/**
+ * Set an option of type 'char *' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'char *'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'char *',
+ *             which will be allocated)
+ * @param option name of the option
+ * @param value actual value of the option (a string)
+ * @return MONKEY_OK
+ */
+int
+MONKEY_GETOPT_set_string (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                          void *scls, const char *option, const char *value)
+{
+  char **val = scls;
+
+//  MONKEY_assert (value != NULL);
+//  MONKEY_free_non_null (*val);
+  if(*val != NULL) free(*val);
+  *val = strdup (value);
+  return MONKEY_OK;
+}
+
+
+/**
+ * Set an option of type 'unsigned long long' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'unsigned long long'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'unsigned long long')
+ * @param option name of the option
+ * @param value actual value of the option as a string.
+ * @return MONKEY_OK if parsing the value worked
+ */
+int
+MONKEY_GETOPT_set_ulong (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                         void *scls, const char *option, const char *value)
+{
+  unsigned long long *val = scls;
+
+  if (1 != SSCANF (value, "%llu", val))
+  {
+    FPRINTF (stderr, "You must pass a number to the `%s' option.\n", option);
+    return MONKEY_SYSERR;
+  }
+  return MONKEY_OK;
+}
+
+
+/**
+ * Set an option of type 'unsigned int' from the command line.
+ * A pointer to this function should be passed as part of the
+ * 'struct MONKEY_GETOPT_CommandLineOption' array to initialize options
+ * of this type.  It should be followed by a pointer to a value of
+ * type 'unsigned int'.
+ *
+ * @param ctx command line processing context
+ * @param scls additional closure (will point to the 'unsigned int')
+ * @param option name of the option
+ * @param value actual value of the option as a string.
+ * @return MONKEY_OK if parsing the value worked
+ */
+int
+MONKEY_GETOPT_set_uint (struct MONKEY_GETOPT_CommandLineProcessorContext *ctx,
+                        void *scls, const char *option, const char *value)
+{
+  unsigned int *val = scls;
+
+  if (1 != SSCANF (value, "%u", val))
+  {
+    FPRINTF (stderr, "You must pass a number to the `%s' option.\n", option);
+    return MONKEY_SYSERR;
+  }
+  return MONKEY_OK;
+}
+
+
+/* end of getopt_helpers.c */
diff --git a/pathologist/src/pathologist/mail_sender.c b/pathologist/src/pathologist/mail_sender.c
new file mode 100644
index 0000000..98edf84
--- /dev/null
+++ b/pathologist/src/pathologist/mail_sender.c
@@ -0,0 +1,231 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <string.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <errno.h>
+#include <stdarg.h>
+
+#include <openssl/ssl.h>
+#include <auth-client.h>
+#include <libesmtp.h>
+
+#if !defined (__GNUC__) || __GNUC__ < 2
+# define __attribute__(x)
+#endif
+
+
+int
+handle_invalid_peer_certificate(long vfy_result)
+{
+  const char *k ="rare error";
+  switch(vfy_result) {
+  case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
+    k="X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT"; break;
+  case X509_V_ERR_UNABLE_TO_GET_CRL:
+    k="X509_V_ERR_UNABLE_TO_GET_CRL"; break;
+  case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
+    k="X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE"; break;
+  case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
+    k="X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE"; break;
+  case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
+    k="X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY"; break;
+  case X509_V_ERR_CERT_SIGNATURE_FAILURE:
+    k="X509_V_ERR_CERT_SIGNATURE_FAILURE"; break;
+  case X509_V_ERR_CRL_SIGNATURE_FAILURE:
+    k="X509_V_ERR_CRL_SIGNATURE_FAILURE"; break;
+  case X509_V_ERR_CERT_NOT_YET_VALID:
+    k="X509_V_ERR_CERT_NOT_YET_VALID"; break;
+  case X509_V_ERR_CERT_HAS_EXPIRED:
+    k="X509_V_ERR_CERT_HAS_EXPIRED"; break;
+  case X509_V_ERR_CRL_NOT_YET_VALID:
+    k="X509_V_ERR_CRL_NOT_YET_VALID"; break;
+  case X509_V_ERR_CRL_HAS_EXPIRED:
+    k="X509_V_ERR_CRL_HAS_EXPIRED"; break;
+  case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
+    k="X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD"; break;
+  case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
+    k="X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD"; break;
+  case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:
+    k="X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD"; break;
+  case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
+    k="X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD"; break;
+  case X509_V_ERR_OUT_OF_MEM:
+    k="X509_V_ERR_OUT_OF_MEM"; break;
+  case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
+    k="X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT"; break;
+  case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
+    k="X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN"; break;
+  case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
+    k="X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY"; break;
+  case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
+    k="X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE"; break;
+  case X509_V_ERR_CERT_CHAIN_TOO_LONG:
+    k="X509_V_ERR_CERT_CHAIN_TOO_LONG"; break;
+  case X509_V_ERR_CERT_REVOKED:
+    k="X509_V_ERR_CERT_REVOKED"; break;
+  case X509_V_ERR_INVALID_CA:
+    k="X509_V_ERR_INVALID_CA"; break;
+  case X509_V_ERR_PATH_LENGTH_EXCEEDED:
+    k="X509_V_ERR_PATH_LENGTH_EXCEEDED"; break;
+  case X509_V_ERR_INVALID_PURPOSE:
+    k="X509_V_ERR_INVALID_PURPOSE"; break;
+  case X509_V_ERR_CERT_UNTRUSTED:
+    k="X509_V_ERR_CERT_UNTRUSTED"; break;
+  case X509_V_ERR_CERT_REJECTED:
+    k="X509_V_ERR_CERT_REJECTED"; break;
+  }
+  printf("SMTP_EV_INVALID_PEER_CERTIFICATE: %ld: %s\n", vfy_result, k);
+  return 1; /* Accept the problem */
+}
+
+
+void event_cb (smtp_session_t session, int event_no, void *arg,...)
+{
+  va_list alist;
+  int *ok;
+
+  va_start(alist, arg);
+  switch(event_no) {
+  case SMTP_EV_CONNECT: 
+  case SMTP_EV_MAILSTATUS:
+  case SMTP_EV_RCPTSTATUS:
+  case SMTP_EV_MESSAGEDATA:
+  case SMTP_EV_MESSAGESENT:
+  case SMTP_EV_DISCONNECT: break;
+  case SMTP_EV_WEAK_CIPHER: {
+    int bits;
+    bits = va_arg(alist, long); ok = va_arg(alist, int*);
+    printf("SMTP_EV_WEAK_CIPHER, bits=%d - accepted.\n", bits);
+    *ok = 1; break;
+  }
+  case SMTP_EV_STARTTLS_OK:
+    puts("SMTP_EV_STARTTLS_OK - TLS started here."); break;
+  case SMTP_EV_INVALID_PEER_CERTIFICATE: {
+    long vfy_result;
+    vfy_result = va_arg(alist, long); ok = va_arg(alist, int*);
+    *ok = handle_invalid_peer_certificate(vfy_result);
+    break;
+  }
+  case SMTP_EV_NO_PEER_CERTIFICATE: {
+    ok = va_arg(alist, int*); 
+    puts("SMTP_EV_NO_PEER_CERTIFICATE - accepted.");
+    *ok = 1; break;
+  }
+  case SMTP_EV_WRONG_PEER_CERTIFICATE: {
+    ok = va_arg(alist, int*);
+    puts("SMTP_EV_WRONG_PEER_CERTIFICATE - accepted.");
+    *ok = 1; break;
+  }
+  case SMTP_EV_NO_CLIENT_CERTIFICATE: {
+    ok = va_arg(alist, int*); 
+    puts("SMTP_EV_NO_CLIENT_CERTIFICATE - accepted.");
+    *ok = 1; break;
+  }
+  default:
+    printf("Got event: %d - ignored.\n", event_no);
+  }
+  va_end(alist);
+}
+
+
+/* Callback to prnt the recipient status */
+void
+print_recipient_status (smtp_recipient_t recipient,
+                        const char *mailbox, void *arg)
+{
+  const smtp_status_t *status;
+
+  status = smtp_recipient_status (recipient);
+  printf ("%s: %d %s", mailbox, status->code, status->text);
+}
+
+
+void sendMail(const char *messageContents, const char* reportFileName, const char *emailAddress)
+{
+        smtp_session_t session;
+        smtp_message_t message;
+        smtp_recipient_t recipient;
+        const smtp_status_t *status;
+        struct sigaction sa;
+        char *host = "localhost:25";
+        char *from = "monkey@gnunet.org";
+        char *subject = "Monkey bug report";
+        const char *recipient_address = emailAddress;
+        char tempFileName[1000];
+        int tempFd;
+        FILE *fp;
+        enum notify_flags notify = Notify_SUCCESS | Notify_FAILURE;
+
+        auth_client_init();
+        session = smtp_create_session();
+        message = smtp_add_message(session);
+        
+        /* Ignore sigpipe */
+        sa.sa_handler = SIG_IGN;
+        sigemptyset(&sa.sa_mask);
+        sa.sa_flags = 0;
+        sigaction(SIGPIPE, &sa, NULL);
+        
+        
+        smtp_set_server(session, host);
+        smtp_set_eventcb(session, event_cb, NULL);
+
+        /* Set the reverse path for the mail envelope.  (NULL is ok)
+         */
+        smtp_set_reverse_path(message, from);
+
+        /* Set the Subject: header.  For no reason, we want the supplied subject
+         to override any subject line in the message headers. */
+        if (subject != NULL) {
+                smtp_set_header(message, "Subject", subject);
+                smtp_set_header_option(message, "Subject", Hdr_OVERRIDE, 1);
+        }
+
+        
+        /* Prepare message */
+        if (NULL == reportFileName) {
+                memset(tempFileName, 0, sizeof(tempFileName));
+                sprintf(tempFileName, "/tmp/messageXXXXXX");
+                tempFd = mkstemp(tempFileName);
+                fp = fdopen(tempFd, "w");
+                fprintf(fp, "%s", messageContents);
+                fclose(fp);
+                fp = fopen(tempFileName, "r");
+                smtp_set_message_fp(message, fp);
+        } else {
+                fp = fopen(reportFileName, "r");
+                smtp_set_message_fp(message, fp);
+        }
+
+        
+        recipient = smtp_add_recipient(message, recipient_address);
+
+        smtp_dsn_set_notify (recipient, notify);
+        
+        /* Initiate a connection to the SMTP server and transfer the
+         message. */
+        if (!smtp_start_session(session)) {
+                char buf[128];
+
+                fprintf(stderr, "SMTP server problem %s\n", smtp_strerror(smtp_errno(),
+                                buf, sizeof buf));
+        } else {
+                /* Report on the success or otherwise of the mail transfer.
+                 */
+                status = smtp_message_transfer_status(message);
+                printf("%d %s", status->code, (status->text != NULL) ? status->text
+                                : "\n");
+                smtp_enumerate_recipients(message, print_recipient_status, NULL);
+        }
+
+        /* Free resources consumed by the program.
+         */
+        smtp_destroy_session(session);
+        fclose(fp);
+        auth_client_exit();
+}
+
diff --git a/pathologist/src/pathologist/pathologist.c b/pathologist/src/pathologist/pathologist.c
new file mode 100644
index 0000000..305c3ce
--- /dev/null
+++ b/pathologist/src/pathologist/pathologist.c
@@ -0,0 +1,357 @@
+/*
+     This file is part of GNUnet.
+     (C) 2010, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 3, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file pathologist/pathologist.c
+ * @brief Monkey Pathologist: automated debugging tool
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include "monkey_common.h"
+#include "action.h"
+#include "monkey_getopt_lib.h"
+
+static char *dumpFileName;
+static char *binaryName;
+static char *command;
+static char *binaryArgs;
+static char *emailAddress;
+static char *edbFilePath;
+static char *gdbBinaryPath;
+static char *valgrindBinaryPath;
+static char *inspectExpression;
+static char *inspectFunction;
+static int scopeDepth;
+static int reverseExecutionAllowed = MONKEY_NO;
+static int ret = 0;
+
+static int checkFileExistence(const char *filePath) {
+        struct stat statBuff;
+        if (0 == stat(filePath, &statBuff)) {
+                return MONKEY_YES;
+        }
+        return MONKEY_NO;
+}
+
+
+static int checkELF(const char *binaryPath) {
+        int ch;
+        const char ELF[5] = {0x7f, 'E', 'L', 'F', '\0'}; // ELF magic number
+        char inputArr[5];
+        FILE *filePtr;
+        filePtr = fopen(binaryPath, "r");
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                ch = fgetc(filePtr);
+                if (EOF == ch) {
+                        return MONKEY_NO;
+                }
+                inputArr[i] = ch;
+        }
+        inputArr[4] = '\0';
+        if (strcmp(ELF, inputArr) == 0) {
+                return MONKEY_YES;
+        }
+        return MONKEY_NO;
+}
+/**
+ * Main function that will launch Pathologist's action api.
+*/
+static void run()
+{
+        int result;
+        struct MONKEY_ACTION_Context *cntxt;
+
+        /* Check files existence */
+        if (MONKEY_NO == checkFileExistence(binaryName)) {
+                fprintf(stderr, "Error: Target binary file does not exist.\n");
+                ret = 1;
+                return;
+        }
+
+        if (MONKEY_NO == checkFileExistence(edbFilePath)) {
+                fprintf(stderr, "Error: Expression database file does not exist.\n");
+                ret = 1;
+                return;
+        }
+
+        if (NULL != gdbBinaryPath &&
+                MONKEY_NO == checkFileExistence(gdbBinaryPath))
+        {
+                fprintf(stderr, "Error: gdb binary file does not exist.\n");
+                ret = 1;
+                return;
+                
+        }
+
+        if (NULL != valgrindBinaryPath &&
+                MONKEY_NO == checkFileExistence(valgrindBinaryPath))
+        {
+                fprintf(stderr, "Error: valgrind binary file does not exist.\n");
+                ret = 1;
+                return;
+        }
+
+        /* Check if the target program is and ELF binary */
+        if (MONKEY_NO == checkELF(binaryName)) {
+                FILE* targetProgramPipe;
+                char buffer[128];
+                ret = 1;
+
+                fprintf(stderr, "Target program is not an ELF. Pathologist will not debug the program.\n");
+                fprintf(stderr, "Pathologist will attempt to run the program normally.\n");
+
+                targetProgramPipe = popen(command, "r");
+                if (NULL == targetProgramPipe) {
+                        fprintf(stderr, "Target is not a binary.\n");
+                        return;
+                }
+                while(!feof(targetProgramPipe)) {
+                        if (NULL != fgets(buffer, 128, targetProgramPipe)) {
+                                fputs(buffer, stderr);
+                        }
+                }
+                pclose(targetProgramPipe);
+                return;
+        }
+
+        if (NULL == edbFilePath)
+        {
+                /* lookup a file named test.db in the working directory */
+                struct stat buf;
+                if (0 != stat ("test.db", &buf))
+                {
+                        fprintf( stderr,
+                        "Expression Database file was not provided as and argument, "
+                        "and there is no file named test.db in pathologist's working directory!\n");
+                        MONKEY_break (0);
+                        ret = 1;
+                        return;
+                }
+        }
+
+        if (NULL == dumpFileName)
+        {
+                /* if no file name provided for the output report, the default report name will be binaryName_PIDpid */
+                const char *bn = strrchr(binaryName, '/');
+                if (NULL == bn) {
+                        bn = binaryName;
+                } else {
+                        bn++;
+                }
+                MONKEY_asprintf(&dumpFileName, "%s_PID%d", bn, getpid());
+        }
+
+        /* Initialize context for the Action API */
+        cntxt = MONKEY_malloc (sizeof (struct MONKEY_ACTION_Context));
+        cntxt->email_address = emailAddress;
+        cntxt->binary_name = binaryName;
+        cntxt->binaryArgs = binaryArgs;
+        cntxt->expression_database_path = edbFilePath;
+        cntxt->gdb_binary_path = gdbBinaryPath;
+        cntxt->valgrind_binary_path = valgrindBinaryPath;
+        cntxt->inspect_expression = inspectExpression;
+        cntxt->inspect_function = inspectFunction;
+        cntxt->scope_depth = scopeDepth;
+        cntxt->bug_detected = NO_BUG_DETECTED;
+        cntxt->has_null = MONKEY_NO;
+        cntxt->xml_report_node = NULL;
+        cntxt->run_reverse = reverseExecutionAllowed;
+        cntxt->gdb_connected = MONKEY_NO;
+
+        result = MONKEY_ACTION_rerun_with_gdb (cntxt);
+        int retVal;
+        switch (result)
+        {
+        case MONKEY_NO:
+        case GDB_STATE_ERROR:
+                fprintf (stderr, "Error in using gdb. Pathologist will exit now!\n");
+                ret = 1;
+                break;
+        case GDB_STATE_EXIT_NORMALLY:
+                fprintf (stderr, "Debug with gdb, program exited normally!\n");
+                break;
+        case GDB_STATE_STOPPED:
+                //categorize bug
+                if ((strcasecmp(cntxt->gdb_stop_reason->signal_meaning, "Segmentation fault") == 0)
+                 || (strcasecmp(cntxt->gdb_stop_reason->signal_meaning, "Signal 0") == 0))
+                        cntxt->bug_detected = MONKEY_ACTION_is_Nullpointer(cntxt) ? BUG_NULL_POINTER : BUG_BAD_MEM_ACCESS;
+                else if (strcasecmp(cntxt->gdb_stop_reason->signal_meaning, "Aborted") == 0)
+                        cntxt->bug_detected = BUG_ABORT;
+                else if (strcasecmp(cntxt->gdb_stop_reason->signal_meaning, "Arithmetic exception") == 0)
+                        cntxt->bug_detected = BUG_ARITHMETIC;
+                else if (strcasecmp(cntxt->gdb_stop_reason->signal_name, "SIGBUS") == 0)
+                        cntxt->bug_detected = BUG_SIG_BUS;
+
+                // get relevant expressions
+                retVal = MONKEY_ACTION_inspect_expression_database (cntxt);
+
+                if (MONKEY_NO == retVal)
+                {
+                        fprintf( stderr,
+                        "Error in using the expression database. Pathologist will exit now!\n");
+                        ret = 1;
+                        break;
+                }
+                else if (BUG_BAD_MEM_ACCESS == cntxt->bug_detected
+                || BUG_SIG_BUS == cntxt->bug_detected)
+                {
+                        /* launch valgrind */
+                        retVal = MONKEY_ACTION_rerun_with_valgrind (cntxt);
+                        if (MONKEY_NO == retVal)
+                                fprintf( stderr, "Error using Valgrind! Pathologist will continue debugging!\n");
+                }
+
+                /* Start backtracking if enabled by user */
+                if (cntxt->run_reverse) {
+                        retVal = MONKEY_ACTION_start_reverse_execution(cntxt);
+                        if (MONKEY_NO == retVal)
+                                fprintf(stderr, "Error during Backtracking! Pathologist will continue debugging with backtracking.\n");
+                }
+
+
+                //                              REPORTING
+                if (MONKEY_OK != MONKEY_ACTION_format_report_xml (cntxt))
+                {
+                        fprintf( stderr,
+                        "Error in generating debug report!\n");
+                        ret = 1;
+                }
+                if (emailAddress != NULL)
+                {
+                        if (MONKEY_OK != MONKEY_ACTION_report_email (cntxt, dumpFileName))
+                        {
+                                fprintf( stderr, "Error sending email!\n");
+                                ret = 1;
+                        }
+                }
+                if (dumpFileName != NULL)
+                {
+                        if (MONKEY_OK !=
+                        MONKEY_ACTION_report_file (cntxt, dumpFileName, MONKEY_YES))
+                        {
+                                fprintf( stderr,
+                                "Error in saving debug file!\n");
+                                ret = 1;
+                        }
+                }
+                break;
+        default:
+                break;
+        }
+
+MONKEY_ACTION_delete_context (cntxt);
+}
+
+
+int freePathologistArgs()
+{
+        if (NULL != dumpFileName)
+                MONKEY_free(dumpFileName);
+        if (NULL != emailAddress)
+                MONKEY_free(emailAddress);
+        if (NULL != edbFilePath)
+                MONKEY_free(edbFilePath);
+        if (NULL != gdbBinaryPath)
+                MONKEY_free(gdbBinaryPath);
+        if (NULL != valgrindBinaryPath)
+                MONKEY_free(valgrindBinaryPath);
+        if (NULL != inspectExpression)
+                MONKEY_free(inspectExpression);
+        if (NULL != inspectFunction)
+                MONKEY_free(inspectFunction);
+
+        return MONKEY_OK;
+}
+
+
+
+const char * buildBinaryArgs(int argc, char **argv) {
+        char * res = MONKEY_strdup("");
+        char * tmp;
+        int i;
+        for (i = 0; i < argc; i++) {
+                MONKEY_asprintf(&tmp, "%s %s", res, argv[i]);
+                MONKEY_free(res);
+                res = tmp;
+        }
+
+        return res;
+}
+
+int
+main (int argc, char *argv[])
+{
+        static const struct MONKEY_GETOPT_CommandLineOption options[] = {
+                {'d', "database", "FILENAME", "the expression database to use, generated by seaspider",
+                        1, &MONKEY_GETOPT_set_string, &edbFilePath},
+                {'f', "function", "FUNCTIONNAME", "the name of the function, in which pathologist will set a breakpoint",
+                        1, &MONKEY_GETOPT_set_string, &inspectFunction},
+                {'g', "gdb", "FILENAME", "path to gdb binary to use. If not passed, pathologist will set it to /usr/bin/gdb",
+                        1, &MONKEY_GETOPT_set_string, &gdbBinaryPath},
+                {'h', "help", NULL, "shows this help",
+                        0, &MONKEY_GETOPT_format_help_, "Monkey Pathologist: Automatically debug a service"},
+                {'i', "inspect", "EXPRESSIONNAME", "expression to inspect in the function specified after argument f",
+                        1, &MONKEY_GETOPT_set_string, &inspectExpression},
+                {'l', "valgrind", "FILENAME", "path to valgrind binary. If not passed, pathologist will set it to /usr/bin/valgrind",
+                        1, &MONKEY_GETOPT_set_string, &valgrindBinaryPath},
+                {'m', "mail", "MAILADDRESS", "if specified, pathologist will send the bugreport to the given address",
+                        1, &MONKEY_GETOPT_set_string, &emailAddress},
+                {'o', "report", "FILENAME", "saves the xml formated report to the given file",
+                        1, &MONKEY_GETOPT_set_string, &dumpFileName},
+                {'p', "depth", "UINT", "scope depth. How many scopes should pathologist lookup expression values outer than the scope in which the problem occurs. Default is 0 which means, pathologist is restricted to the scope of the expression in which the debugged program stopped" ,
+                        1, &MONKEY_GETOPT_set_uint, &scopeDepth},
+                {'r', "reverse", NULL, "enables reverse execution",
+                        0, &MONKEY_GETOPT_set_one, &reverseExecutionAllowed},
+                {'v', "version", NULL, "print the version number",
+                        0, &MONKEY_GETOPT_print_version_, "0.1 alpha"},
+                MONKEY_GETOPT_OPTION_END
+        };
+
+        if (-1 == (ret = MONKEY_GETOPT_run ("pathologist -d DATABASEFILE [options] [--] BINARY", options, (unsigned int) argc, argv)))
+                return -1;
+
+        // Check for required arguments
+        if (argc <= ret)
+                printf("Error: missing argument: path to the binary file.\n");
+        if (NULL == edbFilePath)
+                printf("Error: missing argument: path to expression database file.\n");
+        if (argc <= ret || NULL == edbFilePath)
+                exit(EXIT_FAILURE);
+
+        /* All remaining args are considered program arguments */
+        binaryName = argv[ret];
+        command    = (char *)buildBinaryArgs(argc - ret, &argv[ret]) + 1;
+        binaryArgs = (char *)buildBinaryArgs(argc - ret - 1, &argv[ret + 1]);
+
+        printf("\n%s\n%s\n%s\n\n", binaryName, command, binaryArgs);
+        
+        /* Run Pathologist */
+        run();
+
+        /* clean up */
+        freePathologistArgs();
+
+        return ret;
+}
diff --git a/pathologist/src/pathologist/pathologist_edb.h b/pathologist/src/pathologist/pathologist_edb.h
new file mode 100644
index 0000000..33e18ee
--- /dev/null
+++ b/pathologist/src/pathologist/pathologist_edb.h
@@ -0,0 +1,158 @@
+/**
+ * @file monkey/MONKEY_edb.h
+ * @brief Monkey API for accessing the Expression Database (edb)
+ */
+
+#ifndef MONKEY_EDB_H
+#define MONKEY_EDB_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+struct MONKEY_EDB_Context;
+
+/**
+ * Establish a connection to the Expression Database
+ *
+ * @param db_file_name path the Expression Database file
+ * @return context to use for Accessing the Expression Database, NULL on error
+ */
+struct MONKEY_EDB_Context *MONKEY_EDB_connect (const char
+                                                             *db_file_name);
+
+
+/**
+ * Disconnect from Database, and cleanup resources
+ *
+ * @param context context
+ * @return MONKEY_OK on success, MONKEY_NO on failure
+ */
+int MONKEY_EDB_disconnect (struct MONKEY_EDB_Context *cntxt);
+
+
+typedef int (*MONKEY_ExpressionIterator) (void *, int, char **,
+                                                 char **);
+
+typedef int (*MONKEY_FileIterator) (void *, int, char **, char **);
+
+
+
+int
+MONKEY_EDB_get_all_outer_scopes(struct MONKEY_EDB_Context
+                *cntxt, const char *file_name,
+                int function_beginning,
+                int scope_in_question_start,
+                int scope_in_question_end,
+                MONKEY_ExpressionIterator
+                iter, void *iter_cls);
+
+int
+MONKEY_EDB_expression_function_end_scope(struct MONKEY_EDB_Context
+                *cntxt, const char *file_name,
+                int start_lineno,
+                MONKEY_ExpressionIterator
+                iter, void *iter_cls);
+int
+MONKEY_EDB_function_start_line_for_scope(struct MONKEY_EDB_Context
+                *cntxt, const char *file_name,
+                int scope_end,
+                MONKEY_ExpressionIterator
+                iter, void *iter_cls);
+/**
+ * Return the line number of the end-of-scope for the expression indicated by start_line_no
+ *
+ * @param cntxt context containing the Expression Database handle
+ * @param file_name path to the file in which the expression in question exists
+ * @param start_line_no expression's line
+ * @param iter callback function, iterator for values returned from the Database
+ * @param iter_cls closure for the expression iterator, will contain the scope-end line number
+ * @return MONKEY_OK on success, MONKEY_NO on failure
+ */
+int
+MONKEY_EDB_get_expression_scope_end (struct MONKEY_EDB_Context
+                                            *cntxt, const char *file_name,
+                                            int start_line_no,
+                                            MONKEY_ExpressionIterator
+                                            iter, void *iter_cls);
+
+
+int
+MONKEY_EDB_get_expression_scope_end_for_expression (struct MONKEY_EDB_Context
+                                            *cntxt, const char *file_name,
+                                            const char * expr_syntax,
+                                            MONKEY_ExpressionIterator
+                                            iter, void *iter_cls);
+
+/**
+ * Return all the source code file names available in the Expression Database
+ *
+ * @param cntxt context containing the Expression Database handle
+ * @param iter callback function, iterator for values returned from the Database
+ * @param iter_cls closure for the file names iterator, will contain the file names
+ * @return MONKEY_OK on success, MONKEY_NO on failure
+ */
+int
+MONKEY_EDB_get_file_names (struct MONKEY_EDB_Context *cntxt,
+                                  MONKEY_FileIterator iter,
+                                  void *iter_cls);
+
+
+int
+MONKEY_EDB_get_globals (struct MONKEY_EDB_Context *cntxt,
+                                                const char* file_names,
+                                                MONKEY_ExpressionIterator iter,
+                                                void *iter_cls);
+
+/**
+ * Run an SQLite query to retrieve those expressions that are previous to
+ * given expression and are in the same scope of the given expression
+ * For example, consider the following code snippet:
+ *
+ * {
+ *   struct Something whole; // line no.1 
+ *   struct SomethingElse part; // line no.2
+ *   whole.part = &part; // line no.3
+ *   whole.part->member = 1; // line no.4
+ * }
+ *
+ * If the expression supplied to the function is that of line no.4 "whole.part->member = 1;"
+ * The returned list of expressions will be: whole.part (line no.4), whole.part->member (line no.4),
+ * whole (line no.3), whole.part (line no.3), &part (line no.3), whole.part = &part (line no.3)
+ *
+ * @param cntxt context containing the Expression Database handle.
+ * @param file_name path to the file in which the expression in question exists
+ * @param start_line_no expression beginning line
+ * @param iter callback function, iterator for expressions returned from the Database
+ * @param iter_cls closure for the expression iterator
+ * @return MONKEY_OK success, MONKEY_NO failure
+ */
+int
+MONKEY_EDB_get_expressions (struct MONKEY_EDB_Context *cntxt,
+                                   const char *file_name, int start_line_no,
+                                   MONKEY_ExpressionIterator iter,
+                                   void *iter_cls);
+
+
+int
+MONKEY_EDB_get_sub_expressions (struct MONKEY_EDB_Context
+                                       *cntxt, const char *file_name,
+                                       int start_line_no, int end_line_no,
+                                       MONKEY_ExpressionIterator iter,
+                                       void *iter_cls);
+
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/pathologist/src/pathologist/pathologist_xml_writer.h b/pathologist/src/pathologist/pathologist_xml_writer.h
new file mode 100644
index 0000000..5e74060
--- /dev/null
+++ b/pathologist/src/pathologist/pathologist_xml_writer.h
@@ -0,0 +1,54 @@
+/**
+ * @file monkey/MONKEY_xml_writer.h
+ * @brief Monkey API for generating XML debug report
+ */
+
+
+#ifndef MONKEY_XML_WRITER_H
+#define MONKEY_XML_WRITER_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+struct XmlAttribute {
+        struct XmlAttribute *next;
+        struct XmlAttribute *prev;
+        const char *name;
+        const char *value;
+};
+
+
+struct MONKEY_XML_Node {
+        struct MONKEY_XML_Node *next;
+        struct MONKEY_XML_Node *prev;
+        const char *name;
+        const char *value;
+        const char *innerText;
+        struct XmlAttribute* attributeListHead;
+        struct XmlAttribute* attributeListTail;
+        struct MONKEY_XML_Node *childrenListHead;
+        struct MONKEY_XML_Node *childrenListTail;
+};
+
+struct MONKEY_XML_Node* MONKEY_XML_WRITER_new_node(const char *name, const char *innerText);
+int MONKEY_XML_WRITER_delete_tree(struct MONKEY_XML_Node *root);
+struct MONKEY_XML_Node* MONKEY_XML_WRITER_add_child(struct MONKEY_XML_Node *parent, struct MONKEY_XML_Node *child);
+int MONKEY_XML_WRITER_write_document(FILE* file, struct MONKEY_XML_Node *root);
+FILE* MONKEY_XML_WRITER_create_document(const char *filePath);
+int MONKEY_XML_WRITER_add_attribute(struct MONKEY_XML_Node* node, const char *attrName, const char *attrValue);
+int MONKEY_XML_WRITER_add_inner_text(struct MONKEY_XML_Node *node, const char *innerText);
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/pathologist/src/pathologist/test_monkey_assertion_failure.sh b/pathologist/src/pathologist/test_monkey_assertion_failure.sh
new file mode 100644
index 0000000..2a6d3b0
--- /dev/null
+++ b/pathologist/src/pathologist/test_monkey_assertion_failure.sh
@@ -0,0 +1,16 @@
+#!/bin/sh
+echo -n "Test Monkey with Bug - Assertion Failure -"
+gnunet-monkey -m text -d bug_assertion_failure.db -b bug_assertion_failure -o monkey.out || (echo "Monkey Failed!" && exit 1)
+grep "Bug detected in file:bug_assertion_failure.c" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "function:assertionFailure" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "line:8" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "received signal:SIGABRT" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "Aborted" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "Details:" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "Assertion Failure" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "Expression evaluation:" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "assert(x<4) = Not evaluated" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "x<4 = 0" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+grep "x = 5" monkey.out > /dev/null || (echo "FAIL" && exit 1)
+rm -f monkey.out
+echo "PASS"
diff --git a/pathologist/src/pathologist/test_monkey_bad_memory_access.sh b/pathologist/src/pathologist/test_monkey_bad_memory_access.sh
new file mode 100644
index 0000000..cd86a84
--- /dev/null
+++ b/pathologist/src/pathologist/test_monkey_bad_memory_access.sh
@@ -0,0 +1,15 @@
+echo -n "Test Monkey with Bug - Bad Memory Access -"
+gnunet-monkey -m text -d bug_bad_memory_access.db -b bug_bad_memory_access -o monkey.out || (echo "Monkey Failed!" && exit 1)
+for i in `cat bug_bad_memory_access_rpt.ref`
+do
+        grep $i monkey.out
+        if [ $? -ne 0 ]
+        then
+                {
+                echo $i
+                echo "FAIL"
+                exit 1
+                }
+        fi
+done 
+echo "PASS"
diff --git a/pathologist/src/pathologist/test_monkey_data.conf b/pathologist/src/pathologist/test_monkey_data.conf
new file mode 100644
index 0000000..9ae1d67
--- /dev/null
+++ b/pathologist/src/pathologist/test_monkey_data.conf
@@ -0,0 +1,43 @@
+[PATHS]
+SERVICEHOME = /tmp/test-gnunetd-arm/
+DEFAULTCONFIG = test_arm_api_data.conf
+
+[arm]
+PORT = 23354
+DEFAULTSERVICES =
+BINARY = gnunet-service-arm
+OPTIONS = -L ERROR
+# DEBUG = YES
+#PREFIX = valgrind --tool=memcheck --leak-check=yes
+
+[gnunet-monkey]
+# DEBUG = YES
+PORT = 23355
+BINARY = gnunet-monkey
+# PREFIX = valgrind
+
+
+[fs]
+AUTOSTART = NO
+
+[datastore]
+AUTOSTART = NO
+
+[core]
+AUTOSTART = NO
+
+[transport]
+AUTOSTART = NO
+
+[peerinfo]
+AUTOSTART = NO
+
+[statistics]
+AUTOSTART = YES
+# DEBUG = NO
+
+
+[dns]
+AUTOSTART = NO
+
+
diff --git a/pathologist/src/pathologist/test_monkey_npe.sh b/pathologist/src/pathologist/test_monkey_npe.sh
new file mode 100755
index 0000000..5f3d528
--- /dev/null
+++ b/pathologist/src/pathologist/test_monkey_npe.sh
@@ -0,0 +1,13 @@
+#!/bin/sh
+echo -n "Test Monkey with Bug - Null Pointer Exception -"
+gnunet-monkey -m text -d bug_null_pointer_exception.db -b bug_null_pointer_exception -o npe.out || (echo "Monkey Failed!" && exit 1)
+grep "Bug detected in file:bug_null_pointer_exception.c" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep "function:crashFunction" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep "line:14" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep "reason:(null)" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep "received signal:SIGSEGV" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep "Segmentation fault" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep " Details:" npe.out > /dev/null || (echo "FAIL" && exit 1)
+grep " Expression:crashStruct is NULL" npe.out > /dev/null || (echo "FAIL" && exit 1)
+rm -f npe.out
+echo "PASS"
diff --git a/pathologist/src/pathologist/test_pathologist.c b/pathologist/src/pathologist/test_pathologist.c
new file mode 100644
index 0000000..eac5d2f
--- /dev/null
+++ b/pathologist/src/pathologist/test_pathologist.c
@@ -0,0 +1,412 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "mxml.h"
+
+#undef DEBUG_ENABLED
+static int OK = 0;
+static int NO = 1;
+static char *reportPath = "../../refs/reports";
+static char *dbPath = "../../refs/db";
+static char *binPath = "../../refs/src";
+
+int compareReports(const char *refFileName, const char *testFileName) {
+        FILE *testFilePtr;
+        FILE *refFilePtr;
+        mxml_node_t *refTree;
+        mxml_node_t *testTree;
+        mxml_node_t *refNode;
+        mxml_node_t *testNode;
+        mxml_node_t *refEpochNode;
+        mxml_node_t *testEpochNode;
+        mxml_node_t *refFunctionNode;
+        mxml_node_t *testFunctionNode;
+        mxml_node_t *refExpressionNode;
+        mxml_node_t *testExpressionNode;
+        const char *refExpressionValue;
+        const char *testExpressionValue;
+
+        refFilePtr = fopen(refFileName, "r");
+        testFilePtr = fopen(testFileName, "r");
+        if (NULL == refFilePtr) {
+                fprintf(stderr, "Test failed: cannot locate reference report: %s.\n", strerror(errno));
+                return NO;
+        }
+        if (NULL == testFilePtr) {
+                fprintf(stderr, "Test failed: cannot locate test report: %s.\n", strerror(errno));
+                return NO;
+        }
+
+        refTree = mxmlLoadFile(NULL, refFilePtr, MXML_TEXT_CALLBACK);
+        testTree = mxmlLoadFile(NULL, testFilePtr, MXML_TEXT_CALLBACK);
+        if (NULL == refTree) {
+                fprintf(stderr, "Test failed: cannot parse reference report.\n");
+                return NO;
+        }
+        if (NULL == testTree) {
+                fprintf(stderr, "Test failed: cannot parse test report.\n");
+                return NO;
+        }
+        fclose(refFilePtr);
+        fclose(testFilePtr);
+
+        refNode = refTree; testNode = testTree; // <?xml version="1.0"?>
+
+        // <crash>...
+        refNode = mxmlWalkNext(mxmlGetFirstChild(refNode), refTree, MXML_DESCEND);
+        testNode = mxmlWalkNext(mxmlGetFirstChild(testNode), testTree, MXML_DESCEND);
+        if (0 != strcmp(mxmlGetElement(refNode), "crash") ||
+                        0 != strcmp(mxmlGetElement(testNode), "crash")) {
+                fprintf(stderr, "Test failed: wrong tag. <crash> expected\n");
+                return NO;
+        }
+        if (0 != strcmp(mxmlElementGetAttr(refNode, "category"), mxmlElementGetAttr(testNode, "category")) ||
+                        0 != strcmp(mxmlElementGetAttr(refNode, "function"), mxmlElementGetAttr(testNode, "function")) ||
+                        0 != strcmp(mxmlElementGetAttr(refNode, "line"), mxmlElementGetAttr(testNode, "line")) ||
+                        0 != strcmp(mxmlElementGetAttr(refNode, "file"), mxmlElementGetAttr(testNode, "file"))) {
+                fprintf(stderr, "Test failed: crash attributes mismatch.\n");
+                return NO;
+        }
+
+         // <valgrind> or <history>...
+        refNode = mxmlWalkNext(mxmlGetFirstChild(refNode), refTree, MXML_DESCEND);
+        testNode = mxmlWalkNext(mxmlGetFirstChild(testNode), testTree, MXML_DESCEND);
+        if (0 == strcmp(mxmlGetElement(refNode), "valgrind")) {
+                if (0 != strcmp(mxmlGetElement(testNode), "valgrind")) {
+                        fprintf(stderr, "Test failed: wrong tag, <valgrind> expected.\n");
+                        return NO;
+                }
+                refNode = mxmlFindElement(refNode, refTree, "history", NULL, NULL, MXML_DESCEND); // move to <history>
+                testNode = mxmlFindElement(testNode, testTree, "history", NULL, NULL, MXML_DESCEND);
+        } else if (0 == strcmp(mxmlGetElement(refNode), "history")) {
+                if (0 != strcmp(mxmlGetElement(testNode), "history")) {
+                        fprintf(stderr, "Test failed: wrong tag, <history> expected.\n");
+                        return NO;
+                }
+        } else {
+                fprintf(stderr, "Test failed: unknown tag.\n");
+                return NO;
+        }
+
+        // <epoch>'s
+        refEpochNode = mxmlGetFirstChild(refNode);
+        testEpochNode = mxmlGetFirstChild(testNode);
+        while (NULL != refEpochNode && NULL != testEpochNode) {
+                if (0 != strcmp(mxmlGetElement(refEpochNode), "epoch") ||
+                                0 != strcmp(mxmlGetElement(testEpochNode), "epoch")) {
+                        fprintf(stderr, "Test failed: wrong tag, <epoch> expected.\n");
+                        return NO;
+                }
+                // Comparing the epoch steps
+                if (0 != strcmp(mxmlElementGetAttr(refEpochNode, "step"), mxmlElementGetAttr(testEpochNode, "step"))) {
+                        fprintf(stderr, "Test failed: epoch steps mismatch.\n");
+                        return NO;
+                }
+
+                // <trace>
+                refNode = mxmlWalkNext(mxmlGetFirstChild(refEpochNode), refTree, MXML_DESCEND);
+                testNode = mxmlWalkNext(mxmlGetFirstChild(testEpochNode), testTree, MXML_DESCEND);
+
+                // <function>'s
+                refFunctionNode = mxmlGetFirstChild(refNode);
+                testFunctionNode = mxmlGetFirstChild(testNode);
+                while (NULL != refFunctionNode && NULL != testFunctionNode) {
+                        if (0 != strcmp(mxmlGetElement(refFunctionNode), "function") ||
+                                        0 != strcmp(mxmlGetElement(testFunctionNode), "function")) {
+                                fprintf(stderr, "Test failed: wrong tag, <function> expected.\n");
+                                return NO;
+                        }
+                        //comparing function attributes
+                        if (0 != strcmp(mxmlElementGetAttr(refFunctionNode, "name"), mxmlElementGetAttr(testFunctionNode, "name")) ||
+                                        0 != strcmp(mxmlElementGetAttr(refFunctionNode, "line"), mxmlElementGetAttr(testFunctionNode, "line")) ||
+                                        0 != strcmp(mxmlElementGetAttr(refFunctionNode, "file"), mxmlElementGetAttr(testFunctionNode, "file")) ||
+                                        0 != strcmp(mxmlElementGetAttr(refFunctionNode, "depth"), mxmlElementGetAttr(testFunctionNode, "depth"))) {
+                                fprintf(stderr, "Test failed: function attributes mismatch.\n");
+                                return NO;
+                        }
+
+                        // <expressions>
+                        refNode = mxmlWalkNext(mxmlGetFirstChild(refFunctionNode), refTree, MXML_DESCEND);
+                        testNode = mxmlWalkNext(mxmlGetFirstChild(testFunctionNode), testTree, MXML_DESCEND);
+
+                        // <expression>'s
+                        refExpressionNode = mxmlGetFirstChild(refNode);
+                        testExpressionNode = mxmlGetFirstChild(testNode);
+                        while (NULL != refExpressionNode && NULL != testExpressionNode) {
+                                if (0 != strcmp(mxmlGetElement(refExpressionNode), "expression") ||
+                                                0 != strcmp(mxmlGetElement(testExpressionNode), "expression")) {
+                                        fprintf(stderr, "Test failed: wrong tag, <expression> expected.\n");
+                                        return NO;
+                                }
+
+                                // comparing expression syntax
+                                if (0 != strcmp(mxmlElementGetAttr(refExpressionNode, "name"), mxmlElementGetAttr(testExpressionNode, "name"))) {
+                                        fprintf(stderr, "Test failed: expression syntax mismatch.\n");
+                                        return NO;
+                                }
+
+                                // comparing expression values
+                                refExpressionValue = mxmlGetText(refExpressionNode, 0);
+                                testExpressionValue = mxmlGetText(testExpressionNode, 0);
+                                if (0 != strcmp(refExpressionValue, testExpressionValue)) {
+                                        // different pointer values are accepted
+                                        if (!(refExpressionValue[0] == '0' && refExpressionValue[1] == 'x'
+                                                        && testExpressionValue[0] == '0' && testExpressionValue[1] == 'x')) {
+                                                if ((strlen(refExpressionValue) >= 5) || (strlen(testExpressionValue) >= 5)) {
+                                                        // different numeric values longer than 5 digits are accepted (such values are considered garbage in uninitialized variables)
+                                                        char *endPtr = NULL;
+                                                        long refIntVal;
+                                                        long testIntVal;
+                                                        refIntVal = strtol(refExpressionValue, &endPtr, 0); // testing whether the values are numeric
+                                                        testIntVal = strtol(testExpressionValue, &endPtr, 0);
+                                                        if ((0 == refIntVal || 0 == testIntVal) && (ERANGE == errno || EINVAL == errno)) {
+                                                                fprintf(stderr, "Test failed: expression value mismatch.\n");
+                                                                return NO;
+                                                        }
+                                                } else {
+                                                        // not pointers and not 5+ digits numbers, then mismatch
+                                                        fprintf(stderr, "Test failed: expression value mismatch.\n");
+                                                        return NO;
+                                                }
+                                        }
+                                }
+
+                                // next expression
+                                refExpressionNode = mxmlGetNextSibling(mxmlGetNextSibling(refExpressionNode));
+                                testExpressionNode = mxmlGetNextSibling(mxmlGetNextSibling(testExpressionNode));
+                        }
+                        if (NULL != refExpressionNode || NULL != testExpressionNode) {
+                                fprintf(stderr, "Test failed: expression mismatch.\n");
+                                return NO;
+                        }
+
+                        // next function
+                        refFunctionNode = mxmlGetNextSibling(mxmlGetNextSibling(refFunctionNode));
+                        testFunctionNode = mxmlGetNextSibling(mxmlGetNextSibling(testFunctionNode));
+                }
+                if (NULL != refFunctionNode || NULL != testFunctionNode) {
+                        fprintf(stderr, "Test failed: function mismatch.\n");
+                        return NO;
+                }
+
+                // next epoch step
+                refEpochNode = mxmlGetNextSibling(mxmlGetNextSibling(refEpochNode));
+                testEpochNode = mxmlGetNextSibling(mxmlGetNextSibling(testEpochNode));
+        }
+        if (NULL != refEpochNode || NULL != testEpochNode) {
+                fprintf(stderr, "Test failed: epoch steps mismatch.\n");
+                return NO;
+        }
+
+        mxmlDelete(refTree);
+        mxmlDelete(testTree);
+        return OK;
+}
+
+
+int runTest(const char *refReportName, const char *testReportName,
+                const char *dbName, const char *binaryName, char *commandStr) {
+        FILE *pathologistPipe;
+        char *refReportPath;
+        char *testReportPath;
+        char *dbFilePath;
+        char *binFilePath;
+        char *command;
+        int ret = OK;
+
+        asprintf(&testReportPath, "%s/%s", reportPath, testReportName);
+        asprintf(&dbFilePath, "%s/%s", dbPath, dbName);
+        asprintf(&binFilePath, "%s/%s", binPath, binaryName);
+        asprintf(&command, commandStr, dbFilePath, testReportPath, binFilePath);
+        asprintf(&refReportPath, "%s/%s", reportPath, refReportName);
+
+        // run Monkey pathologist
+        pathologistPipe = popen(command, "r");
+#ifdef DEBUG_ENABLED
+        fprintf(stderr, "Running command: %s\n", command);
+#endif
+        if (NULL == pathologistPipe) {
+                fprintf(stderr, "Fatal error: unable to run Monkey pathologist.\n");
+                ret = NO;
+        }
+        else {
+                char buffer[128];
+                while(!feof(pathologistPipe)) {
+                        if(fgets(buffer, 128, pathologistPipe) != NULL) {
+#ifdef DEBUG_ENABLED
+                                fputs(buffer, stdout);
+#endif
+                        }
+                }
+                pclose(pathologistPipe);
+                // compare results with ref
+                if (NO == compareReports(refReportPath, testReportPath)) {
+                        ret = NO;
+                } else {
+                        // test passed, delete test report
+                        if (0 != remove(testReportPath)) {
+                                fprintf(stderr, "Warning: could not remove test file %s\n", testReportPath);
+                        }
+                }
+        }
+
+        free(refReportPath); free(command); free(binFilePath); free(dbFilePath); free(testReportPath);
+        return ret;
+}
+
+int main() {
+        int ret = OK;
+        char *commandStr = "pathologist -d %s -o %s %s";
+        char *commandStrReverse = "pathologist -d %s -o %s -r %s";
+        char *commandStrDepthOne = "pathologist -d %s -o %s -p 1 %s";
+        char *commandStrDepthOneReverse = "pathologist -d %s -o %s -p 1 -r %s";
+        char *commandStrDepthThousand = "pathologist -d %s -o %s -p 1000 %s";
+
+        fprintf(stderr, "Testing Monkey Pathologist...\n");
+
+        // Bug Null Pointer Exception
+        fprintf(stderr, "Testing bug null pointer exception...\n");
+        if (NO == runTest("ref_bug_null_pointer_exception.xml",
+                        "test_bug_null_pointer_exception.xml", "bug_null_pointer_exception.db",
+                        "bug_null_pointer_exception", commandStr)) {
+                ret = NO;
+                fprintf(stderr, "Test bug null pointer exception: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug null pointer exception: PASSED\n");
+        }
+
+        // Bug Null Pointer Exception with backtracking
+        fprintf(stderr, "Testing bug null pointer exception with backtracking...\n");
+        if (NO == runTest("ref_bt_bug_null_pointer_exception.xml",
+                        "test_bt_bug_null_pointer_exception.xml", "bug_null_pointer_exception.db",
+                        "bug_null_pointer_exception", commandStrReverse)) {
+                ret = NO;
+                fprintf(stderr, "Test bug null pointer exception with backtracking: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug null pointer exception with backtracking: PASSED\n");
+        }
+
+        // Bug Null Pointer Exception modified with backtracking
+        fprintf(stderr, "Testing bug null pointer exception modified with backtracking...\n");
+        if (NO == runTest("ref_bt_bug_null_pointer_exception_modified.xml",
+                        "test_bt_bug_null_pointer_exception_modified.xml", "bug_null_pointer_exception_modified.db",
+                        "bug_null_pointer_exception_modified", commandStrReverse)) {
+                ret = NO;
+                fprintf(stderr, "Test bug null pointer exception modified with backtracking: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug null pointer exception modified with backtracking: PASSED\n");
+        }
+
+        // Bug Bad Memory Access
+        fprintf(stderr, "Testing bug bad memory access...\n");
+        if (NO == runTest("ref_bug_bad_memory_access.xml",
+                        "test_bug_bad_memory_access.xml", "bug_bad_memory_access.db",
+                        "bug_bad_memory_access", commandStr)) {
+                ret = NO;
+                fprintf(stderr, "Test bug bad memory access: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug bad memory access: PASSED\n");
+        }
+
+        // Bug Bad Memory Access with backtracking
+        fprintf(stderr, "Testing bug bad memory access with backtracking...\n");
+        if (NO == runTest("ref_bt_bug_bad_memory_access.xml",
+                        "test_bt_bug_bad_memory_access.xml", "bug_bad_memory_access.db",
+                        "bug_bad_memory_access", commandStrReverse)) {
+                ret = NO;
+                fprintf(stderr, "Test bug bad memory access with backtracking: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug bad memory access with backtracking: PASSED\n");
+        }
+
+        // Bug Assertion Failure
+        fprintf(stderr, "Testing bug assertion failure...\n");
+        if (NO == runTest("ref_bug_assertion_failure.xml",
+                        "test_bug_assertion_failure.xml", "bug_assertion_failure.db",
+                        "bug_assertion_failure", commandStr)) {
+                ret = NO;
+                fprintf(stderr, "Test bug assertion failure: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug assertion failure: PASSED\n");
+        }
+
+        // Bug Assertion Failure with backtracking
+        fprintf(stderr, "Testing bug assertion failure with backtracking...\n");
+        if (NO == runTest("ref_bt_bug_assertion_failure.xml",
+                        "test_bt_bug_assertion_failure.xml", "bug_assertion_failure.db",
+                        "bug_assertion_failure", commandStrReverse)) {
+                ret = NO;
+                fprintf(stderr, "Test bug assertion failure with backtracking: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug assertion failure with backtracking: PASSED\n");
+        }
+
+        // Bug Division By Zero Loop no depth
+        fprintf(stderr, "Testing bug division by zero loop no depth...\n");
+        if (NO == runTest("ref_bug_division_by_zero_nodepth.xml",
+                        "test_bug_division_by_zero_nodepth.xml", "bug_division_by_zero_loop.db",
+                        "bug_division_by_zero_loop", commandStr)) {
+                ret = NO;
+                fprintf(stderr, "Test bug division by zero loop with no depth: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug division by zero loop with no depth: PASSED\n");
+        }
+
+        // Bug Division By Zero Loop no depth with backtracking
+        fprintf(stderr, "Testing bug division by zero loop no depth with backtracking...\n");
+        if (NO == runTest("ref_bt_bug_division_by_zero_nodepth.xml",
+                        "test_bt_bug_division_by_zero_nodepth.xml", "bug_division_by_zero_loop.db",
+                        "bug_division_by_zero_loop", commandStrReverse)) {
+                ret = NO;
+                fprintf(stderr, "Test bug division by zero loop with no depth with backtracking: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug division by zero loop with no depth with backtracking: PASSED\n");
+        }
+
+        // Bug Division By Zero Loop depth 1
+        fprintf(stderr, "Testing bug division by zero loop depth 1...\n");
+        if (NO == runTest("ref_bug_division_by_zero_depth_1.xml",
+                        "test_bug_division_by_zero_depth_1.xml", "bug_division_by_zero_loop.db",
+                        "bug_division_by_zero_loop", commandStrDepthOne)) {
+                ret = NO;
+                fprintf(stderr, "Test bug division by zero loop with depth 1: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug division by zero loop with depth 1: PASSED\n");
+        }
+
+        // Bug Division By Zero Loop depth 1 with backtracking
+        fprintf(stderr, "Testing bug division by zero loop depth 1 with backtracking...\n");
+        if (NO == runTest("ref_bt_bug_division_by_zero_depth_1.xml",
+                        "test_bt_bug_division_by_zero_depth_1.xml", "bug_division_by_zero_loop.db",
+                        "bug_division_by_zero_loop", commandStrDepthOneReverse)) {
+                ret = NO;
+                fprintf(stderr, "Test bug division by zero loop with depth 1 with backtracking: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug division by zero loop with depth 1 with backtracking: PASSED\n");
+        }
+
+        // Bug Division By Zero Loop depth 1000
+        fprintf(stderr, "Testing bug division by zero loop depth 1000...\n");
+        if (NO == runTest("ref_bug_division_by_zero_depth_1.xml",
+                        "test_bug_division_by_zero_depth_1000.xml", "bug_division_by_zero_loop.db",
+                        "bug_division_by_zero_loop", commandStrDepthThousand)) {
+                ret = NO;
+                fprintf(stderr, "Test bug division by zero loop with depth 1000: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug division by zero loop with depth 1000: PASSED\n");
+        }
+
+        // Bug Bad Food
+        fprintf(stderr, "Testing bug bad food...\n");
+        if (NO == runTest("ref_bug_bad_food.xml",
+                        "test_bug_bad_food.xml", "bug_bad_food.db",
+                        "bug_bad_food", commandStr)) {
+                ret = NO;
+                fprintf(stderr, "Test bug bad food: FAILED\n");
+        } else {
+                fprintf(stderr, "Test bug bad food: PASSED\n");
+        }
+
+        return ret;
+}
diff --git a/pathologist/src/pathologist/xml_writer.c b/pathologist/src/pathologist/xml_writer.c
new file mode 100644
index 0000000..64775a4
--- /dev/null
+++ b/pathologist/src/pathologist/xml_writer.c
@@ -0,0 +1,126 @@
+/**
+ * @file monkey/xml_writer.c
+ * @brief Monkey API for generating XML debug report
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include "monkey_common.h"
+#include "pathologist_xml_writer.h"
+
+
+struct MONKEY_XML_Node* MONKEY_XML_WRITER_new_node(const char *name, const char *innerText) {
+        struct MONKEY_XML_Node *node = MONKEY_malloc(sizeof(struct MONKEY_XML_Node));
+        node->name = name;
+        node->innerText = innerText;
+        node->childrenListHead = NULL;
+        node->childrenListTail = NULL;
+        node->attributeListHead = NULL;
+        node->attributeListTail = NULL;
+        return node;
+}
+
+
+int MONKEY_XML_WRITER_add_attribute(struct MONKEY_XML_Node* node, const char *attrName, const char *attrValue)
+{
+        struct XmlAttribute *attribute = MONKEY_malloc(sizeof(struct XmlAttribute));
+        attribute->name = attrName;
+        attribute->value  = attrValue;
+        attribute->next = NULL; attribute->prev = NULL;
+        MONKEY_CONTAINER_DLL_insert_tail (node->attributeListHead, node->attributeListTail,
+                                                         attribute);
+        return MONKEY_OK;
+}
+
+
+int MONKEY_XML_WRITER_add_inner_text(struct MONKEY_XML_Node *node, const char *innerText)
+{
+        node->innerText = innerText;
+        return MONKEY_OK;
+}
+
+
+int MONKEY_XML_WRITER_delete_tree(struct MONKEY_XML_Node *root)
+{
+        struct MONKEY_XML_Node *tmp = NULL;
+        struct XmlAttribute *tmpAttribute = NULL;
+
+        /* MONKEY_freeing children list - Depth First */
+        while (NULL != root->childrenListHead) {
+                tmp = root->childrenListHead;
+                root->childrenListHead = tmp->next;
+                MONKEY_XML_WRITER_delete_tree(tmp);
+        }
+
+        /* MONKEY_freeing Attributes List */
+        while (NULL != root->attributeListHead) {
+                tmpAttribute = root->attributeListHead;
+                root->attributeListHead = tmpAttribute->next;
+                MONKEY_free(tmpAttribute);
+        }
+
+        /* MONKEY_freeing Leaf Node */
+        MONKEY_free(root);
+
+        return MONKEY_OK;
+}
+
+
+struct MONKEY_XML_Node* MONKEY_XML_WRITER_add_child(struct MONKEY_XML_Node *parent, struct MONKEY_XML_Node *child) {
+        child->next = NULL; child->prev = NULL;
+        MONKEY_CONTAINER_DLL_insert_tail (parent->childrenListHead, parent->childrenListTail,
+                                                 child);
+        return child;
+}
+
+
+FILE* MONKEY_XML_WRITER_create_document(const char *filePath) {
+        FILE* file = fopen(filePath, "w");
+        if (NULL != file) {
+                fprintf(file, "<?xml version=\"1.0\"?>\n");
+                return file;
+        }
+        return NULL;
+}
+
+static char* escapeSpecialCharacters(const char * s) {
+        char* escaped;
+        escaped = MONKEY_str_replace_all (s, "&", "&amp;"); // & (escaping amp character MUST be the first, otherwise, it will spoil the other escaped characters
+        escaped = MONKEY_str_replace_all (escaped, "\"", "&quot;"); // single quote
+        escaped = MONKEY_str_replace_all (escaped, "'", "&apos;"); // double quotes
+        escaped = MONKEY_str_replace_all (escaped, "<", "&lt;"); // less than
+        escaped = MONKEY_str_replace_all (escaped, ">", "&gt;");// greater than
+
+        return escaped;
+}
+
+int MONKEY_XML_WRITER_write_document(FILE* file, struct MONKEY_XML_Node *root) {
+        struct MONKEY_XML_Node *tmp = root->childrenListHead;
+        struct XmlAttribute *tmpAttribute = root->attributeListHead;
+        if (!tmpAttribute)
+                fprintf(file, "<%s>", root->name);
+        else {
+                fprintf(file, "<%s ", root->name);
+                while (NULL != tmpAttribute) {
+                        /* Escaping special characters in attribute values */
+                        fprintf(file, "%s=\"%s\" ", tmpAttribute->name,
+                                        (tmpAttribute->value) ? 
+                                        (escapeSpecialCharacters(tmpAttribute->value)) : "");
+                        tmpAttribute = tmpAttribute->next;
+                }
+                fprintf(file, ">");
+        }
+        if(tmp) fprintf(file, "\n");
+
+        if (NULL != root->innerText)
+                fprintf(file, "%s", escapeSpecialCharacters(root->innerText));
+
+        while (NULL != tmp) {
+                MONKEY_XML_WRITER_write_document(file, tmp);
+                tmp = tmp->next;
+        }
+        fprintf(file, "</%s>\n", root->name);//End
+        return MONKEY_OK;
+}
diff --git a/pathologist/src/struct_parse/exmpl.c b/pathologist/src/struct_parse/exmpl.c
new file mode 100644
index 0000000..00d3a6f
--- /dev/null
+++ b/pathologist/src/struct_parse/exmpl.c
@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+struct a {
+        char c;
+        char c2;
+        char* s[2];
+        struct a* a;
+        char r[4];
+        int i[2];
+        float f;
+};
+
+int main(int argc, char* argv[]) {
+        struct a a;
+        struct a b;
+        a.c = '\'';
+        a.c2 = '"';
+        a.s[0] = "bliblablu\"";
+        a.s[1] = "trololo";
+        a.a = &b;
+        a.r[0] = '\n';
+        a.r[1] = 'a';
+        a.r[2] = '
';
+        a.r[3] = '"';
+        a.i[0] = -5;
+        a.i[1] = 42;
+        a.f = 3.141f;
+
+        return 0;
+}
diff --git a/pathologist/src/struct_parse/p.c b/pathologist/src/struct_parse/p.c
new file mode 100644
index 0000000..c99a654
--- /dev/null
+++ b/pathologist/src/struct_parse/p.c
@@ -0,0 +1,147 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char* parse(char* str, int indent);
+
+// parses one pair of curly braces recursively.
+// expects first char to be the opening '{'
+// returns pointer to the next char after the closing '}' or NULL on error
+char* parse(char* str, int indent) {
+        int is_struct = 0, is_array = 0, had_equals = 0, had_children = 0, had_end = 0;
+        char* first = NULL;
+        char* second = NULL;
+        char* ws = NULL;
+        char* count = NULL;
+
+        if(*str++ != '{') return NULL;
+        while(*str == ' ') str++;
+        if(!*str) return NULL;
+        while(*str) {
+                first = str;
+                second = NULL;
+                had_equals = 0;
+                had_children = 0;
+                had_end = 0;
+                count = NULL;
+                while(*str) {
+                        if(*str == '{') {
+                                if(     (is_struct && !had_equals) ||
+                                        (str != first && str != second) ) return NULL;
+                                if(str == second) {
+                                        printf("%*s<expression name=\"%s\">\n", 2*indent, "", first);
+                                        had_children = 1;
+                                }
+                                str = parse(str, indent+1);
+                                //continue; // have to check this char => no str++ at end of loop.
+                        } else if(*str == '=') {
+                                if(had_equals || is_array) return NULL;
+                                had_equals = 1;
+                                if(!is_struct && !is_array)
+                                        is_struct = 1;
+                                for(ws = str-1; *ws == ' '; ws--)
+                                        *ws = '\0';
+                                *str = '\0';
+                                while(*++str == ' ');
+                                second = str;
+                                continue; // have to check this char => no str++ at end of loop.
+                        } else if(*str == '\'' || *str == '"') {
+                                char end_char = *str;
+                                if(had_equals) second = str;
+                                else first = str;
+                                for(str++; *str != end_char; str++) {
+                                        if(!*str) return NULL;
+                                        if(*str == '\\') {
+                                                if(!*(str+1)) return NULL;
+                                                else str++;
+                                        }
+                                }
+                        } else if(*str == '<') {
+                                for(ws = str-1; *ws == ' '; ws--)
+                                        *ws = '\0';
+                                if(!(str = strpbrk(str+1, "0123456789>"))) return NULL;
+                                if(*str == '>') continue;
+                                count = str;
+                                if(!(str = strpbrk(str+1, " >"))) return NULL;
+                                if(*str == ' ')
+                                *str = '\0';
+                                else {
+                                        *str = '\0';
+                                        if(!(str = strchr(str+1, '>'))) return NULL;
+                                }
+                        } else if(*str == ',') {
+                                if(is_struct && !had_equals) return NULL;
+                                is_array = !is_struct;
+                                is_struct = !is_array;
+                                break;
+                        } else if(*str == '}') {
+                                had_end = 1;
+                                break;
+                        }
+                        str++;
+                }
+                for(ws = str-1; *ws == ' '; ws--)
+                        *ws = '\0';
+                *str = '\0';
+                if(had_children)
+                        printf("%*s</expression>\n", 2*indent, "");
+                else if(is_array)
+                        if(count)
+                                printf("%*s<element count=\"%s\">%s</element>\n", 2*indent, "", count, first);
+                        else
+                                printf("%*s<element>%s</element>\n", 2*indent, "", first);
+                else
+                        printf("%*s<expression name=\"%s\">%s</expression>\n", 2*indent, "", first, second);
+                if(had_end) return str;
+                str++;
+                while(*str == ' ') str++;
+        }
+        return NULL;
+}
+
+
+char * getl(void) {
+        char * line = malloc(128), * linep = line;
+        size_t lenmax = 128, len = lenmax;
+        int c;
+
+        if(line == NULL)
+                return NULL;
+
+        for(;;) {
+                c = fgetc(stdin);
+                if(c == EOF)
+                        break;
+
+                if(--len == 0) {
+                        len = lenmax;
+                        char * linen = realloc(linep, lenmax *= 2);
+
+                        if(linen == NULL) {
+                                free(linep);
+                                return NULL;
+                        }
+                        line = linen + (line - linep);
+                        linep = linen;
+                }
+
+                if((*line = c) == '\n')
+                        break;
+                line++;
+        }
+        *line = '\0';
+        return linep;
+}
+
+
+int main(int argc, char* argv[]) {
+        char* line;
+        while(line = getl()) {
+                if(*line == '\0') break;
+                if(!parse(line, 1))
+                        printf("=====FAILED!=====\n\n");
+                free(line);
+        }
+        if(line) free(line);
+        return 0;
+}
diff --git a/pathologist/src/struct_parse/test.sh b/pathologist/src/struct_parse/test.sh
new file mode 100644
index 0000000..2ab8cec
--- /dev/null
+++ b/pathologist/src/struct_parse/test.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+for n in `seq 1 1000`; do zzuf -r 0.00$n -s $n -i valgrind -q --leak-check=summary --track-origins=yes ./a.out < test.txt; done
diff --git a/pathologist/src/struct_parse/test.txt b/pathologist/src/struct_parse/test.txt
new file mode 100644
index 0000000..030fe36
--- /dev/null
+++ b/pathologist/src/struct_parse/test.txt
@@ -0,0 +1 @@
+{value = {publish = {pc = 0x607a20, fi = 0x60b580, cctx = 0x0, pctx = 0x0, filename = 0x60b9e0 "/home/grothoff/svn/gnunet/src/core/../../COPYING", size = 35147, eta = { rel_value = 18446744073709551615}, duration = {rel_value = 1360752708604}, completed = 0, anonymity = 1, specifics = {progress = {data = 0x0, offset = 0, data_len = 140737349529600, depth = 4158564850}, resume = {message = 0x0, chk_uri = 0x0}, completed = {chk_uri = 0x0}, error = {message = 0x0}}}, download = {dc = 0x607a20,   cctx = 0x60b580, pctx = 0x0, sctx = 0x0, uri = 0x60b9e0, filename = 0x894b <Address 0x894b out of bounds>, size = 18446744073709551615, eta = {rel_value = 1360752708604}, duration = {      rel_value = 0}, completed = 1, anonymity = 0, is_active = 0, specifics = {progress = {data = 0x0, offset = 140737349529600, data_len = 140737351952882, block_download_duration = {            rel_value = 140733193388033}, depth = 0, respect_offered = 0, num_transmissions = 6336704}, start = {meta = 0x0}, resume = {meta = 0x0,           message = 0x7ffff7b9b000 "\177ELF\002\001\001"}, error = {message = 0x0}}}, search = {sc = 0x607a20, cctx = 0x60b580, pctx = 0x0, query = 0x0, duration = {rel_value = 6339040},       anonymity = 35147, specifics = {result = {meta = 0xffffffffffffffff, uri = 0x13cd32e8bfc, result = 0x0, applicability_rank = 1}, resume_result = {meta = 0xffffffffffffffff,           uri = 0x13cd32e8bfc, result = 0x0, availability_rank = 1, availability_certainty = 0, applicability_rank = 0}, update = {cctx = 0xffffffffffffffff, meta = 0x13cd32e8bfc,           uri = 0x0, availability_rank = 1, availability_certainty = 0, applicability_rank = 0, current_probe_time = {rel_value = 0}}, result_suspend = {cctx = 0xffffffffffffffff,           meta = 0x13cd32e8bfc, uri = 0x0}, result_stopped = {cctx = 0xffffffffffffffff, meta = 0x13cd32e8bfc, uri = 0x0}, resume = {          message = 0xffffffffffffffff <Address 0xffffffffffffffff out of bounds>, is_paused = -751924228}, error = {          message = 0xffffffffffffffff <Address 0xffffffffffffffff out of bounds>}, ns = {ns = 0xffffffffffffffff, name = 0x13cd32e8bfc <Address 0x13cd32e8bfc out of bounds>, root = 0x0,           meta = 0x1, id = {bits = {0, 0, 0, 0, 4156141568, 32767, 4158564850, 32767, 1, 32767, 0, 0, 6336704, 0, 4156149880, 32767}}}}}, unindex = {uc = 0x607a20, cctx = 0x60b580,       filename = 0x0, size = 0, eta = {rel_value = 6339040}, duration = {rel_value = 35147}, completed = 18446744073709551615, specifics = {progress = {data = 0x13cd32e8bfc, offset = 0,           data_len = 1, depth = 0}, resume = {message = 0x13cd32e8bfc <Address 0x13cd32e8bfc out of bounds>}, error = {message = 0x13cd32e8bfc <Address 0x13cd32e8bfc out of bounds>}}}},   status = GNUNET_FS_STATUS_PUBLISH_START}
diff --git a/pathologist/src/struct_parse/test1.txt b/pathologist/src/struct_parse/test1.txt
new file mode 100644
index 0000000..9ddec90
--- /dev/null
+++ b/pathologist/src/struct_parse/test1.txt
@@ -0,0 +1 @@
+{0 <repeats 9274 times>, -136430974, 32767, 0 <repeats 18 times>, 1560576, 0, 1560100, 0, 1560100, 0, 0, 0, 5, 0, 3657728, 0, 3678208, 0, 3677624, 0, 3696728, 0, 1560576, 0, 3, 0 <repeats 47 times>, -136436024, 32767, 0, 0, 0, 0, 0, 0, -134241024, 32767, 47, 0, -136413867, 32767, 0, 0, -134239856, 32767, 32, 0, 0, 1, -134241104, 32767, 0, 0, -8304, 32767, -136414759, 32767, -134225464, 32767, -134240992, 32767, -8304, 32767, -136431348, 32767, 1811964521, 778265193, 909012851, 1932419840, 3550831, 3550831, -136398771, 32767, 0, 0,  -140067357, 32767, 0, 0, -136427454, 32767, -136478720, 32767, -136460200, 32767, -136479304, 32767, 0, 0, -8656, 32767, -134241024, 32767, 4195056, 0, -134225504, 32767, 3, 1, -8136, 0, 6, 0, 3696728, 0, 2053, 0, 1324524, 0, 1, 0, 33261, 0, 0, 0, 0, 0, 1583120, 0, 4096, 0, 3104, 0, 1349347463, 0, 0, 0, 1342975530, 0, 0, 0, 1349347464, 0 <repeats 11 times>, 4195056, 0, -134225464, 32767, -134229952, 32767, 0, 0, -134224528, 32767, 0, 0, -136427174, 32767, 0, 32767, -7304, 32767, 0, 0, 0, 0, 0, 0, -134261768, 32767, 0, 0, 7, 0, 0, 1...}
diff --git a/pathologist/src/struct_parse/test2.txt b/pathologist/src/struct_parse/test2.txt
new file mode 100644
index 0000000..e89ac3a
--- /dev/null
+++ b/pathologist/src/struct_parse/test2.txt
@@ -0,0 +1 @@
+{"buil\"e" , '" ueuil \"\'', "\\\\", 0 ,1560576,0,  1560100,0  , 1560100}
diff --git a/pathologist/src/struct_parse/test3.txt b/pathologist/src/struct_parse/test3.txt
new file mode 100644
index 0000000..39bbf8c
--- /dev/null
+++ b/pathologist/src/struct_parse/test3.txt
@@ -0,0 +1 @@
+{data  =  0x0,offset=0,  data_len=  140737349529600  ,depth  =4158564850  }
diff --git a/pathologist/src/struct_parse/test4.txt b/pathologist/src/struct_parse/test4.txt
new file mode 100644
index 0000000..3735a52
--- /dev/null
+++ b/pathologist/src/struct_parse/test4.txt
@@ -0,0 +1 @@
+{0 <repeats 9274 times>, -136430974, 32767, 0 <repeats 18 times>, 1560576, 0,1560100, 0, 1560100, 0, 0}
diff --git a/pathologist/src/util/Makefile.am b/pathologist/src/util/Makefile.am
new file mode 100644
index 0000000..6961228
--- /dev/null
+++ b/pathologist/src/util/Makefile.am
@@ -0,0 +1,12 @@
+INCLUDES = -I$(top_srcdir)/src/include -I$(top_builddir)/src/include
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+  XLIB = -lgcov
+endif
+
+lib_LTLIBRARIES = libpathologistutil.la
+
+libpathologistutil_la_SOURCES = \
+  common_allocation.c \
+  str_replace_all.c
\ No newline at end of file
diff --git a/pathologist/src/util/common_allocation.c b/pathologist/src/util/common_allocation.c
new file mode 100644
index 0000000..2eef7d5
--- /dev/null
+++ b/pathologist/src/util/common_allocation.c
@@ -0,0 +1,338 @@
+/*
+     This file is part of MONKEY.
+     (C) 2001, 2002, 2003, 2005, 2006 Christian Grothoff (and other contributing authors)
+
+     MONKEY is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     MONKEY is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with MONKEY; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file util/common_allocation.c
+ * @brief wrapper around malloc/free
+ * @author Christian Grothoff
+ * @author Safey A.Halim
+ */
+
+#include "monkey_common.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#ifndef INT_MAX
+#define INT_MAX 0x7FFFFFFF
+#endif
+
+#if 0
+#define W32_MEM_LIMIT 200000000
+#endif
+
+#ifdef W32_MEM_LIMIT
+static LONG mem_used = 0;
+#endif
+
+/**
+ * Allocate memory. Checks the return value, aborts if no more
+ * memory is available.
+ *
+ * @param size how many bytes of memory to allocate, do NOT use
+ *  this function (or MONKEY_malloc) to allocate more than several MB
+ *  of memory, if you are possibly needing a very large chunk use
+ *  MONKEY_xmalloc_unchecked_ instead.
+ * @param filename where in the code was the call to MONKEY_malloc
+ * @param linenumber where in the code was the call to MONKEY_malloc
+ * @return pointer to size bytes of memory
+ */
+void *
+MONKEY_xmalloc_ (size_t size, const char *filename, int linenumber)
+{
+  void *ret;
+
+  /* As a security precaution, we generally do not allow very large
+   * allocations using the default 'MONKEY_malloc' macro */
+  MONKEY_assert_at (size <= MONKEY_MAX_MALLOC_CHECKED, filename, linenumber);
+  ret = MONKEY_xmalloc_unchecked_ (size, filename, linenumber);
+  if (ret == NULL)
+  {
+    fprintf (stderr, "malloc");
+    abort ();
+  }
+  return ret;
+}
+
+
+/**
+ * Allocate and initialize memory. Checks the return value, aborts if no more
+ * memory is available.  Don't use MONKEY_xmemdup_ directly. Use the
+ * MONKEY_memdup macro.
+ *
+ * @param buf buffer to initialize from (must contain size bytes)
+ * @param size number of bytes to allocate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return allocated memory, never NULL
+ */
+void *
+MONKEY_xmemdup_ (const void *buf, size_t size, const char *filename,
+                 int linenumber)
+{
+  void *ret;
+
+  /* As a security precaution, we generally do not allow very large
+   * allocations here */
+  MONKEY_assert_at (size <= MONKEY_MAX_MALLOC_CHECKED, filename, linenumber);
+#ifdef W32_MEM_LIMIT
+  size += sizeof (size_t);
+  if (mem_used + size > W32_MEM_LIMIT)
+    return NULL;
+#endif
+  MONKEY_assert_at (size < INT_MAX, filename, linenumber);
+  ret = malloc (size);
+  if (ret == NULL)
+  {
+    fprintf (stderr, "malloc");
+    abort ();
+  }
+#ifdef W32_MEM_LIMIT
+  *((size_t *) ret) = size;
+  ret = &((size_t *) ret)[1];
+  mem_used += size;
+#endif
+  memcpy (ret, buf, size);
+  return ret;
+}
+
+
+
+/**
+ * Wrapper around malloc. Allocates size bytes of memory.
+ * The memory will be zero'ed out.
+ *
+ * @param size the number of bytes to allocate
+ * @param filename where in the code was the call to MONKEY_malloc_large
+ * @param linenumber where in the code was the call to MONKEY_malloc_large
+ * @return pointer to size bytes of memory, NULL if we do not have enough memory
+ */
+void *
+MONKEY_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
+{
+  void *result;
+
+#ifdef W32_MEM_LIMIT
+  size += sizeof (size_t);
+  if (mem_used + size > W32_MEM_LIMIT)
+    return NULL;
+#endif
+
+  MONKEY_assert_at (size < INT_MAX, filename, linenumber);
+  result = malloc (size);
+  if (result == NULL)
+    return NULL;
+  memset (result, 0, size);
+
+#ifdef W32_MEM_LIMIT
+  *((size_t *) result) = size;
+  result = &((size_t *) result)[1];
+  mem_used += size;
+#endif
+
+  return result;
+}
+
+
+/**
+ * Reallocate memory. Checks the return value, aborts if no more
+ * memory is available.
+ *
+ * @param ptr the pointer to reallocate
+ * @param n how many bytes of memory to allocate
+ * @param filename where in the code was the call to MONKEY_realloc
+ * @param linenumber where in the code was the call to MONKEY_realloc
+ * @return pointer to size bytes of memory
+ */
+void *
+MONKEY_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
+{
+#ifdef W32_MEM_LIMIT
+  n += sizeof (size_t);
+  ptr = &((size_t *) ptr)[-1];
+  mem_used = mem_used - *((size_t *) ptr) + n;
+#endif
+  ptr = realloc (ptr, n);
+  if ((NULL == ptr) && (n > 0))
+  {
+    fprintf (stderr, "realloc");
+    abort ();
+  }
+#ifdef W32_MEM_LIMIT
+  ptr = &((size_t *) ptr)[1];
+#endif
+  return ptr;
+}
+
+
+/**
+ * Free memory. Merely a wrapper for the case that we
+ * want to keep track of allocations.
+ *
+ * @param ptr the pointer to free
+ * @param filename where in the code was the call to MONKEY_array_grow
+ * @param linenumber where in the code was the call to MONKEY_array_grow
+ */
+void
+MONKEY_xfree_ (void *ptr, const char *filename, int linenumber)
+{
+  MONKEY_assert_at (ptr != NULL, filename, linenumber);
+#ifdef W32_MEM_LIMIT
+  ptr = &((size_t *) ptr)[-1];
+  mem_used -= *((size_t *) ptr);
+#endif
+  free (ptr);
+}
+
+/**
+ * Dup a string (same semantics as strdup).
+ *
+ * @param str the string to dup
+ * @param filename where in the code was the call to MONKEY_strdup
+ * @param linenumber where in the code was the call to MONKEY_strdup
+ * @return strdup(str)
+ */
+char *
+MONKEY_xstrdup_ (const char *str, const char *filename, int linenumber)
+{
+  char *res;
+
+  MONKEY_assert_at (str != NULL, filename, linenumber);
+  res = MONKEY_xmalloc_ (strlen (str) + 1, filename, linenumber);
+  memcpy (res, str, strlen (str) + 1);
+  return res;
+}
+
+
+/**
+ * Dup partially a string (same semantics as strndup).
+ *
+ * @param str the string to dup
+ * @param len the length of the string to dup
+ * @param filename where in the code was the call to MONKEY_strndup
+ * @param linenumber where in the code was the call to MONKEY_strndup
+ * @return strndup(str,len)
+ */
+char *
+MONKEY_xstrndup_ (const char *str, size_t len, const char *filename,
+                  int linenumber)
+{
+  char *res;
+
+  MONKEY_assert_at (str != NULL, filename, linenumber);
+  len = MONKEY_MIN (len, strlen (str));
+  res = MONKEY_xmalloc_ (len + 1, filename, linenumber);
+  memcpy (res, str, len);
+  res[len] = '\0';
+  return res;
+}
+
+
+/**
+ * Grow an array.  Grows old by (*oldCount-newCount)*elementSize bytes
+ * and sets *oldCount to newCount.
+ *
+ * @param old address of the pointer to the array
+ *        *old may be NULL
+ * @param elementSize the size of the elements of the array
+ * @param oldCount address of the number of elements in the *old array
+ * @param newCount number of elements in the new array, may be 0
+ * @param filename where in the code was the call to MONKEY_array_grow
+ * @param linenumber where in the code was the call to MONKEY_array_grow
+ */
+void
+MONKEY_xgrow_ (void **old, size_t elementSize, unsigned int *oldCount,
+               unsigned int newCount, const char *filename, int linenumber)
+{
+  void *tmp;
+  size_t size;
+
+  MONKEY_assert_at (INT_MAX / elementSize > newCount, filename, linenumber);
+  size = newCount * elementSize;
+  if (size == 0)
+  {
+    tmp = NULL;
+  }
+  else
+  {
+    tmp = MONKEY_xmalloc_ (size, filename, linenumber);
+    memset (tmp, 0, size);      /* client code should not rely on this, though... */
+    if (*oldCount > newCount)
+      *oldCount = newCount;     /* shrink is also allowed! */
+    memcpy (tmp, *old, elementSize * (*oldCount));
+  }
+
+  if (*old != NULL)
+  {
+    MONKEY_xfree_ (*old, filename, linenumber);
+  }
+  *old = tmp;
+  *oldCount = newCount;
+}
+
+
+/**
+ * Like asprintf, just portable.
+ *
+ * @param buf set to a buffer of sufficient size (allocated, caller must free)
+ * @param format format string (see printf, fprintf, etc.)
+ * @param ... data for format string
+ * @return number of bytes in "*buf" excluding 0-termination
+ */
+int
+MONKEY_asprintf (char **buf, const char *format, ...)
+{
+  int ret;
+  va_list args;
+
+  va_start (args, format);
+  ret = vsnprintf (NULL, 0, format, args);
+  va_end (args);
+  *buf = MONKEY_malloc (ret + 1);
+  va_start (args, format);
+  ret = vsprintf (*buf, format, args);
+  va_end (args);
+  return ret;
+}
+
+
+/**
+ * Like snprintf, just aborts if the buffer is of insufficient size.
+ *
+ * @param buf pointer to buffer that is written to
+ * @param size number of bytes in buf
+ * @param format format strings
+ * @param ... data for format string
+ * @return number of bytes written to buf or negative value on error
+ */
+int
+MONKEY_snprintf (char *buf, size_t size, const char *format, ...)
+{
+  int ret;
+  va_list args;
+
+  va_start (args, format);
+  ret = vsnprintf (buf, size, format, args);
+  va_end (args);
+  MONKEY_assert (ret <= size);
+  return ret;
+}
+
+/* end of common_allocation.c */
diff --git a/pathologist/src/util/str_replace_all.c b/pathologist/src/util/str_replace_all.c
new file mode 100644
index 0000000..a167523
--- /dev/null
+++ b/pathologist/src/util/str_replace_all.c
@@ -0,0 +1,56 @@
+/**
+ * vim: tabstop=2:shiftwidth=2:softtabstop=2:expandtab
+ *
+ * str_replace.c implements a str_replace PHP like function
+ * Copyright (C) 2010  chantra <chantra__A__debuntu__D__org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * gcc -o str_replace_all str_replace_all.c
+ */
+
+#include <string.h>
+#include "monkey_common.h"
+
+char *
+MONKEY_str_replace_all ( const char *string, const char *substr, const char *replacement ){
+  char *tok = NULL;
+  char *newstr = NULL;
+  char *oldstr = NULL;
+  char *head = NULL;
+
+  /* if either substr or replacement is NULL, duplicate string a let caller handle it */
+  if ( substr == NULL || replacement == NULL ) return MONKEY_strdup (string);
+  newstr = MONKEY_strdup (string);
+  head = newstr;
+  while ( (tok = strstr ( head, substr ))){
+    oldstr = newstr;
+    newstr = MONKEY_malloc ( strlen ( oldstr ) - strlen ( substr ) + strlen ( replacement ) + 1 );
+    /*failed to alloc mem, free old string and return NULL */
+    if ( newstr == NULL ){
+      MONKEY_free (oldstr);
+      return NULL;
+    }
+    memcpy ( newstr, oldstr, tok - oldstr );
+    memcpy ( newstr + (tok - oldstr), replacement, strlen ( replacement ) );
+    memcpy ( newstr + (tok - oldstr) + strlen( replacement ), tok + strlen ( substr ), strlen ( oldstr ) - strlen ( substr ) - ( tok - oldstr ) );
+    memset ( newstr + strlen ( oldstr ) - strlen ( substr ) + strlen ( replacement ) , 0, 1 );
+    /* move back head right after the last replacement */
+    head = newstr + (tok - oldstr) + strlen( replacement );
+    MONKEY_free (oldstr);
+  }
+  return newstr;
+}
+