/* ==================================================================

    FILE: "/home/joze/src/tclreadline/tclreadline.c"
    LAST MODIFICATION: "Fri Aug 20 23:41:24 1999 (joze)"
    LAST MODIFICATION: "Sat Aug 21 17:44:13 1999 (joze)"
    (C) 1998, 1999 by Johannes Zellner, <johannes@zellner.org>
    $Id$
    ---

    tclreadline -- gnu readline for tcl
    Copyright (C) 1999  Johannes Zellner

int    Tclreadline_SafeInit	(Tcl_Interp *interp);
int    Tclreadline_Init	(Tcl_Interp *interp);
char*  TclReadlineInitialize	(char *historyfile);
char** TclReadlineCompletion	(char *text, int start, int end);
char*  TclReadline0generator	(char *text, int state);
char*  TclReadline1generator	(char *text, int state);
char*  TclReadlineKnownCommands	(char *text, int state, int mode);
int    TclReadlineEventHook	(void);
int    TclReadlineParse	(char **args, int maxargs, char *buf);

enum { 
    LINE_PENDING,
    LINE_CONTROL_D,
    LINE_COMPLETE
};

static int line_complete = LINE_PENDING;
static char *line = (char *) NULL;


/*
 * Script to set the tclreadline library path in the
 * variable global "tclreadline_library"
 */

int


int TclReadlineCmd (clientData, interp, argc, argv)
    ClientData clientData;	/* Main window associated with interpreter  */
    Tcl_Interp *interp;		/* Current interpreter                      */
    int argc;			/* Number of arguments                      */
    char **argv;		/* Argument strings                         */
