#ifdef EXECUTING_MACRO_HACK
/**
 * this prototype is private in readline's file `macro.c'.
 * We need it here to decide, if we should read more
 * characters from a macro. Dirty, but it should work.
 */
extern char* EXECUTING_MACRO_NAME;
#endif

#include "tclreadline.h"
static const char* tclrl_library = TCLRL_LIBRARY;
static const char* tclrl_version_str = TCLRL_VERSION_STR;
static const char* tclrl_patchlevel_str = TCLRL_PATCHLEVEL_STR;

    switch (obj_idx) {

	case TCLRL_READ:

	    rl_callback_handler_install(
			       objc == 3 ? Tcl_GetStringFromObj(objv[2], 0)
			       : "% ", TclReadlineLineCompleteHandler);

	    Tcl_CreateFileHandler(0, TCL_READABLE,
		TclReadlineReadHandler, (ClientData) NULL);

	    /**
	     * Main Loop.
	     * XXX each modification of the global variables
	     *     which terminates the main loop must call
	     *     rl_callback_handler_remove() to leave
	     *     readline in a defined state.          XXX
	     */
	    tclrl_state = LINE_PENDING;

	    while (!TclReadlineLineComplete()) {
#ifdef EXECUTING_MACRO_NAME
		/**
		 * check first, if more characters are
		 * available from _rl_executing_macro,
		 * because Tcl_DoOneEvent() will (naturally)
		 * not detect this `event'.
		 */
		if (EXECUTING_MACRO_NAME)
		    TclReadlineReadHandler((ClientData) NULL, TCL_READABLE);
		else
#endif
		    Tcl_DoOneEvent(TCL_ALL_EVENTS);
	    }

	    Tcl_DeleteFileHandler(0);

}

static void
TclReadlineReadHandler(ClientData clientData, int mask)
{
    if (mask & TCL_READABLE) {
#ifdef EXECUTING_MACRO_NAME
	do {
#endif
	    rl_callback_read_char();
#ifdef EXECUTING_MACRO_NAME
	    /**
	     * check, if we're inside a macro and
	     * if so, read all macro characters
	     * until the next eol.
	     */
	} while (EXECUTING_MACRO_NAME && !TclReadlineLineComplete());
#endif
    }
}

static void
TclReadlineLineCompleteHandler(char* ptr)
{

	 * The calling script is responsible for handling
	 * empty strings.
	 */

	char* expansion = (char*) NULL;
	int status = history_expand(ptr, &expansion);

	if (status >= 2) {
	    /* TODO: make this a valid tcl output */
	    printf("%s\n", expansion);
		free(ptr);
		free(expansion);
		return;
	} else if (status <= -1) {
	    Tcl_AppendResult
	    (tclrl_interp, "error in history expansion: ", expansion, "\n", (char*) NULL);
	    TclReadlineTerminate(TCL_ERROR);


		free(ptr);
		free(expansion);
		return;

	} else {
        Tcl_AppendResult(tclrl_interp, expansion, (char*) NULL);
    }

#ifdef EXECUTING_MACRO_NAME
	/**
	 * don't stuff macro lines
	 * into readline's history.
	 */
	if(!EXECUTING_MACRO_NAME) {
#endif
	    /**
	     * don't stuff empty lines
	     * into readline's history.
	     * don't stuff twice the same
	     * line into readline's history.
	     */
	    if (expansion && *expansion && (!tclrl_last_line ||
		    strcmp(tclrl_last_line, expansion))) {
		add_history(expansion);
	    }
	    if (tclrl_last_line)
		free(tclrl_last_line);
	    tclrl_last_line = strdup(expansion);
#ifdef EXECUTING_MACRO_NAME
	}
#endif
	/**
	 * tell the calling routines to terminate.
	 */
	TclReadlineTerminate(LINE_COMPLETE);
	FREE(ptr);

	char* quoted_rl_line_buffer = TclReadlineQuote(rl_line_buffer, "$[]{}\"");
	sprintf(start_s, "%d", start);
	sprintf(end_s, "%d", end);
	Tcl_ResetResult(tclrl_interp); /* clear result space */
	state = Tcl_VarEval(tclrl_interp, tclrl_custom_completer,
	    " \"", quoted_text, "\" ", start_s, " ", end_s,
	    " \"", quoted_rl_line_buffer, "\"", (char*) NULL);


	if (TCL_OK != state) {
	    Tcl_AppendResult (tclrl_interp, " `", tclrl_custom_completer,
		" \"", quoted_text, "\" ", start_s, " ", end_s,
		" \"", quoted_rl_line_buffer, "\"' failed.", (char*) NULL);
	    TclReadlineTerminate(state);
		free(quoted_text);
		free(quoted_rl_line_buffer);
	    return matches;
	}
	free(quoted_text);
	quoted_text = NULL;
	free(quoted_rl_line_buffer);
	quoted_rl_line_buffer = NULL;
	obj = Tcl_GetObjResult(tclrl_interp);
	status = Tcl_ListObjGetElements(tclrl_interp, obj, &objc, &objv);
	if (TCL_OK != status)
	    return matches;

	if (objc) {
	    int i, length;