TclReadlineCmd(
    ClientData  clientData, /* Main window associated with interpreter  */
    Tcl_Interp* interp,     /* Current interpreter                      */
    int         argc,       /* Number of arguments                      */
    char**      argv        /* Argument strings                         */
)
{
    int		c, length;
    

    if (argc < 2) {
	interp->result = "wrong # args";
	for (c = 0; c < argc; c++)
	    fprintf (stderr, "argv[%d] = %s\n", c, argv[c]);
	return TCL_ERROR;
    }

    c = argv[1][0];
    length = strlen(argv[1]);


    if (c == 'r'  && strncmp (argv[1], "read", length) == 0) {
        
        char *expansion = (char *) NULL;
        int status;
        
        line_complete = LINE_PENDING;
        rl_callback_handler_install (argc == 3 ? argv[2] : "%",
                TclReadlineLineCompleteHandler);

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

        while (LINE_PENDING == line_complete) {
            Tcl_DoOneEvent (0);
        }

        Tcl_DeleteFileHandler (0);

        /*
	if (LINE_CONTROL_D == line_complete) {
	    Tcl_Eval (interp, "puts {}; exit");
	}
        */

        status = history_expand (line, &expansion);
        if (status == 1)
            printf ("%s\n", expansion);
        else if (status == -1)
            Tcl_AppendResult (interp, "error in history expansion\n",
                    (char *) NULL);

    Tcl_AppendResult (interp,
            "wrong # args: should be \"readline option ?arg ...?\"",
	    (char *) NULL);
    return TCL_ERROR;

}

void
void TclReadlineDataAvailableHandler (ClientData clientData, int mask)
TclReadlineDataAvailableHandler(ClientData clientData, int mask)
{
#if 0
    fprintf (stderr, "(TclReadlineDataAvailableHandler) mask = %d\n",  mask);
#endif
    if (mask & TCL_READABLE) {
        while (0 == rl_done)
        rl_callback_read_char ();
        rl_redisplay ();
    }
}

void
void TclReadlineLineCompleteHandler (char *ptr)
TclReadlineLineCompleteHandler(char *ptr)
{
#if 0
    fprintf (stderr, "(TclReadlineLineCompleteHandler)  ptr = %p\n",  ptr);
    if (ptr)
    fprintf (stderr, "(TclReadlineLineCompleteHandler) *ptr = %p\n", *ptr);
#endif
    if (!ptr) { /* <c-d> */
        line_complete = LINE_CONTROL_D;
        rl_callback_handler_remove ();
    } else if (*ptr) {
        line_complete = LINE_COMPLETE;
        rl_callback_handler_remove ();
        line = ptr;
    }
#endif
    if (ptr && *ptr) {
        line_complete = 1;
        rl_callback_handler_remove ();
        line = ptr;
}

}

int
int Tclreadline_SafeInit (Tcl_Interp *interp)
Tclreadline_SafeInit(Tcl_Interp *interp)
{
    return Tclreadline_Init (interp);
}

int
int Tclreadline_Init (Tcl_Interp *interp)
Tclreadline_Init(Tcl_Interp *interp)
{
    Tcl_CreateCommand (interp, "::tclreadline::readline", TclReadlineCmd,
	    (ClientData) NULL, (Tcl_CmdDeleteProc *) NULL);
    return Tcl_PkgProvide (interp, "tclreadline", TCLREADLINE_VERSION);
}

char*
char *TclReadlineInitialize (char *historyfile)
TclReadlineInitialize(char* historyfile)
{

    rl_readline_name = "tclreadline";
    using_history ();

    /*
     * try to read historyfile in home
     * directory. If this failes, this
     * is *not* an error.
     */
    rl_attempted_completion_function = (CPPFunction *) TclReadlineCompletion;
    if (read_history (historyfile))
        return "unable to read history file";
    
    else
        return "";
}

char**
char **TclReadlineCompletion (char *text, int start, int end)
TclReadlineCompletion(char* text, int start, int end)
{
    char **matches = (char **) NULL;
    static char local_line[BUFSIZ];
       
    strcpy (local_line, rl_line_buffer);
    
    STRIPWHITE (local_line);

        matches = completion_matches (text, TclReadline0generator);
    else
        matches = completion_matches (text, TclReadline1generator);
    
    return matches;
}

char*
char *TclReadline0generator (char *text, int state)
TclReadline0generator(char* text, int state)
{
    return TclReadlineKnownCommands (text, state, _CMD_GET);
}

char*
char *TclReadline1generator (char *text, int state)
TclReadline1generator(char* text, int state)
{
    return TclReadlineKnownCommands (text, state, _CMD_SUB_GET);
}

char*
char *TclReadlineKnownCommands (char *text, int state, int mode)
TclReadlineKnownCommands(char* text, int state, int mode)
{
    static int len;
    static cmds_t *cmds = (cmds_t *) NULL, *new;
    char* tmp;
    char *tmp, *args[256];
    char* args[256];
    int i, argc;
    char **name;
    
    switch (mode) {
        
        case _CMD_SET:

                
                len = strlen (local_line);
                STRIPRIGHT (local_line);

                if (len != strlen (local_line))
                    sub = TclReadlineParse (args, sizeof (args), local_line);
                else
                    sub = TclReadlineParse (args,
                    sub = TclReadlineParse(args, sizeof(args), local_line) - 1;
                                            sizeof (args), local_line) - 1;
                
                new = cmds;
                len = strlen (text);
                
                while (new && (name = new->cmd)) {
                    if (!strcmp (name[0], args[0]))
                        break;

        default:
            return (char *) NULL;
            break;

    }
    
    /* NOTREACHED */

}

}

int
int TclReadlineEventHook (void)
{
    Tcl_DoOneEvent (TCL_ALL_EVENTS | TCL_DONT_WAIT);
    return TCL_OK;
}

int TclReadlineParse (char **args, int maxargs, char *buf)
TclReadlineParse(char** args, int maxargs, char* buf)
{
    int nr = 0;

    while (*buf != '\0' && nr < maxargs) {
        /*
         * Strip whitespace.  Use nulls, so
         * that the previous argument is terminated

        while ((*buf!='\0') && (*buf!=' ') && (*buf!='\t') && (*buf!='\n'))
            buf++;
    }

    *args = '\0';
    return nr;

}
}