add xchat r1489

5 files changed, 2772 insertions, 0 deletions

diff --git a/plugins/tcl/Makefile.am b/plugins/tcl/Makefile.am
new file mode 100644
index 00000000..804fc83b
--- /dev/null
+++ b/plugins/tcl/Makefile.am
@@ -0,0 +1,10 @@
+
+EXTRA_DIST=printevents.h tclplugin.h README
+
+libdir = $(xchatlibdir)/plugins
+
+lib_LTLIBRARIES = tcl.la
+tcl_la_SOURCES = tclplugin.c
+tcl_la_LDFLAGS = -avoid-version -module 
+tcl_la_LIBADD = $(TCL_LIBS)
+INCLUDES = $(TCL_CFLAGS) $(COMMON_CFLAGS) -I$(srcdir)/..
diff --git a/plugins/tcl/README b/plugins/tcl/README
new file mode 100644
index 00000000..e46635ef
--- /dev/null
+++ b/plugins/tcl/README
@@ -0,0 +1,55 @@
+Please read this document before asking questions.
+
+(1) WHAT IS THE TCL PLUGIN?
+
+    The XChat Tcl Plugin adds the complete Tcl scripting language to the
+    XChat 1.9.x and 2.x IRC client.  The design philosophy behind the tcl
+    plugin was to give all the power of the C API. yet completely shield
+    the user from all the complexities of it.  It is lightly modeled after
+    after Xircon; an old windows TCL enabled client with a little bit of
+    eggdrop functionality to it.
+
+    Features:
+     * Uses the popular TCL scripting language.
+     * Familiar to eggdrop bot owners.
+     * Adds many new XChat specific commands to the Tcl language for 
+       handling of events, user commands, timers, etc. 
+     * It's actually documented! (Hey, what a concept!) 
+     * Works with XChat 1.9.x and 2.x. 
+     * Open source (GPL) 
+
+    The supplied documentation for Tcl Plugin commands can be 
+    found in doc/tclplugin.html
+    
+    For a comprehensive list of IRC server tokens, see
+    doc/tokens.txt
+
+
+(2) HOW TO GET TCL PLUGIN
+
+    You can always find the latest version of the Tcl Plugin at:
+
+       http://www.scriptkitties.com/tclplugin
+
+   You must also have Tcl 8.3 or higher installed on your system.
+
+     Tcl can be obtained from:
+
+       http://sourceforge.net/projects/tcl
+       http://tcl.activestate.com (pre-compiled binaries)
+
+     Tcl Man Pages
+
+       http://tcl.activestate.com/man/
+
+     Tcl Tutorials:
+
+       http://hegel.ittc.ukans.edu/topics/tcltk/tutorial-noplugin/
+       http://jan.netcomp.monash.edu.au/ProgrammingUnix/tcl/tcl_tut.html
+       http://users.belgacom.net/bruno.champagne/tcl.html
+
+
+(3) QUICK STARTUP
+
+    SEE 'INSTALL'
+
diff --git a/plugins/tcl/printevents.h b/plugins/tcl/printevents.h
new file mode 100644
index 00000000..dfea4aea
--- /dev/null
+++ b/plugins/tcl/printevents.h
@@ -0,0 +1,319 @@
+/***************************************************************************
+                           printevents.h  -  TCL plugin header file
+                           -------------------------------------------------
+    begin                : Sat Nov  9 17:31:20 MST 2002
+    copyright            : Copyright 2002-2007 Daniel P. Stasinski
+    email                : mooooooo@avenues.org
+    generated            : Mon May 21 06:03:00 PM MST 2007
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+typedef struct {
+    char *event;
+    char *emit;
+    int argc;
+    xchat_hook *hook;
+} print_event;
+
+enum
+{
+	CHAT,
+	XC_APPFOCUS,
+	XC_TABOPEN,
+	XC_TABCLOSE,
+	XC_TABFOCUS,
+	XC_KEYPRESS,
+	XC_ADDNOTIFY,
+	XC_BANLIST,
+	XC_BANNED,
+	XC_BEEP,
+	XC_CHANGENICK,
+	XC_CHANACTION,
+	XC_HCHANACTION,
+	XC_CHANBAN,
+	XC_CHANDATE,
+	XC_CHANDEHOP,
+	XC_CHANDEOP,
+	XC_CHANDEVOICE,
+	XC_CHANEXEMPT,
+	XC_CHANHOP,
+	XC_CHANINVITE,
+	XC_CHANLISTHEAD,
+	XC_CHANMSG,
+	XC_CHANMODEGEN,
+	XC_CHANMODES,
+	XC_HCHANMSG,
+	XC_CHANNOTICE,
+	XC_CHANOP,
+	XC_CHANRMEXEMPT,
+	XC_CHANRMINVITE,
+	XC_CHANRMKEY,
+	XC_CHANRMLIMIT,
+	XC_CHANSETKEY,
+	XC_CHANSETLIMIT,
+	XC_CHANUNBAN,
+	XC_CHANVOICE,
+	XC_CONNECTED,
+	XC_CONNECT,
+	XC_CONNFAIL,
+	XC_CTCPGEN,
+	XC_CTCPGENC,
+	XC_CTCPSEND,
+	XC_CTCPSND,
+	XC_CTCPSNDC,
+	XC_DCCCHATABORT,
+	XC_DCCCONCHAT,
+	XC_DCCCHATF,
+	XC_DCCCHATOFFER,
+	XC_DCCCHATOFFERING,
+	XC_DCCCHATREOFFER,
+	XC_DCCCONFAIL,
+	XC_DCCGENERICOFFER,
+	XC_DCCHEAD,
+	XC_MALFORMED,
+	XC_DCCOFFER,
+	XC_DCCIVAL,
+	XC_DCCRECVABORT,
+	XC_DCCRECVCOMP,
+	XC_DCCCONRECV,
+	XC_DCCRECVERR,
+	XC_DCCFILEERR,
+	XC_DCCRENAME,
+	XC_DCCRESUMEREQUEST,
+	XC_DCCSENDABORT,
+	XC_DCCSENDCOMP,
+	XC_DCCCONSEND,
+	XC_DCCSENDFAIL,
+	XC_DCCSENDOFFER,
+	XC_DCCSTALL,
+	XC_DCCTOUT,
+	XC_DELNOTIFY,
+	XC_DISCON,
+	XC_FOUNDIP,
+	XC_GENMSG,
+	XC_IGNOREADD,
+	XC_IGNORECHANGE,
+	XC_IGNOREFOOTER,
+	XC_IGNOREHEADER,
+	XC_IGNOREREMOVE,
+	XC_IGNOREEMPTY,
+	XC_INVITE,
+	XC_INVITED,
+	XC_JOIN,
+	XC_KEYWORD,
+	XC_KICK,
+	XC_KILL,
+	XC_MSGSEND,
+	XC_MOTD,
+	XC_MOTDSKIP,
+	XC_NICKCLASH,
+	XC_NICKFAIL,
+	XC_NODCC,
+	XC_NOCHILD,
+	XC_NOTICE,
+	XC_NOTICESEND,
+	XC_NOTIFYEMPTY,
+	XC_NOTIFYHEAD,
+	XC_NOTIFYNUMBER,
+	XC_NOTIFYOFFLINE,
+	XC_NOTIFYONLINE,
+	XC_OPENDIALOG,
+	XC_PART,
+	XC_PARTREASON,
+	XC_PINGREP,
+	XC_PINGTIMEOUT,
+	XC_PRIVMSG,
+	XC_DPRIVMSG,
+	XC_ALREADYPROCESS,
+	XC_QUIT,
+	XC_RAWMODES,
+	XC_WALLOPS,
+	XC_RESOLVINGUSER,
+	XC_SERVERCONNECTED,
+	XC_SERVERERROR,
+	XC_SERVERLOOKUP,
+	XC_SERVNOTICE,
+	XC_SERVTEXT,
+	XC_STOPCONNECT,
+	XC_TOPIC,
+	XC_NEWTOPIC,
+	XC_TOPICDATE,
+	XC_UKNHOST,
+	XC_USERLIMIT,
+	XC_USERSONCHAN,
+	XC_WHOIS_AUTH,
+	XC_WHOIS5,
+	XC_WHOIS2,
+	XC_WHOIS6,
+	XC_WHOIS_ID,
+	XC_WHOIS4,
+	XC_WHOIS4T,
+	XC_WHOIS1,
+	XC_WHOIS_REALHOST,
+	XC_WHOIS3,
+	XC_WHOIS_SPECIAL,
+	XC_UJOIN,
+	XC_UKICK,
+	XC_UPART,
+	XC_UPARTREASON,
+	XC_UACTION,
+	XC_UINVITE,
+	XC_UCHANMSG,
+	XC_UCHANGENICK,
+	XC_SIZE
+};
+
+static print_event xc[] = {
+	{ "CHAT", "DCC Chat Text", -1, NULL },
+	{ "XC_APPFOCUS", "Focus Window", -3, NULL },
+	{ "XC_TABOPEN", "Open Context", -2, NULL },
+	{ "XC_TABCLOSE", "Close Context", -2, NULL },
+	{ "XC_TABFOCUS", "Focus Tab", -2, NULL },
+	{ "XC_KEYPRESS", "Key Press", 4, NULL },
+	{ "XC_ADDNOTIFY", "Add Notify", 1, NULL },
+	{ "XC_BANLIST", "Ban List", 4, NULL },
+	{ "XC_BANNED", "Banned", 1, NULL },
+	{ "XC_BEEP", "Beep", 0, NULL },
+	{ "XC_CHANGENICK", "Change Nick", 2, NULL },
+	{ "XC_CHANACTION", "Channel Action", 3, NULL },
+	{ "XC_HCHANACTION", "Channel Action Hilight", 3, NULL },
+	{ "XC_CHANBAN", "Channel Ban", 2, NULL },
+	{ "XC_CHANDATE", "Channel Creation", 2, NULL },
+	{ "XC_CHANDEHOP", "Channel DeHalfOp", 2, NULL },
+	{ "XC_CHANDEOP", "Channel DeOp", 2, NULL },
+	{ "XC_CHANDEVOICE", "Channel DeVoice", 2, NULL },
+	{ "XC_CHANEXEMPT", "Channel Exempt", 2, NULL },
+	{ "XC_CHANHOP", "Channel Half-Operator", 2, NULL },
+	{ "XC_CHANINVITE", "Channel INVITE", 2, NULL },
+	{ "XC_CHANLISTHEAD", "Channel List", 0, NULL },
+	{ "XC_CHANMSG", "Channel Message", 4, NULL },
+	{ "XC_CHANMODEGEN", "Channel Mode Generic", 4, NULL },
+	{ "XC_CHANMODES", "Channel Modes", 2, NULL },
+	{ "XC_HCHANMSG", "Channel Msg Hilight", 4, NULL },
+	{ "XC_CHANNOTICE", "Channel Notice", 3, NULL },
+	{ "XC_CHANOP", "Channel Operator", 2, NULL },
+	{ "XC_CHANRMEXEMPT", "Channel Remove Exempt", 2, NULL },
+	{ "XC_CHANRMINVITE", "Channel Remove Invite", 2, NULL },
+	{ "XC_CHANRMKEY", "Channel Remove Keyword", 1, NULL },
+	{ "XC_CHANRMLIMIT", "Channel Remove Limit", 1, NULL },
+	{ "XC_CHANSETKEY", "Channel Set Key", 2, NULL },
+	{ "XC_CHANSETLIMIT", "Channel Set Limit", 2, NULL },
+	{ "XC_CHANUNBAN", "Channel UnBan", 2, NULL },
+	{ "XC_CHANVOICE", "Channel Voice", 2, NULL },
+	{ "XC_CONNECTED", "Connected", 0, NULL },
+	{ "XC_CONNECT", "Connecting", 3, NULL },
+	{ "XC_CONNFAIL", "Connection Failed", 1, NULL },
+	{ "XC_CTCPGEN", "CTCP Generic", 2, NULL },
+	{ "XC_CTCPGENC", "CTCP Generic to Channel", 3, NULL },
+	{ "XC_CTCPSEND", "CTCP Send", 2, NULL },
+	{ "XC_CTCPSND", "CTCP Sound", 2, NULL },
+	{ "XC_CTCPSNDC", "CTCP Sound to Channel", 3, NULL },
+	{ "XC_DCCCHATABORT", "DCC CHAT Abort", 1, NULL },
+	{ "XC_DCCCONCHAT", "DCC CHAT Connect", 2, NULL },
+	{ "XC_DCCCHATF", "DCC CHAT Failed", 4, NULL },
+	{ "XC_DCCCHATOFFER", "DCC CHAT Offer", 1, NULL },
+	{ "XC_DCCCHATOFFERING", "DCC CHAT Offering", 1, NULL },
+	{ "XC_DCCCHATREOFFER", "DCC CHAT Reoffer", 1, NULL },
+	{ "XC_DCCCONFAIL", "DCC Conection Failed", 3, NULL },
+	{ "XC_DCCGENERICOFFER", "DCC Generic Offer", 2, NULL },
+	{ "XC_DCCHEAD", "DCC Header", 0, NULL },
+	{ "XC_MALFORMED", "DCC Malformed", 2, NULL },
+	{ "XC_DCCOFFER", "DCC Offer", 3, NULL },
+	{ "XC_DCCIVAL", "DCC Offer Not Valid", 0, NULL },
+	{ "XC_DCCRECVABORT", "DCC RECV Abort", 2, NULL },
+	{ "XC_DCCRECVCOMP", "DCC RECV Complete", 4, NULL },
+	{ "XC_DCCCONRECV", "DCC RECV Connect", 3, NULL },
+	{ "XC_DCCRECVERR", "DCC RECV Failed", 4, NULL },
+	{ "XC_DCCFILEERR", "DCC RECV File Open Error", 2, NULL },
+	{ "XC_DCCRENAME", "DCC Rename", 2, NULL },
+	{ "XC_DCCRESUMEREQUEST", "DCC RESUME Request", 3, NULL },
+	{ "XC_DCCSENDABORT", "DCC SEND Abort", 2, NULL },
+	{ "XC_DCCSENDCOMP", "DCC SEND Complete", 3, NULL },
+	{ "XC_DCCCONSEND", "DCC SEND Connect", 3, NULL },
+	{ "XC_DCCSENDFAIL", "DCC SEND Failed", 3, NULL },
+	{ "XC_DCCSENDOFFER", "DCC SEND Offer", 4, NULL },
+	{ "XC_DCCSTALL", "DCC Stall", 3, NULL },
+	{ "XC_DCCTOUT", "DCC Timeout", 3, NULL },
+	{ "XC_DELNOTIFY", "Delete Notify", 1, NULL },
+	{ "XC_DISCON", "Disconnected", 1, NULL },
+	{ "XC_FOUNDIP", "Found IP", 1, NULL },
+	{ "XC_GENMSG", "Generic Message", 2, NULL },
+	{ "XC_IGNOREADD", "Ignore Add", 1, NULL },
+	{ "XC_IGNORECHANGE", "Ignore Changed", 1, NULL },
+	{ "XC_IGNOREFOOTER", "Ignore Footer", 0, NULL },
+	{ "XC_IGNOREHEADER", "Ignore Header", 0, NULL },
+	{ "XC_IGNOREREMOVE", "Ignore Remove", 1, NULL },
+	{ "XC_IGNOREEMPTY", "Ignorelist Empty", 0, NULL },
+	{ "XC_INVITE", "Invite", 1, NULL },
+	{ "XC_INVITED", "Invited", 3, NULL },
+	{ "XC_JOIN", "Join", 3, NULL },
+	{ "XC_KEYWORD", "Keyword", 1, NULL },
+	{ "XC_KICK", "Kick", 4, NULL },
+	{ "XC_KILL", "Killed", 2, NULL },
+	{ "XC_MSGSEND", "Message Send", 2, NULL },
+	{ "XC_MOTD", "Motd", 1, NULL },
+	{ "XC_MOTDSKIP", "MOTD Skipped", 0, NULL },
+	{ "XC_NICKCLASH", "Nick Clash", 2, NULL },
+	{ "XC_NICKFAIL", "Nick Failed", 0, NULL },
+	{ "XC_NODCC", "No DCC", 0, NULL },
+	{ "XC_NOCHILD", "No Running Process", 0, NULL },
+	{ "XC_NOTICE", "Notice", 2, NULL },
+	{ "XC_NOTICESEND", "Notice Send", 2, NULL },
+	{ "XC_NOTIFYEMPTY", "Notify Empty", 0, NULL },
+	{ "XC_NOTIFYHEAD", "Notify Header", 0, NULL },
+	{ "XC_NOTIFYNUMBER", "Notify Number", 1, NULL },
+	{ "XC_NOTIFYOFFLINE", "Notify Offline", 3, NULL },
+	{ "XC_NOTIFYONLINE", "Notify Online", 3, NULL },
+	{ "XC_OPENDIALOG", "Open Dialog", 0, NULL },
+	{ "XC_PART", "Part", 3, NULL },
+	{ "XC_PARTREASON", "Part with Reason", 4, NULL },
+	{ "XC_PINGREP", "Ping Reply", 2, NULL },
+	{ "XC_PINGTIMEOUT", "Ping Timeout", 1, NULL },
+	{ "XC_PRIVMSG", "Private Message", 3, NULL },
+	{ "XC_DPRIVMSG", "Private Message to Dialog", 3, NULL },
+	{ "XC_ALREADYPROCESS", "Process Already Running", 0, NULL },
+	{ "XC_QUIT", "Quit", 3, NULL },
+	{ "XC_RAWMODES", "Raw Modes", 2, NULL },
+	{ "XC_WALLOPS", "Receive Wallops", 2, NULL },
+	{ "XC_RESOLVINGUSER", "Resolving User", 2, NULL },
+	{ "XC_SERVERCONNECTED", "Server Connected", 0, NULL },
+	{ "XC_SERVERERROR", "Server Error", 1, NULL },
+	{ "XC_SERVERLOOKUP", "Server Lookup", 1, NULL },
+	{ "XC_SERVNOTICE", "Server Notice", 2, NULL },
+	{ "XC_SERVTEXT", "Server Text", 2, NULL },
+	{ "XC_STOPCONNECT", "Stop Connection", 1, NULL },
+	{ "XC_TOPIC", "Topic", 2, NULL },
+	{ "XC_NEWTOPIC", "Topic Change", 3, NULL },
+	{ "XC_TOPICDATE", "Topic Creation", 3, NULL },
+	{ "XC_UKNHOST", "Unknown Host", 0, NULL },
+	{ "XC_USERLIMIT", "User Limit", 1, NULL },
+	{ "XC_USERSONCHAN", "Users On Channel", 2, NULL },
+	{ "XC_WHOIS_AUTH", "WhoIs Authenticated", 3, NULL },
+	{ "XC_WHOIS5", "WhoIs Away Line", 2, NULL },
+	{ "XC_WHOIS2", "WhoIs Channel/Oper Line", 2, NULL },
+	{ "XC_WHOIS6", "WhoIs End", 1, NULL },
+	{ "XC_WHOIS_ID", "WhoIs Identified", 2, NULL },
+	{ "XC_WHOIS4", "WhoIs Idle Line", 2, NULL },
+	{ "XC_WHOIS4T", "WhoIs Idle Line with Signon", 3, NULL },
+	{ "XC_WHOIS1", "WhoIs Name Line", 4, NULL },
+	{ "XC_WHOIS_REALHOST", "WhoIs Real Host", 4, NULL },
+	{ "XC_WHOIS3", "WhoIs Server Line", 2, NULL },
+	{ "XC_WHOIS_SPECIAL", "WhoIs Special", 3, NULL },
+	{ "XC_UJOIN", "You Join", 3, NULL },
+	{ "XC_UKICK", "You Kicked", 4, NULL },
+	{ "XC_UPART", "You Part", 3, NULL },
+	{ "XC_UPARTREASON", "You Part with Reason", 4, NULL },
+	{ "XC_UACTION", "Your Action", 3, NULL },
+	{ "XC_UINVITE", "Your Invitation", 3, NULL },
+	{ "XC_UCHANMSG", "Your Message", 4, NULL },
+	{ "XC_UCHANGENICK", "Your Nick Changing", 2, NULL }
+};
+
diff --git a/plugins/tcl/tclplugin.c b/plugins/tcl/tclplugin.c
new file mode 100644
index 00000000..17dc7556
--- /dev/null
+++ b/plugins/tcl/tclplugin.c
@@ -0,0 +1,2290 @@
+/***************************************************************************
+                           tclplugin.c  -  Tcl plugin for xchat 1.9.x / 2.x.x
+                           -------------------------------------------------s
+    begin                : Sat Nov 19 17:31:20 MST 2002
+    copyright            : Copyright 2002-2010 Daniel P. Stasinski
+    email                : daniel@avenues.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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+static char RCSID[] = "$Id: tclplugin.c,v 1.64 2010/03/10 04:24:16 mooooooo Exp $";
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <limits.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <tcl.h>
+#include <tclDecls.h>
+#include <sys/stat.h>
+
+#ifdef WIN32
+#include <windows.h>
+#define bzero(mem, sz) memset((mem), 0, (sz))
+#define bcopy(src, dest, count) memmove((dest), (src), (count))
+#else
+#include <unistd.h>
+#endif
+
+#include "xchat-plugin.h"
+#include "tclplugin.h"
+#include "printevents.h"
+
+static int nexttimerid = 0;
+static int nexttimerindex = 0;
+static timer timers[MAX_TIMERS];
+
+static char VERSION[16];
+
+static int initialized = 0;
+static int reinit_tried = 0;
+static Tcl_Interp *interp = NULL;
+static xchat_plugin *ph;
+static xchat_hook *raw_line_hook;
+static xchat_hook *Command_TCL_hook;
+static xchat_hook *Command_Source_hook;
+static xchat_hook *Command_Reload_hook;
+static xchat_hook *Command_Load_hook;
+static xchat_hook *Event_Handler_hook;
+static xchat_hook *Null_Command_hook;
+
+static int complete_level = 0;
+static t_complete complete[MAX_COMPLETES + 1];
+static Tcl_HashTable cmdTablePtr;
+static Tcl_HashTable aliasTablePtr;
+
+static int nextprocid = 0x1000;
+#define PROCPREFIX "__xctcl_"
+
+static char unknown[] = {
+"rename unknown iunknown\n"
+"proc ::unknown {args} {\n"
+"  global errorInfo errorCode\n"
+"  if { [string index [lindex $args 0] 0] == \"/\" } {\n"
+"    command \"[string range [join $args \" \"] 1 end]\"\n"
+"  } else {\n"
+"    set code [catch {uplevel iunknown $args} msg]\n"
+"    if {$code == 1} {\n"
+"      set new [split $errorInfo \\n]\n"
+"      set new [join [lrange $new 0 [expr {[llength $new] - 8}]] \\n]\n"
+"      return -code error -errorcode $errorCode -errorinfo $new $msg\n"
+"    } else {\n"
+"      return -code $code $msg\n"
+"    }\n"
+"  }\n"
+"}\n"
+"proc unsupported0 {from to {bytes \"\"}} {\n"
+"  set b [expr {$bytes == \"\" ? \"\" : \"-size [list $bytes]\"}]\n"
+"  eval [list fcopy $from $to] $b\n"
+"}\n"
+};
+
+static char sourcedirs[] = {
+    "set files [lsort [glob -nocomplain -directory [xchatdir] \"*.tcl\"]]\n"
+        "set init [lsearch -glob $files \"*/init.tcl\"]\n"
+        "if { $init > 0 } {\n"
+        "set initfile [lindex $files $init]\n"
+        "set files [lreplace $files $init $init]\n"
+        "set files [linsert $files 0 $initfile]\n" "}\n" "foreach f $files {\n" "if { [catch { source $f } errMsg] } {\n" "puts \"Tcl plugin\\tError sourcing \\\"$f\\\" ($errMsg)\"\n" "} else {\n" "puts \"Tcl plugin\\tSourced \\\"$f\\\"\"\n" "}\n" "}\n"
+};
+
+static char inlinetcl[] = {
+"proc splitsrc { } {\n"
+"uplevel \"scan \\$_src \\\"%\\\\\\[^!\\\\\\]!%\\\\\\[^@\\\\\\]@%s\\\" _nick _ident _host\"\n"
+"}\n"
+
+"proc ::exit { } {\n"
+"puts \"Using 'exit' is bad\"\n"
+"}\n"
+
+"proc ::away { args } { return [eval [join [list getinfo $args away]]] }\n"
+"proc ::channel { args } { return [eval [join [list getinfo $args channel]]] }\n"
+"proc ::tab { args } { return [eval [join [list getinfo $args channel]]] }\n"
+"proc ::charset { args } { return [eval [join [list getinfo $args charset]]] }\n"
+"proc ::host { args } { return [eval [join [list getinfo $args host]]] }\n"
+"proc ::inputbox { args } { return [eval [join [list getinfo $args inputbox]]] }\n"
+"proc ::libdirfs { args } { return [eval [join [list getinfo $args libdirfs]]] }\n"
+"proc ::network { args } { return [eval [join [list getinfo $args network]]] }\n"
+"proc ::nickserv { args } { return [eval [join [list getinfo $args nickserv]]] }\n"
+"proc ::server { args } { return [eval [join [list getinfo $args server]]] }\n"
+"proc ::version { args } { return [eval [join [list getinfo $args version]]] }\n"
+"proc ::win_status { args } { return [eval [join [list getinfo $args win_status]]] }\n"
+"proc ::xchatdir { args } { return [eval [join [list getinfo $args xchatdir]]] }\n"
+"proc ::xchatdirfs { args } { return [eval [join [list getinfo $args xchatdirfs]]] }\n"
+
+"proc ::color { {arg {}} } { return \"\\003$arg\" }\n"
+"proc ::bold { } { return \"\\002\" }\n"
+"proc ::underline { } { return \"\\037\" }\n"
+"proc ::reverse { } { return \"\\026\" }\n"
+"proc ::reset { } { return \"\\017\" }\n"
+
+"proc ::__xctcl_errorInfo { } {\n"
+"      set text [split $::errorInfo \\n]\n"
+"      puts [string trim [join [lrange $text 0 [expr {[llength $text] - 4}]] \\n]]\n"
+"}\n"
+
+"proc ::bgerror { message } {\n"
+"      set text [split $::errorInfo \\n]\n"
+"      puts [string trim [join [lrange $text 0 [expr {[llength $text] - 4}]] \\n]]\n"
+"}\n"
+};
+
+static void NiceErrorInfo ()
+{
+    Tcl_Eval(interp, "::__xctcl_errorInfo");
+}
+
+static void Tcl_MyDStringAppend(Tcl_DString * ds, char *string)
+{
+    Tcl_DStringAppend(ds, string, strlen(string));
+}
+
+static char *InternalProcName(int value)
+{
+    static char result[32];
+    sprintf(result, "%s%08x", PROCPREFIX, value);
+    return result;
+}
+
+static int SourceInternalProc(int id, const char *args, const char *source)
+{
+    Tcl_DString ds;
+    int result;
+    Tcl_DStringInit(&ds);
+
+    Tcl_MyDStringAppend(&ds, "proc ");
+    Tcl_MyDStringAppend(&ds, InternalProcName(id));
+    Tcl_MyDStringAppend(&ds, " { ");
+    Tcl_MyDStringAppend(&ds, args);
+    Tcl_MyDStringAppend(&ds, " } {\n");
+    Tcl_MyDStringAppend(&ds, source);
+    Tcl_MyDStringAppend(&ds, "\n}\n\n");
+
+    result = Tcl_Eval(interp, ds.string);
+
+    Tcl_DStringFree(&ds);
+
+    return result;
+}
+
+static int EvalInternalProc(const char *procname, int ct, ...)
+{
+    Tcl_DString ds;
+    int result;
+    va_list ap;
+    char *buf;
+
+    Tcl_DStringInit(&ds);
+
+    Tcl_MyDStringAppend(&ds, procname);
+
+    if (ct) {
+        va_start(ap, ct);
+        while (ct--) {
+            if ((buf = va_arg(ap, char *)) != NULL)
+                 Tcl_DStringAppendElement(&ds, buf);
+            else
+                Tcl_MyDStringAppend(&ds, " \"\"");
+        }
+        va_end(ap);
+    }
+
+    result = Tcl_Eval(interp, ds.string);
+
+    Tcl_DStringFree(&ds);
+
+    return result;
+}
+
+
+static void DeleteInternalProc(const char *proc)
+{
+    Tcl_DString ds;
+
+    Tcl_DStringInit(&ds);
+    Tcl_MyDStringAppend(&ds, "rename ");
+    Tcl_MyDStringAppend(&ds, proc);
+    Tcl_MyDStringAppend(&ds, " {}");
+    Tcl_Eval(interp, ds.string);
+    Tcl_DStringFree(&ds);
+}
+
+static char *StrDup(const char *string, int *length)
+{
+    char *result;
+
+    if (string == NULL)
+        return NULL;
+
+    *length = strlen(string);
+    result = Tcl_Alloc(*length + 1);
+    strncpy(result, string, *length);
+    result[*length] = 0;
+
+    return result;
+}
+
+static char *myitoa(long value)
+{
+    static char result[32];
+    sprintf(result, "%ld", value);
+    return result;
+}
+
+static xchat_context *atoctx(const char *nptr)
+{
+    int isnum = 1;
+    int x = 0;
+
+    if (!nptr)
+        return NULL;
+
+    while (isnum && nptr[x]) {
+        if (!isdigit(nptr[x++]))
+            isnum--;
+    }
+
+    if (isnum && x)
+        return (xchat_context *) atol(nptr);
+    else
+        return NULL;
+}
+
+static xchat_context *xchat_smart_context(const char *arg1, const char *arg2)
+{
+    const char *server, *s, *n;
+    xchat_context *result = NULL;
+    xchat_context *ctx = NULL;
+    xchat_context *actx = NULL;
+    xchat_list *list;
+
+    if (arg1 == NULL)
+        return xchat_get_context(ph);;
+
+    if (arg1 && arg2) {
+        result = xchat_find_context(ph, arg1, arg2);
+        if (result == NULL)
+            result = xchat_find_context(ph, arg2, arg1);
+        return result;
+    } else {
+
+        actx = atoctx(arg1);
+
+        server = xchat_get_info(ph, "server");
+
+        list = xchat_list_get(ph, "channels");
+
+        if (list != NULL) {
+
+            while (xchat_list_next(ph, list)) {
+
+                ctx = (xchat_context *)xchat_list_str(ph, list, "context");
+
+                if (actx) {
+                    if (ctx == actx) {
+                        result = ctx;
+                        break;
+                    }
+                } else {
+
+                    s = xchat_list_str(ph, list, "server");
+
+                    if (xchat_list_int(ph, list, "type") == 1) {
+                        if (strcasecmp(arg1, s) == 0) {
+                            result = ctx;
+                            break;
+                        }
+                        n = xchat_list_str(ph, list, "network");
+                        if (n) {
+                            if (strcasecmp(arg1, n) == 0) {
+                                result = ctx;
+                                break;
+                            }
+                        }
+                    } else {
+                        if ((strcasecmp(server, s) == 0) && (strcasecmp(arg1, xchat_list_str(ph, list, "channel")) == 0)) {
+                            result = ctx;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            xchat_list_free(ph, list);
+        }
+
+    }
+
+    return result;
+}
+
+static void queue_nexttimer()
+{
+    int x;
+    time_t then;
+
+    nexttimerindex = 0;
+    then = (time_t) 0x7fffffff;
+
+    for (x = 1; x < MAX_TIMERS; x++) {
+        if (timers[x].timerid) {
+            if (timers[x].timestamp < then) {
+                then = timers[x].timestamp;
+                nexttimerindex = x;
+            }
+        }
+    }
+}
+
+static int insert_timer(int seconds, int count, const char *script)
+{
+    int x;
+    int dummy;
+    time_t now;
+    int id;
+
+    if (script == NULL)
+        return (-1);
+
+    id = (nextprocid++ % INT_MAX) + 1;
+
+    now = time(NULL);
+
+    for (x = 1; x < MAX_TIMERS; x++) {
+        if (timers[x].timerid == 0) {
+            if (SourceInternalProc(id, "", script) == TCL_ERROR) {
+                xchat_printf(ph, "\0039TCL plugin\003\tERROR (timer %d) ", timers[x].timerid);
+                NiceErrorInfo ();
+                return (-1);
+            }
+            timers[x].timerid = (nexttimerid++ % INT_MAX) + 1;
+            timers[x].timestamp = now + seconds;
+            timers[x].count = count;
+            timers[x].seconds = seconds;
+            timers[x].procPtr = StrDup(InternalProcName(id), &dummy);
+            queue_nexttimer();
+            return (timers[x].timerid);
+        }
+    }
+
+    return (-1);
+}
+
+static void do_timer()
+{
+    xchat_context *origctx;
+    time_t now;
+    int index;
+
+    if (!nexttimerindex)
+        return;
+
+    now = time(NULL);
+
+    if (now < timers[nexttimerindex].timestamp)
+        return;
+
+    index = nexttimerindex;
+    origctx = xchat_get_context(ph);
+    if (EvalInternalProc(timers[index].procPtr, 0) == TCL_ERROR) {
+        xchat_printf(ph, "\0039TCL plugin\003\tERROR (timer %d) ", timers[index].timerid);
+        NiceErrorInfo ();
+    }
+    xchat_set_context(ph, origctx);
+
+    if (timers[index].count != -1)
+      timers[index].count--;
+
+    if (timers[index].count == 0) {
+      timers[index].timerid = 0;
+      if (timers[index].procPtr != NULL) {
+          DeleteInternalProc(timers[index].procPtr);
+          Tcl_Free(timers[index].procPtr);
+      }
+      timers[index].procPtr = NULL;
+    } else {
+      timers[index].timestamp += timers[index].seconds;
+    }
+
+    queue_nexttimer();
+
+    return;
+
+}
+
+static int Server_raw_line(char *word[], char *word_eol[], void *userdata)
+{
+    char *src, *cmd, *dest, *rest;
+    char *chancmd = NULL;
+    char *procList;
+    Tcl_HashEntry *entry = NULL;
+    xchat_context *origctx;
+    int len;
+    int dummy;
+    char *string = NULL;
+    int ctcp = 0;
+    int count;
+    int list_argc, proc_argc;
+    const char **list_argv, **proc_argv;
+    int private = 0;
+
+    if (word[0][0] == 0)
+        return XCHAT_EAT_NONE;
+
+    if (complete_level == MAX_COMPLETES)
+        return XCHAT_EAT_NONE;
+
+    complete_level++;
+    complete[complete_level].defresult = XCHAT_EAT_NONE;     /* XCHAT_EAT_PLUGIN; */
+    complete[complete_level].result = XCHAT_EAT_NONE;
+    complete[complete_level].word = word;
+	complete[complete_level].word_eol = word_eol;
+
+    if (word[1][0] == ':') {
+        src = word[1];
+        cmd = word[2];
+        dest = word[3];
+        rest = word_eol[4];
+    } else {
+        src = "";
+        cmd = word[1];
+        if (word_eol[2][0] == ':') {
+            dest = "";
+            rest = word_eol[2];
+        } else {
+            dest = word[2];
+            rest = word_eol[3];
+        }
+    }
+
+    if (src[0] == ':')
+        src++;
+    if (dest[0] == ':')
+        dest++;
+    if (rest[0] == ':')
+        rest++;
+
+    if (rest[0] == 0x01) {
+        rest++;
+        if (strcasecmp("PRIVMSG", cmd) == 0) {
+            if (strncasecmp(rest, "ACTION ", 7) == 0) {
+                cmd = "ACTION";
+                rest += 7;
+            } else
+                cmd = "CTCP";
+        } else if (!strcasecmp("NOTICE", cmd))
+            cmd = "CTCR";
+        ctcp = 1;
+    } else if (!strcasecmp("NOTICE", cmd) && (strchr(src, '!') == NULL)) {
+        cmd = "SNOTICE";
+    } else if (rest[0] == '!') {
+        chancmd = word[4] + 1;
+    }
+
+    if (chancmd != NULL) {
+        string = StrDup(chancmd, &dummy);
+        Tcl_UtfToUpper(string);
+        if ((entry = Tcl_FindHashEntry(&cmdTablePtr, string)) == NULL) {
+            Tcl_Free(string);
+        } else {
+            cmd = chancmd;
+            rest = word_eol[5];
+        }
+    }
+
+    if (entry == NULL) {
+        string = StrDup(cmd, &dummy);
+        Tcl_UtfToUpper(string);
+        entry = Tcl_FindHashEntry(&cmdTablePtr, string);
+    }
+
+    if (entry != NULL) {
+
+        procList = Tcl_GetHashValue(entry);
+
+        if (isalpha(dest[0]))
+            private = 1;
+
+        rest = StrDup(rest, &len);
+        if (ctcp) {
+            if (rest != NULL) {
+                if ((len > 1) && (rest[len - 1] == 0x01))
+                    rest[len - 1] = 0;
+            }
+        }
+
+        if (Tcl_SplitList(interp, procList, &list_argc, &list_argv) == TCL_OK) {
+
+            for (count = 0; count < list_argc; count++) {
+
+                if (Tcl_SplitList(interp, list_argv[count], &proc_argc, &proc_argv) != TCL_OK)
+                    continue;
+
+                origctx = xchat_get_context(ph);
+                if (EvalInternalProc(proc_argv[1], 7, src, dest, cmd, rest, word_eol[1], proc_argv[0], myitoa(private)) == TCL_ERROR) {
+                    xchat_printf(ph, "\0039TCL plugin\003\tERROR (on %s %s) ", cmd, proc_argv[0]);
+                    NiceErrorInfo ();
+                }
+                xchat_set_context(ph, origctx);
+
+                Tcl_Free((char *) proc_argv);
+
+                if ((complete[complete_level].result ==  XCHAT_EAT_PLUGIN) || (complete[complete_level].result == XCHAT_EAT_ALL))
+                    break;
+
+            }
+
+            Tcl_Free((char *) list_argv);
+
+        }
+
+        Tcl_Free(rest);
+
+    }
+
+    if (string)
+        Tcl_Free(string);
+
+    return complete[complete_level--].result;
+
+}
+
+static int Print_Hook(char *word[], void *userdata)
+{
+    char *procList;
+    Tcl_HashEntry *entry;
+    xchat_context *origctx;
+    int count;
+    int list_argc, proc_argc;
+    const char **list_argv, **proc_argv;
+    Tcl_DString ds;
+    int x;
+
+    if (complete_level == MAX_COMPLETES)
+        return XCHAT_EAT_NONE;
+
+    complete_level++;
+    complete[complete_level].defresult = XCHAT_EAT_NONE;     /* XCHAT_EAT_PLUGIN; */
+    complete[complete_level].result = XCHAT_EAT_NONE;
+    complete[complete_level].word = word;
+	complete[complete_level].word_eol = word;
+
+    if ((entry = Tcl_FindHashEntry(&cmdTablePtr, xc[(int) userdata].event)) != NULL) {
+
+        procList = Tcl_GetHashValue(entry);
+
+        if (Tcl_SplitList(interp, procList, &list_argc, &list_argv) == TCL_OK) {
+
+            for (count = 0; count < list_argc; count++) {
+
+                if (Tcl_SplitList(interp, list_argv[count], &proc_argc, &proc_argv) != TCL_OK)
+                    continue;
+
+                origctx = xchat_get_context(ph);
+
+                Tcl_DStringInit(&ds);
+
+                if ((int) userdata == CHAT) {
+                    Tcl_DStringAppend(&ds, word[3], strlen(word[3]));
+                    Tcl_DStringAppend(&ds, "!*@", 3);
+                    Tcl_DStringAppend(&ds, word[1], strlen(word[1]));
+                    if (EvalInternalProc(proc_argv[1], 7, ds.string, word[2], xc[(int) userdata].event, word[4], "", proc_argv[0], "0") == TCL_ERROR) {
+                        xchat_printf(ph, "\0039TCL plugin\003\tERROR (on %s %s) ", xc[(int) userdata].event, proc_argv[0]);
+                        NiceErrorInfo ();
+                    }
+                } else {
+                    if (xc[(int) userdata].argc > 0) {
+                        for (x = 0; x <= xc[(int) userdata].argc; x++)
+                            Tcl_DStringAppendElement(&ds, word[x]);
+                    }
+                    if (EvalInternalProc(proc_argv[1], 7, "", "", xc[(int) userdata].event, "", ds.string, proc_argv[0], "0") == TCL_ERROR) {
+                        xchat_printf(ph, "\0039Tcl plugin\003\tERROR (on %s %s) ", xc[(int) userdata].event, proc_argv[0]);
+                        NiceErrorInfo ();
+                    }
+                }
+
+                Tcl_DStringFree(&ds);
+
+                xchat_set_context(ph, origctx);
+
+                Tcl_Free((char *) proc_argv);
+
+                if ((complete[complete_level].result ==  XCHAT_EAT_PLUGIN) || (complete[complete_level].result ==  XCHAT_EAT_ALL))
+                    break;
+
+            }
+
+            Tcl_Free((char *) list_argv);
+
+        }
+    }
+
+    return complete[complete_level--].result;
+}
+
+
+static int tcl_timerexists(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    int x;
+    int timerid;
+
+    BADARGS(2, 2, " schedid");
+
+    if (Tcl_GetInt(irp, argv[1], &timerid) != TCL_OK) {
+        Tcl_AppendResult(irp, "Invalid timer id", NULL);
+        return TCL_ERROR;
+    }
+
+    if (timerid) {
+        for (x = 1; x < MAX_TIMERS; x++) {
+            if (timers[x].timerid == timerid) {
+                Tcl_AppendResult(irp, "1", NULL);
+                return TCL_OK;
+            }
+        }
+    }
+
+    Tcl_AppendResult(irp, "0", NULL);
+
+    return TCL_OK;
+}
+
+static int tcl_killtimer(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    int x;
+    int timerid;
+
+    BADARGS(2, 2, " timerid");
+
+    if (Tcl_GetInt(irp, argv[1], &timerid) != TCL_OK) {
+        Tcl_AppendResult(irp, "Invalid timer id", NULL);
+        return TCL_ERROR;
+    }
+
+    if (timerid) {
+        for (x = 1; x < MAX_TIMERS; x++) {
+            if (timers[x].timerid == timerid) {
+                timers[x].timerid = 0;
+                if (timers[x].procPtr != NULL) {
+                    DeleteInternalProc(timers[x].procPtr);
+                    Tcl_Free(timers[x].procPtr);
+                }
+                timers[x].procPtr = NULL;
+                break;
+            }
+        }
+    }
+
+    queue_nexttimer();
+
+    return TCL_OK;
+}
+
+static int tcl_timers(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    int x;
+    Tcl_DString ds;
+    time_t now;
+
+    BADARGS(1, 1, "");
+
+    now = time(NULL);
+
+    Tcl_DStringInit(&ds);
+
+    for (x = 1; x < MAX_TIMERS; x++) {
+        if (timers[x].timerid) {
+            Tcl_DStringStartSublist(&ds);
+            Tcl_DStringAppendElement(&ds, myitoa((long)timers[x].timerid));
+            Tcl_DStringAppendElement(&ds, myitoa((long)timers[x].timestamp - now));
+            Tcl_DStringAppendElement(&ds, timers[x].procPtr);
+            Tcl_DStringAppendElement(&ds, myitoa((long)timers[x].seconds));
+            Tcl_DStringAppendElement(&ds, myitoa((long)timers[x].count));
+            Tcl_DStringEndSublist(&ds);
+        }
+    }
+
+    Tcl_AppendResult(interp, ds.string, NULL);
+    Tcl_DStringFree(&ds);
+
+    return TCL_OK;
+}
+
+static int tcl_timer(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    int seconds;
+    int timerid;
+    int repeat = 0;
+    int count = 0;
+    int first = 1;
+    char reply[32];
+
+    BADARGS(3, 6, " ?-repeat? ?-count times? seconds {script | procname ?args?}");
+
+    while (argc--) {
+        if (strcasecmp(argv[first], "-repeat") == 0) {
+            repeat++;
+        } else if (strcasecmp(argv[first], "-count") == 0) {
+            if (Tcl_GetInt(irp, argv[++first], &count) != TCL_OK)
+                return TCL_ERROR;
+        } else {
+            break;
+        }
+        first++;
+    }
+
+    if (repeat && !count)
+      count = -1;
+
+    if (!count)
+      count = 1;
+
+    if (Tcl_GetInt(irp, argv[first++], &seconds) != TCL_OK)
+        return TCL_ERROR;
+
+    if ((timerid = insert_timer(seconds, count, argv[first++])) == -1) {
+        Tcl_AppendResult(irp, "0", NULL);
+        return TCL_ERROR;
+    }
+
+    sprintf(reply, "%d", timerid);
+
+    Tcl_AppendResult(irp, reply, NULL);
+
+    queue_nexttimer();
+
+    return TCL_OK;
+}
+
+static int tcl_on(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    int newentry;
+    char *procList;
+    Tcl_HashEntry *entry;
+    char *token;
+    int dummy;
+    Tcl_DString ds;
+    int index;
+    int count;
+    int list_argc, proc_argc;
+    int id;
+    const char **list_argv, **proc_argv;
+
+    BADARGS(4, 4, " token label {script | procname ?args?}");
+
+    id = (nextprocid++ % INT_MAX) + 1;
+
+    if (SourceInternalProc(id, "_src _dest _cmd _rest _raw _label _private", argv[3]) == TCL_ERROR) {
+        xchat_printf(ph, "\0039Tcl plugin\003\tERROR (on %s:%s) ", argv[1], argv[2]);
+        NiceErrorInfo ();
+        return TCL_OK;
+    }
+
+    token = StrDup(argv[1], &dummy);
+    Tcl_UtfToUpper(token);
+
+    Tcl_DStringInit(&ds);
+
+    entry = Tcl_CreateHashEntry(&cmdTablePtr, token, &newentry);
+    if (!newentry) {
+        procList = Tcl_GetHashValue(entry);
+        if (Tcl_SplitList(interp, procList, &list_argc, &list_argv) == TCL_OK) {
+            for (count = 0; count < list_argc; count++) {
+                if (Tcl_SplitList(interp, list_argv[count], &proc_argc, &proc_argv) != TCL_OK)
+                    continue;
+                if (strcmp(proc_argv[0], argv[2])) {
+                    Tcl_DStringStartSublist(&ds);
+                    Tcl_DStringAppendElement(&ds, proc_argv[0]);
+                    Tcl_DStringAppendElement(&ds, proc_argv[1]);
+                    Tcl_DStringEndSublist(&ds);
+                } else {
+                    DeleteInternalProc(proc_argv[1]);
+                }
+                Tcl_Free((char *) proc_argv);
+            }
+            Tcl_Free((char *) list_argv);
+        }
+        Tcl_Free(procList);
+    }
+
+    Tcl_DStringStartSublist(&ds);
+    Tcl_DStringAppendElement(&ds, argv[2]);
+    Tcl_DStringAppendElement(&ds, InternalProcName(id));
+    Tcl_DStringEndSublist(&ds);
+
+    procList = StrDup(ds.string, &dummy);
+
+    Tcl_SetHashValue(entry, procList);
+
+    if ((strncmp(token, "XC_", 3) == 0) || (strcmp(token, "CHAT") == 0)) {
+        for (index = 0; index < XC_SIZE; index++) {
+            if (strcmp(xc[index].event, token) == 0) {
+                if (xc[index].hook == NULL) {
+                    xc[index].hook = xchat_hook_print(ph, xc[index].emit, XCHAT_PRI_NORM, Print_Hook, (void *) index);
+                    break;
+                }
+            }
+        }
+    }
+
+    Tcl_Free(token);
+    Tcl_DStringFree(&ds);
+
+    return TCL_OK;
+}
+
+static int tcl_off(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    char *procList;
+    Tcl_HashEntry *entry;
+    char *token;
+    int dummy;
+    Tcl_DString ds;
+    int index;
+    int count;
+    int list_argc, proc_argc;
+    const char **list_argv, **proc_argv;
+
+    BADARGS(2, 3, " token ?label?");
+
+    token = StrDup(argv[1], &dummy);
+    Tcl_UtfToUpper(token);
+
+    Tcl_DStringInit(&ds);
+
+    if ((entry = Tcl_FindHashEntry(&cmdTablePtr, token)) != NULL) {
+
+        procList = Tcl_GetHashValue(entry);
+
+        if (argc == 3) {
+            if (Tcl_SplitList(interp, procList, &list_argc, &list_argv) == TCL_OK) {
+                for (count = 0; count < list_argc; count++) {
+                    if (Tcl_SplitList(interp, list_argv[count], &proc_argc, &proc_argv) != TCL_OK)
+                        continue;
+                    if (strcmp(proc_argv[0], argv[2])) {
+                        Tcl_DStringStartSublist(&ds);
+                        Tcl_DStringAppendElement(&ds, proc_argv[0]);
+                        Tcl_DStringAppendElement(&ds, proc_argv[1]);
+                        Tcl_DStringEndSublist(&ds);
+                    } else
+                        DeleteInternalProc(proc_argv[1]);
+                    Tcl_Free((char *) proc_argv);
+                }
+                Tcl_Free((char *) list_argv);
+            }
+        }
+
+        Tcl_Free(procList);
+
+        if (ds.length) {
+            procList = StrDup(ds.string, &dummy);
+            Tcl_SetHashValue(entry, procList);
+        } else {
+            Tcl_DeleteHashEntry(entry);
+        }
+
+        if (!ds.length) {
+            if ((strncmp(token, "XC_", 3) == 0) || (strcmp(token, "CHAT") == 0)) {
+                for (index = 0; index < XC_SIZE; index++) {
+                    if (strcmp(xc[index].event, token) == 0) {
+                        if (xc[index].hook != NULL) {
+                            xchat_unhook(ph, xc[index].hook);
+                            xc[index].hook = NULL;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Tcl_Free(token);
+    Tcl_DStringFree(&ds);
+
+    return TCL_OK;
+}
+
+static int tcl_alias(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    int newentry;
+    alias *aliasPtr;
+    Tcl_HashEntry *entry;
+    char *string;
+    const char *help = NULL;
+    int dummy;
+    int id;
+
+    BADARGS(3, 4, " name ?help? {script | procname ?args?}");
+
+    string = StrDup(argv[1], &dummy);
+    Tcl_UtfToUpper(string);
+
+    if (strlen(argv[argc - 1])) {
+
+        if (argc == 4)
+            help = argv[2];
+
+        id = (nextprocid++ % INT_MAX) + 1;
+
+        if (SourceInternalProc(id, "_cmd _rest", argv[argc - 1]) == TCL_ERROR) {
+            xchat_printf(ph, "\0039Tcl plugin\003\tERROR (alias %s) ", argv[1]);
+            NiceErrorInfo ();
+            return TCL_OK;
+        }
+
+        entry = Tcl_CreateHashEntry(&aliasTablePtr, string, &newentry);
+        if (newentry) {
+            aliasPtr = (alias *) Tcl_Alloc(sizeof(alias));
+            if (string[0] == '@')
+                aliasPtr->hook = NULL;
+            else
+                aliasPtr->hook = xchat_hook_command(ph, string, XCHAT_PRI_NORM, Command_Alias, help, 0);
+        } else {
+            aliasPtr = Tcl_GetHashValue(entry);
+            DeleteInternalProc(aliasPtr->procPtr);
+            Tcl_Free(aliasPtr->procPtr);
+        }
+
+        aliasPtr->procPtr = StrDup(InternalProcName(id), &dummy);
+
+        Tcl_SetHashValue(entry, aliasPtr);
+
+    } else {
+
+        if ((entry = Tcl_FindHashEntry(&aliasTablePtr, string)) != NULL) {
+            aliasPtr = Tcl_GetHashValue(entry);
+            DeleteInternalProc(aliasPtr->procPtr);
+            Tcl_Free(aliasPtr->procPtr);
+            if (aliasPtr->hook)
+                xchat_unhook(ph, aliasPtr->hook);
+            Tcl_Free((char *) aliasPtr);
+            Tcl_DeleteHashEntry(entry);
+        }
+    }
+
+    Tcl_Free(string);
+
+    return TCL_OK;
+}
+
+static int tcl_complete(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    BADARGS(1, 2, " ?EAT_NONE|EAT_XCHAT|EAT_PLUGIN|EAT_ALL?");
+
+    if (argc == 2) {
+        if (Tcl_GetInt(irp, argv[1], &complete[complete_level].result) != TCL_OK) {
+            if (strcasecmp("EAT_NONE", argv[1]) == 0)
+                complete[complete_level].result = XCHAT_EAT_NONE;
+            else if (strcasecmp("EAT_XCHAT", argv[1]) == 0)
+                complete[complete_level].result = XCHAT_EAT_XCHAT;
+            else if (strcasecmp("EAT_PLUGIN", argv[1]) == 0)
+                complete[complete_level].result = XCHAT_EAT_PLUGIN;
+            else if (strcasecmp("EAT_ALL", argv[1]) == 0)
+                complete[complete_level].result = XCHAT_EAT_ALL;
+            else
+                BADARGS(1, 2, " ?EAT_NONE|EAT_XCHAT|EAT_PLUGIN|EAT_ALL?");
+        }
+    } else
+        complete[complete_level].result = complete[complete_level].defresult;
+
+    return TCL_RETURN;
+}
+
+static int tcl_command(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_context *origctx;
+    xchat_context *ctx = NULL;
+    const char *string = NULL;
+
+    BADARGS(2, 4, " ?server|network|context? ?#channel|nick? text");
+
+    origctx = xchat_get_context(ph);
+
+    switch (argc) {
+    case 2:
+        ctx = origctx;
+        break;
+    case 3:
+        ctx = xchat_smart_context(argv[1], NULL);
+        break;
+    case 4:
+        ctx = xchat_smart_context(argv[1], argv[2]);
+        break;
+    default:;
+    }
+
+    CHECKCTX(ctx);
+
+    string = argv[argc - 1];
+
+    if (string[0] == '/')
+        string++;
+
+    xchat_set_context(ph, ctx);
+    xchat_command(ph, string);
+    xchat_set_context(ph, origctx);
+
+    return TCL_OK;
+}
+
+static int tcl_raw(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_context *origctx;
+    xchat_context *ctx = NULL;
+    const char *string = NULL;
+
+    BADARGS(2, 4, " ?server|network|context? ?#channel|nick? text");
+
+    origctx = xchat_get_context(ph);
+
+    switch (argc) {
+    case 2:
+        ctx = origctx;
+        break;
+    case 3:
+        ctx = xchat_smart_context(argv[1], NULL);
+        break;
+    case 4:
+        ctx = xchat_smart_context(argv[1], argv[2]);
+        break;
+    default:;
+    }
+
+    CHECKCTX(ctx);
+
+    string = argv[argc - 1];
+
+    xchat_set_context(ph, ctx);
+    xchat_commandf(ph, "RAW %s", string);
+    xchat_set_context(ph, origctx);
+
+    return TCL_OK;
+}
+
+
+static int tcl_prefs(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    int i;
+    const char *str;
+
+    BADARGS(2, 2, " name");
+
+    switch (xchat_get_prefs (ph, argv[1], &str, &i)) {
+        case 1:
+            Tcl_AppendResult(irp, str, NULL);
+            break;
+        case 2:
+        case 3:
+            Tcl_AppendResult(irp, myitoa(i), NULL);
+            break;
+        default:
+            Tcl_AppendResult(irp, NULL);
+    }
+
+    return TCL_OK;
+}
+
+static int tcl_info(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[], char *id)
+{
+    char *result;
+    int max_argc;
+    xchat_context *origctx, *ctx;
+
+    if (id == NULL) {
+        BADARGS(2, 3, " ?server|network|context? id");
+        max_argc = 3;
+    } else {
+        BADARGS(1, 2, " ?server|network|context?");
+        max_argc = 2;
+    }
+
+    origctx = xchat_get_context(ph);
+
+    if (argc == max_argc) {
+        ctx = xchat_smart_context(argv[1], NULL);
+        CHECKCTX(ctx);
+        xchat_set_context(ph, ctx);
+    }
+
+    if (id == NULL)
+      id = argv[argc-1];
+
+    if ((result = xchat_get_info(ph, id)) == NULL)
+        result = "";
+
+    Tcl_AppendResult(irp, result, NULL);
+
+    xchat_set_context(ph, origctx);
+
+    return TCL_OK;
+}
+
+static int tcl_me(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    return tcl_info(cd, irp, argc, argv, "nick");
+}
+
+static int tcl_getinfo(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    return tcl_info(cd, irp, argc, argv, NULL);
+}
+
+static int tcl_getlist(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_list *list = NULL;
+    const char *name = NULL;
+    const char * const *fields;
+    const char *field;
+    const char *sattr;
+    int iattr;
+    int i;
+    time_t t;
+    Tcl_DString ds;
+    xchat_context *origctx;
+    xchat_context *ctx = NULL;
+
+    origctx = xchat_get_context(ph);
+
+    BADARGS(1, 2, " list");
+
+    Tcl_DStringInit(&ds);
+
+    fields = xchat_list_fields(ph, "lists");
+
+    if (argc == 1) {
+        for (i = 0; fields[i] != NULL; i++) {
+            Tcl_DStringAppendElement(&ds, fields[i]);
+        }
+        goto done;
+    }
+
+    for (i = 0; fields[i] != NULL; i++) {
+        if (strcmp(fields[i], argv[1]) == 0) {
+            name = fields[i];
+            break;
+        }
+    }
+
+    if (name == NULL)
+        goto done;
+
+    list = xchat_list_get(ph, name);
+    if (list == NULL)
+        goto done;
+
+    fields = xchat_list_fields(ph, name);
+
+    Tcl_DStringStartSublist(&ds);
+    for (i = 0; fields[i] != NULL; i++) {
+        field = fields[i] + 1;
+        Tcl_DStringAppendElement(&ds, field);
+    }
+    Tcl_DStringEndSublist(&ds);
+
+    while (xchat_list_next(ph, list)) {
+
+        Tcl_DStringStartSublist(&ds);
+
+        for (i = 0; fields[i] != NULL; i++) {
+
+            field = fields[i] + 1;
+
+            switch (fields[i][0]) {
+            case 's':
+                sattr = xchat_list_str(ph, list, (char *) field);
+                Tcl_DStringAppendElement(&ds, sattr);
+                break;
+            case 'i':
+                iattr = xchat_list_int(ph, list, (char *) field);
+                Tcl_DStringAppendElement(&ds, myitoa((long)iattr));
+                break;
+            case 't':
+                t = xchat_list_time(ph, list, (char *) field);
+                Tcl_DStringAppendElement(&ds, myitoa((long)t));
+                break;
+            case 'p':
+                sattr = xchat_list_str(ph, list, (char *) field);
+                if (strcmp(field, "context") == 0) {
+                    ctx = (xchat_context *) sattr;
+                    Tcl_DStringAppendElement(&ds, myitoa((long)ctx));
+                } else
+                    Tcl_DStringAppendElement(&ds, "*");
+                break;
+            default:
+                Tcl_DStringAppendElement(&ds, "*");
+                break;
+            }
+        }
+
+        Tcl_DStringEndSublist(&ds);
+
+    }
+
+    xchat_list_free(ph, list);
+
+  done:
+
+    xchat_set_context(ph, origctx);
+
+    Tcl_AppendResult(irp, ds.string, NULL);
+
+    Tcl_DStringFree(&ds);
+
+    return TCL_OK;
+}
+
+/*
+ * tcl_xchat_puts - stub for tcl puts command
+ * This is modified from the original internal "puts" command.  It redirects
+ * stdout to the current context, while still allowing all normal puts features
+ */
+
+static int tcl_xchat_puts(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    Tcl_Channel chan;
+    const char *string;
+    int newline;
+    const char *channelId = NULL;
+    int result;
+    int mode;
+    int trap_stdout = 0;
+
+    switch (argc) {
+
+    case 2:
+        string = argv[1];
+        newline = 1;
+        trap_stdout = 1;
+        break;
+
+    case 3:
+        if (strcmp(argv[1], "-nonewline") == 0) {
+            newline = 0;
+            trap_stdout = 1;
+        } else {
+            newline = 1;
+            channelId = argv[1];
+        }
+        string = argv[2];
+        break;
+
+    case 4:
+        if (strcmp(argv[1], "-nonewline") == 0) {
+            channelId = argv[2];
+            string = argv[3];
+        } else {
+            if (strcmp(argv[3], "nonewline") != 0) {
+                Tcl_AppendResult(interp, "bad argument \"", argv[3], "\": should be \"nonewline\"", (char *) NULL);
+                return TCL_ERROR;
+            }
+            channelId = argv[1];
+            string = argv[2];
+        }
+        newline = 0;
+        break;
+
+    default:
+        Tcl_AppendResult(interp, argv, "?-nonewline? ?channelId? string", NULL);
+        return TCL_ERROR;
+    }
+
+    if (!trap_stdout && (strcmp(channelId, "stdout") == 0))
+        trap_stdout = 1;
+
+    if (trap_stdout) {
+        if (newline)
+            xchat_printf(ph, "%s\n", string);
+        else
+            xchat_print(ph, string);
+        return TCL_OK;
+    }
+
+    chan = Tcl_GetChannel(interp, channelId, &mode);
+    if (chan == (Tcl_Channel) NULL) {
+        return TCL_ERROR;
+    }
+    if ((mode & TCL_WRITABLE) == 0) {
+        Tcl_AppendResult(interp, "channel \"", channelId, "\" wasn't opened for writing", (char *) NULL);
+        return TCL_ERROR;
+    }
+
+    result = Tcl_Write(chan, string, strlen(string));
+    if (result < 0) {
+        goto error;
+    }
+    if (newline != 0) {
+        result = Tcl_WriteChars(chan, "\n", 1);
+        if (result < 0) {
+            goto error;
+        }
+    }
+    return TCL_OK;
+
+  error:
+    Tcl_AppendResult(interp, "error writing \"", channelId, "\": ", Tcl_PosixError(interp), (char *) NULL);
+
+    return TCL_ERROR;
+}
+
+static int tcl_print(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_context *origctx;
+    xchat_context *ctx = NULL;
+    const char *string = NULL;
+
+    BADARGS(2, 4, " ?server|network|context? ?#channel|nick? text");
+
+    origctx = xchat_get_context(ph);
+
+    switch (argc) {
+    case 2:
+        ctx = origctx;
+        break;
+    case 3:
+        ctx = xchat_smart_context(argv[1], NULL);
+        break;
+    case 4:
+        ctx = xchat_smart_context(argv[1], argv[2]);
+        break;
+    default:;
+    }
+
+    CHECKCTX(ctx);
+
+    string = argv[argc - 1];
+
+    xchat_set_context(ph, ctx);
+    xchat_print(ph, string);
+    xchat_set_context(ph, origctx);
+
+    return TCL_OK;
+}
+
+static int tcl_setcontext(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_context *ctx = NULL;
+
+    BADARGS(2, 2, " context");
+
+    ctx = xchat_smart_context(argv[1], NULL);
+
+    CHECKCTX(ctx);
+
+    xchat_set_context(ph, ctx);
+
+    return TCL_OK;
+}
+
+static int tcl_findcontext(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_context *ctx = NULL;
+
+    BADARGS(1, 3, " ?server|network|context? ?channel?");
+
+    switch (argc) {
+    case 1:
+        ctx = xchat_find_context(ph, NULL, NULL);
+        break;
+    case 2:
+        ctx = xchat_smart_context(argv[1], NULL);
+        break;
+    case 3:
+        ctx = xchat_smart_context(argv[1], argv[2]);
+        break;
+    default:;
+    }
+
+    CHECKCTX(ctx);
+
+    Tcl_AppendResult(irp, myitoa((long)ctx), NULL);
+
+    return TCL_OK;
+}
+
+static int tcl_getcontext(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_context *ctx = NULL;
+
+    BADARGS(1, 1, "");
+
+    ctx = xchat_get_context(ph);
+
+    Tcl_AppendResult(irp, myitoa((long)ctx), NULL);
+
+    return TCL_OK;
+}
+
+static int tcl_channels(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    const char *server, *channel;
+    xchat_list *list;
+    Tcl_DString ds;
+    xchat_context *origctx;
+    xchat_context *ctx;
+
+    origctx = xchat_get_context(ph);
+
+    BADARGS(1, 2, " ?server|network|context?");
+
+    if (argc == 2) {
+        ctx = xchat_smart_context(argv[1], NULL);
+        CHECKCTX(ctx);
+        xchat_set_context(ph, ctx);
+    }
+
+    server = (char *) xchat_get_info(ph, "server");
+
+    Tcl_DStringInit(&ds);
+
+    list = xchat_list_get(ph, "channels");
+
+    if (list != NULL) {
+        while (xchat_list_next(ph, list)) {
+            if (xchat_list_int(ph, list, "type") != 2)
+                continue;
+            if (strcasecmp(server, xchat_list_str(ph, list, "server")) != 0)
+                continue;
+            channel = xchat_list_str(ph, list, "channel");
+            Tcl_DStringAppendElement(&ds, channel);
+        }
+        xchat_list_free(ph, list);
+    }
+
+    Tcl_AppendResult(irp, ds.string, NULL);
+
+    Tcl_DStringFree(&ds);
+
+    xchat_set_context(ph, origctx);
+
+    return TCL_OK;
+}
+
+static int tcl_servers(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    const char *server;
+    xchat_list *list;
+    Tcl_DString ds;
+
+    BADARGS(1, 1, "");
+
+    Tcl_DStringInit(&ds);
+
+    list = xchat_list_get(ph, "channels");
+
+    if (list != NULL) {
+        while (xchat_list_next(ph, list)) {
+            if (xchat_list_int(ph, list, "type") == 1) {
+                server = xchat_list_str(ph, list, "server");
+                Tcl_DStringAppendElement(&ds, server);
+            }
+        }
+        xchat_list_free(ph, list);
+    }
+
+    Tcl_AppendResult(irp, ds.string, NULL);
+
+    Tcl_DStringFree(&ds);
+
+    return TCL_OK;
+}
+
+static int tcl_queries(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    const char *server, *channel;
+    xchat_list *list;
+    Tcl_DString ds;
+    xchat_context *origctx;
+    xchat_context *ctx;
+
+    origctx = xchat_get_context(ph);
+
+    BADARGS(1, 2, " ?server|network|context?");
+
+    if (argc == 2) {
+        ctx = xchat_smart_context(argv[1], NULL);
+        CHECKCTX(ctx);
+        xchat_set_context(ph, ctx);
+    }
+
+    server = (char *) xchat_get_info(ph, "server");
+
+    Tcl_DStringInit(&ds);
+
+    list = xchat_list_get(ph, "channels");
+
+    if (list != NULL) {
+        while (xchat_list_next(ph, list)) {
+            if (xchat_list_int(ph, list, "type") != 3)
+                continue;
+            if (strcasecmp(server, xchat_list_str(ph, list, "server")) != 0)
+                continue;
+            channel = xchat_list_str(ph, list, "channel");
+            Tcl_DStringAppendElement(&ds, channel);
+        }
+        xchat_list_free(ph, list);
+    }
+
+    Tcl_AppendResult(irp, ds.string, NULL);
+
+    Tcl_DStringFree(&ds);
+
+    xchat_set_context(ph, origctx);
+
+    return TCL_OK;
+}
+
+static int tcl_users(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_context *origctx, *ctx = NULL;
+    xchat_list *list;
+    Tcl_DString ds;
+
+    BADARGS(1, 3, " ?server|network|context? ?channel?");
+
+    origctx = xchat_get_context(ph);
+
+    switch (argc) {
+    case 1:
+        ctx = origctx;
+        break;
+    case 2:
+        ctx = xchat_smart_context(argv[1], NULL);
+        break;
+    case 3:
+        ctx = xchat_smart_context(argv[1], argv[2]);
+        break;
+    default:;
+    }
+
+    CHECKCTX(ctx);
+
+    xchat_set_context(ph, ctx);
+
+    Tcl_DStringInit(&ds);
+
+    list = xchat_list_get(ph, "users");
+
+    if (list != NULL) {
+
+        Tcl_DStringStartSublist(&ds);
+        Tcl_DStringAppendElement(&ds, "nick");
+        Tcl_DStringAppendElement(&ds, "host");
+        Tcl_DStringAppendElement(&ds, "prefix");
+        Tcl_DStringAppendElement(&ds, "away");
+        Tcl_DStringAppendElement(&ds, "lasttalk");
+        Tcl_DStringAppendElement(&ds, "selected");
+        Tcl_DStringEndSublist(&ds);
+
+        while (xchat_list_next(ph, list)) {
+            Tcl_DStringStartSublist(&ds);
+            Tcl_DStringAppendElement(&ds, (const char *) xchat_list_str(ph, list, "nick"));
+            Tcl_DStringAppendElement(&ds, (const char *) xchat_list_str(ph, list, "host"));
+            Tcl_DStringAppendElement(&ds, (const char *) xchat_list_str(ph, list, "prefix"));
+            Tcl_DStringAppendElement(&ds, myitoa((long)xchat_list_int(ph, list, "away")));
+            Tcl_DStringAppendElement(&ds, myitoa((long)xchat_list_time(ph, list, "lasttalk")));
+            Tcl_DStringAppendElement(&ds, myitoa((long)xchat_list_int(ph, list, "selected")));
+            Tcl_DStringEndSublist(&ds);
+        }
+
+        xchat_list_free(ph, list);
+    }
+
+    Tcl_AppendResult(irp, ds.string, NULL);
+
+    Tcl_DStringFree(&ds);
+
+    xchat_set_context(ph, origctx);
+
+    return TCL_OK;
+}
+
+static int tcl_notifylist(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_list *list;
+    Tcl_DString ds;
+
+    BADARGS(1, 1, "");
+
+    Tcl_DStringInit(&ds);
+
+    list = xchat_list_get(ph, "notify");
+
+    if (list != NULL) {
+
+        Tcl_DStringStartSublist(&ds);
+        Tcl_DStringAppendElement(&ds, "nick");
+        Tcl_DStringAppendElement(&ds, "flags");
+        Tcl_DStringAppendElement(&ds, "on");
+        Tcl_DStringAppendElement(&ds, "off");
+        Tcl_DStringAppendElement(&ds, "seen");
+        Tcl_DStringAppendElement(&ds, "networks");
+        Tcl_DStringEndSublist(&ds);
+
+        while (xchat_list_next(ph, list)) {
+            Tcl_DStringStartSublist(&ds);
+            Tcl_DStringAppendElement(&ds, (const char *) xchat_list_str(ph, list, "nick"));
+            Tcl_DStringAppendElement(&ds, (const char *) xchat_list_str(ph, list, "flags"));
+            Tcl_DStringAppendElement(&ds, myitoa((long)xchat_list_time(ph, list, "on")));
+            Tcl_DStringAppendElement(&ds, myitoa((long)xchat_list_time(ph, list, "off")));
+            Tcl_DStringAppendElement(&ds, myitoa((long)xchat_list_time(ph, list, "seen")));
+            Tcl_DStringAppendElement(&ds, (const char *) xchat_list_str(ph, list, "networks"));
+            Tcl_DStringEndSublist(&ds);
+        }
+
+        xchat_list_free(ph, list);
+
+    }
+
+    Tcl_AppendResult(irp, ds.string, NULL);
+
+    Tcl_DStringFree(&ds);
+
+    return TCL_OK;
+}
+
+static int tcl_chats(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_list *list;
+    Tcl_DString ds;
+
+    BADARGS(1, 1, "");
+
+    Tcl_DStringInit(&ds);
+
+    list = xchat_list_get(ph, "dcc");
+
+    if (list != NULL) {
+        while (xchat_list_next(ph, list)) {
+            switch (xchat_list_int(ph, list, "type")) {
+            case 2:
+            case 3:
+                if (xchat_list_int(ph, list, "status") == 1)
+                    Tcl_DStringAppendElement(&ds, (const char *) xchat_list_str(ph, list, "nick"));
+                break;
+            }
+        }
+        xchat_list_free(ph, list);
+    }
+
+    Tcl_AppendResult(irp, ds.string, NULL);
+
+    Tcl_DStringFree(&ds);
+
+    return TCL_OK;
+}
+
+static int tcl_ignores(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_list *list;
+    Tcl_DString ds;
+    int flags;
+
+    BADARGS(1, 1, "");
+
+    Tcl_DStringInit(&ds);
+
+    list = xchat_list_get(ph, "ignore");
+
+    if (list != NULL) {
+
+        while (xchat_list_next(ph, list)) {
+            Tcl_DStringStartSublist(&ds);
+            Tcl_DStringAppendElement(&ds, (const char *) xchat_list_str(ph, list, "mask"));
+            Tcl_DStringStartSublist(&ds);
+            flags = xchat_list_int(ph, list, "flags");
+            if (flags & 1)
+                Tcl_DStringAppendElement(&ds, "PRIVMSG");
+            if (flags & 2)
+                Tcl_DStringAppendElement(&ds, "NOTICE");
+            if (flags & 4)
+                Tcl_DStringAppendElement(&ds, "CHANNEL");
+            if (flags & 8)
+                Tcl_DStringAppendElement(&ds, "CTCP");
+            if (flags & 16)
+                Tcl_DStringAppendElement(&ds, "INVITE");
+            if (flags & 32)
+                Tcl_DStringAppendElement(&ds, "UNIGNORE");
+            if (flags & 64)
+                Tcl_DStringAppendElement(&ds, "NOSAVE");
+            Tcl_DStringEndSublist(&ds);
+            Tcl_DStringEndSublist(&ds);
+        }
+        xchat_list_free(ph, list);
+    }
+
+    Tcl_AppendResult(irp, ds.string, NULL);
+
+    Tcl_DStringFree(&ds);
+
+    return TCL_OK;
+}
+
+static int tcl_dcclist(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_list *list;
+    Tcl_DString ds;
+    int dcctype;
+
+    BADARGS(1, 1, "");
+
+    Tcl_DStringInit(&ds);
+
+    list = xchat_list_get(ph, "dcc");
+
+    if (list != NULL) {
+
+        while (xchat_list_next(ph, list)) {
+            Tcl_DStringStartSublist(&ds);
+            dcctype = xchat_list_int(ph, list, "type");
+            switch (dcctype) {
+            case 0:
+                Tcl_DStringAppendElement(&ds, "filesend");
+                break;
+            case 1:
+                Tcl_DStringAppendElement(&ds, "filerecv");
+                break;
+            case 2:
+                Tcl_DStringAppendElement(&ds, "chatrecv");
+                break;
+            case 3:
+                Tcl_DStringAppendElement(&ds, "chatsend");
+                break;
+            }
+            switch (xchat_list_int(ph, list, "status")) {
+            case 0:
+                Tcl_DStringAppendElement(&ds, "queued");
+                break;
+            case 1:
+                Tcl_DStringAppendElement(&ds, "active");
+                break;
+            case 2:
+                Tcl_DStringAppendElement(&ds, "failed");
+                break;
+            case 3:
+                Tcl_DStringAppendElement(&ds, "done");
+                break;
+            case 4:
+                Tcl_DStringAppendElement(&ds, "connecting");
+                break;
+            case 5:
+                Tcl_DStringAppendElement(&ds, "aborted");
+                break;
+            }
+
+            Tcl_DStringAppendElement(&ds, (const char *) xchat_list_str(ph, list, "nick"));
+
+            switch (dcctype) {
+            case 0:
+                Tcl_DStringAppendElement(&ds, (const char *) xchat_list_str(ph, list, "file"));
+                break;
+            case 1:
+                Tcl_DStringAppendElement(&ds, (const char *) xchat_list_str(ph, list, "destfile"));
+                break;
+            }
+
+            Tcl_DStringAppendElement(&ds, myitoa((long)xchat_list_int(ph, list, "size")));
+            Tcl_DStringAppendElement(&ds, myitoa((long)xchat_list_int(ph, list, "resume")));
+            Tcl_DStringAppendElement(&ds, myitoa((long)xchat_list_int(ph, list, "pos")));
+            Tcl_DStringAppendElement(&ds, myitoa((long)xchat_list_int(ph, list, "cps")));
+            Tcl_DStringAppendElement(&ds, myitoa((long)xchat_list_int(ph, list, "address32")));
+            Tcl_DStringAppendElement(&ds, myitoa((long)xchat_list_int(ph, list, "port")));
+            Tcl_DStringEndSublist(&ds);
+        }
+        xchat_list_free(ph, list);
+    }
+
+    Tcl_AppendResult(irp, ds.string, NULL);
+
+    Tcl_DStringFree(&ds);
+
+    return TCL_OK;
+}
+
+
+static int tcl_strip(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    char *new_text;
+    int flags = 1 | 2;
+
+    BADARGS(2, 3, " text ?flags?");
+
+    if (argc == 3) {
+        if (Tcl_GetInt(irp, argv[2], &flags) != TCL_OK)
+            return TCL_ERROR;
+    }
+
+    new_text = xchat_strip(ph, argv[1], -1, flags);
+
+    if(new_text) {
+        Tcl_AppendResult(irp, new_text, NULL);
+        xchat_free(ph, new_text);
+    }
+
+    return TCL_OK;
+}
+
+static int tcl_topic(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    xchat_context *origctx, *ctx = NULL;
+    BADARGS(1, 3, " ?server|network|context? ?channel?");
+
+    origctx = xchat_get_context(ph);
+
+    switch (argc) {
+    case 1:
+        ctx = origctx;
+        break;
+    case 2:
+        ctx = xchat_smart_context(argv[1], NULL);
+        break;
+    case 3:
+        ctx = xchat_smart_context(argv[1], argv[2]);
+        break;
+    default:;
+    }
+
+    CHECKCTX(ctx);
+
+    xchat_set_context(ph, ctx);
+    Tcl_AppendResult(irp, xchat_get_info(ph, "topic"), NULL);
+    xchat_set_context(ph, origctx);
+
+    return TCL_OK;
+}
+
+static int tcl_xchat_nickcmp(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    BADARGS(3, 3, " string1 string2");
+    Tcl_AppendResult(irp, myitoa((long)xchat_nickcmp(ph, argv[1], argv[2])), NULL);
+    return TCL_OK;
+}
+
+static int tcl_word(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    int index;
+
+    BADARGS(2, 2, " index");
+
+    if (Tcl_GetInt(irp, argv[1], &index) != TCL_OK)
+        return TCL_ERROR;
+
+    if (!index || (index > 31))
+        Tcl_AppendResult(interp, "", NULL);
+    else
+        Tcl_AppendResult(interp, complete[complete_level].word[index], NULL);
+
+    return TCL_OK;
+}
+
+static int tcl_word_eol(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[])
+{
+    int index;
+
+    BADARGS(2, 2, " index");
+
+    if (Tcl_GetInt(irp, argv[1], &index) != TCL_OK)
+        return TCL_ERROR;
+
+    if (!index || (index > 31))
+        Tcl_AppendResult(interp, "", NULL);
+    else
+        Tcl_AppendResult(interp, complete[complete_level].word_eol[index], NULL);
+
+    return TCL_OK;
+}
+
+static int Command_Alias(char *word[], char *word_eol[], void *userdata)
+{
+    alias *aliasPtr;
+    Tcl_HashEntry *entry;
+    xchat_context *origctx;
+    int dummy;
+    char *string;
+
+    if (complete_level == MAX_COMPLETES)
+        return XCHAT_EAT_NONE;
+
+    complete_level++;
+    complete[complete_level].defresult = XCHAT_EAT_ALL;
+    complete[complete_level].result = XCHAT_EAT_NONE;
+    complete[complete_level].word = word;
+	complete[complete_level].word_eol = word_eol;
+
+    string = StrDup(word[1], &dummy);
+
+    Tcl_UtfToUpper(string);
+
+    if ((entry = Tcl_FindHashEntry(&aliasTablePtr, string)) != NULL) {
+        aliasPtr = Tcl_GetHashValue(entry);
+        origctx = xchat_get_context(ph);
+        if (EvalInternalProc(aliasPtr->procPtr, 2, string, word_eol[2]) == TCL_ERROR) {
+            xchat_printf(ph, "\0039Tcl plugin\003\tERROR (alias %s) ", string);
+            NiceErrorInfo ();
+        }
+        xchat_set_context(ph, origctx);
+    }
+
+    Tcl_Free(string);
+
+    return complete[complete_level--].result;
+}
+
+static int Null_Command_Alias(char *word[], char *word_eol[], void *userdata)
+{
+    alias *aliasPtr;
+    Tcl_HashEntry *entry;
+    xchat_context *origctx;
+    int dummy;
+    const char *channel;
+    char *string;
+    Tcl_DString ds;
+    static int recurse = 0;
+
+    if (recurse)
+        return XCHAT_EAT_NONE;
+
+    if (complete_level == MAX_COMPLETES)
+        return XCHAT_EAT_NONE;
+
+    complete_level++;
+    complete[complete_level].defresult = XCHAT_EAT_ALL;
+    complete[complete_level].result = XCHAT_EAT_NONE;
+    complete[complete_level].word = word;
+	complete[complete_level].word_eol = word_eol;
+
+    recurse++;
+
+    channel = xchat_get_info(ph, "channel");
+    Tcl_DStringInit(&ds);
+    Tcl_DStringAppend(&ds, "@", 1);
+    Tcl_DStringAppend(&ds, channel, strlen(channel));
+    string = StrDup(ds.string, &dummy);
+    Tcl_DStringFree(&ds);
+
+    Tcl_UtfToUpper(string);
+
+    if ((entry = Tcl_FindHashEntry(&aliasTablePtr, string)) != NULL) {
+        aliasPtr = Tcl_GetHashValue(entry);
+        origctx = xchat_get_context(ph);
+        if (EvalInternalProc(aliasPtr->procPtr, 2, string, word_eol[1]) == TCL_ERROR) {
+            xchat_printf(ph, "\0039Tcl plugin\003\tERROR (alias %s) ", string);
+            NiceErrorInfo ();
+        }
+        xchat_set_context(ph, origctx);
+    }
+
+    Tcl_Free(string);
+
+    recurse--;
+
+    return complete[complete_level--].result;
+}
+
+static int Command_TCL(char *word[], char *word_eol[], void *userdata)
+{
+    const char *errorInfo;
+
+    complete_level++;
+    complete[complete_level].word = word;
+    complete[complete_level].word_eol = word_eol;
+
+    if (Tcl_Eval(interp, word_eol[2]) == TCL_ERROR) {
+        errorInfo = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
+        xchat_printf(ph, "\0039Tcl plugin\003\tERROR: %s ", errorInfo);
+    } else
+        xchat_printf(ph, "\0039Tcl plugin\003\tRESULT: %s ", Tcl_GetStringResult(interp));
+
+    complete_level--;
+
+    return XCHAT_EAT_ALL;
+}
+
+static int Command_Source(char *word[], char *word_eol[], void *userdata)
+{
+    const char *xchatdir;
+    Tcl_DString ds;
+    struct stat dummy;
+    int len;
+    const char *errorInfo;
+
+    if (!strlen(word_eol[2]))
+        return XCHAT_EAT_NONE;
+
+    complete_level++;
+    complete[complete_level].word = word;
+    complete[complete_level].word_eol = word_eol;
+
+    len = strlen(word[2]);
+
+    if (len > 4 && strcasecmp(".tcl", word[2] + len - 4) == 0) {
+
+        xchatdir = xchat_get_info(ph, "xchatdir");
+
+        Tcl_DStringInit(&ds);
+
+        if (stat(word_eol[2], &dummy) == 0) {
+            Tcl_DStringAppend(&ds, word_eol[2], strlen(word_eol[2]));
+        } else {
+            if (!strchr(word_eol[2], '/')) {
+                Tcl_DStringAppend(&ds, xchatdir, strlen(xchatdir));
+                Tcl_DStringAppend(&ds, "/", 1);
+                Tcl_DStringAppend(&ds, word_eol[2], strlen(word_eol[2]));
+            }
+        }
+
+        if (Tcl_EvalFile(interp, ds.string) == TCL_ERROR) {
+            errorInfo = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
+            xchat_printf(ph, "\0039Tcl plugin\003\tERROR: %s ", errorInfo);
+        } else
+            xchat_printf(ph, "\0039Tcl plugin\003\tSourced %s\n", ds.string);
+
+        Tcl_DStringFree(&ds);
+
+        complete_level--;
+
+        return XCHAT_EAT_XCHAT;
+
+    } else {
+        complete_level--;
+        return XCHAT_EAT_NONE;
+    }
+
+}
+
+static int Command_Reloadall(char *word[], char *word_eol[], void *userdata)
+{
+    Tcl_Plugin_DeInit();
+    Tcl_Plugin_Init();
+
+    xchat_print(ph, "\0039Tcl plugin\003\tRehashed\n");
+
+    return XCHAT_EAT_ALL;
+}
+
+static int TCL_Event_Handler(void *userdata)
+{
+    Tcl_DoOneEvent(TCL_DONT_WAIT);
+    do_timer();
+    return 1;
+}
+
+static void Tcl_Plugin_Init()
+{
+    int x;
+    const char *xchatdir;
+
+    interp = Tcl_CreateInterp();
+
+    Tcl_FindExecutable(NULL);
+
+    Tcl_Init(interp);
+
+    nextprocid = 0x1000;
+
+    Tcl_CreateCommand(interp, "alias", tcl_alias, NULL, NULL);
+    Tcl_CreateCommand(interp, "channels", tcl_channels, NULL, NULL);
+    Tcl_CreateCommand(interp, "chats", tcl_chats, NULL, NULL);
+    Tcl_CreateCommand(interp, "command", tcl_command, NULL, NULL);
+    Tcl_CreateCommand(interp, "complete", tcl_complete, NULL, NULL);
+    Tcl_CreateCommand(interp, "dcclist", tcl_dcclist, NULL, NULL);
+    Tcl_CreateCommand(interp, "notifylist", tcl_notifylist, NULL, NULL);
+    Tcl_CreateCommand(interp, "findcontext", tcl_findcontext, NULL, NULL);
+    Tcl_CreateCommand(interp, "getcontext", tcl_getcontext, NULL, NULL);
+    Tcl_CreateCommand(interp, "getinfo", tcl_getinfo, NULL, NULL);
+    Tcl_CreateCommand(interp, "getlist", tcl_getlist, NULL, NULL);
+    Tcl_CreateCommand(interp, "ignores", tcl_ignores, NULL, NULL);
+    Tcl_CreateCommand(interp, "killtimer", tcl_killtimer, NULL, NULL);
+    Tcl_CreateCommand(interp, "me", tcl_me, NULL, NULL);
+    Tcl_CreateCommand(interp, "on", tcl_on, NULL, NULL);
+    Tcl_CreateCommand(interp, "off", tcl_off, NULL, NULL);
+    Tcl_CreateCommand(interp, "nickcmp", tcl_xchat_nickcmp, NULL, NULL);
+    Tcl_CreateCommand(interp, "print", tcl_print, NULL, NULL);
+    Tcl_CreateCommand(interp, "prefs", tcl_prefs, NULL, NULL);
+    Tcl_CreateCommand(interp, "::puts", tcl_xchat_puts, NULL, NULL);
+    Tcl_CreateCommand(interp, "queries", tcl_queries, NULL, NULL);
+    Tcl_CreateCommand(interp, "raw", tcl_raw, NULL, NULL);
+    Tcl_CreateCommand(interp, "servers", tcl_servers, NULL, NULL);
+    Tcl_CreateCommand(interp, "setcontext", tcl_setcontext, NULL, NULL);
+    Tcl_CreateCommand(interp, "strip", tcl_strip, NULL, NULL);
+    Tcl_CreateCommand(interp, "timer", tcl_timer, NULL, NULL);
+    Tcl_CreateCommand(interp, "timerexists", tcl_timerexists, NULL, NULL);
+    Tcl_CreateCommand(interp, "timers", tcl_timers, NULL, NULL);
+    Tcl_CreateCommand(interp, "topic", tcl_topic, NULL, NULL);
+    Tcl_CreateCommand(interp, "users", tcl_users, NULL, NULL);
+    Tcl_CreateCommand(interp, "word", tcl_word, NULL, NULL);
+    Tcl_CreateCommand(interp, "word_eol", tcl_word_eol, NULL, NULL);
+
+    Tcl_InitHashTable(&cmdTablePtr, TCL_STRING_KEYS);
+    Tcl_InitHashTable(&aliasTablePtr, TCL_STRING_KEYS);
+
+    bzero(timers, sizeof(timers));
+    nexttimerid = 0;
+    nexttimerindex = 0;
+
+    for (x = 0; x < XC_SIZE; x++)
+        xc[x].hook = NULL;
+
+    xchatdir = xchat_get_info(ph, "xchatdir");
+
+    if (Tcl_Eval(interp, unknown) == TCL_ERROR) {
+        xchat_printf(ph, "Error sourcing internal 'unknown' (%s)\n", Tcl_GetStringResult(interp));
+    }
+
+    if (Tcl_Eval(interp, inlinetcl) == TCL_ERROR) {
+        xchat_printf(ph, "Error sourcing internal 'inlinetcl' (%s)\n", Tcl_GetStringResult(interp));
+    }
+
+    if (Tcl_Eval(interp, sourcedirs) == TCL_ERROR) {
+        xchat_printf(ph, "Error sourcing internal 'sourcedirs' (%s)\n", Tcl_GetStringResult(interp));
+    }
+
+}
+
+static void Tcl_Plugin_DeInit()
+{
+    int x;
+    char *procPtr;
+    alias *aliasPtr;
+    Tcl_HashEntry *entry;
+    Tcl_HashSearch search;
+
+    /* Be sure to free all the memory for ON and ALIAS entries */
+
+    entry = Tcl_FirstHashEntry(&cmdTablePtr, &search);
+    while (entry != NULL) {
+        procPtr = Tcl_GetHashValue(entry);
+        Tcl_Free(procPtr);
+        entry = Tcl_NextHashEntry(&search);
+    }
+
+    Tcl_DeleteHashTable(&cmdTablePtr);
+
+    entry = Tcl_FirstHashEntry(&aliasTablePtr, &search);
+    while (entry != NULL) {
+        aliasPtr = Tcl_GetHashValue(entry);
+        Tcl_Free(aliasPtr->procPtr);
+        if (aliasPtr->hook)
+            xchat_unhook(ph, aliasPtr->hook);
+        Tcl_Free((char *) aliasPtr);
+        entry = Tcl_NextHashEntry(&search);
+    }
+
+    Tcl_DeleteHashTable(&aliasTablePtr);
+
+    for (x = 1; x < MAX_TIMERS; x++) {
+        if (timers[x].timerid) {
+            timers[x].timerid = 0;
+            if (timers[x].procPtr != NULL)
+                Tcl_Free(timers[x].procPtr);
+            timers[x].procPtr = NULL;
+            break;
+        }
+    }
+
+    for (x = 0; x < XC_SIZE; x++) {
+        if (xc[x].hook != NULL) {
+            xchat_unhook(ph, xc[x].hook);
+            xc[x].hook = NULL;
+        }
+    }
+
+    Tcl_DeleteInterp(interp);
+}
+
+static void banner()
+{
+    xchat_printf(ph, "Tcl plugin for XChat - Version %s\n", VERSION);
+    xchat_print(ph, "Copyright 2002-2005 Daniel P. Stasinski\n");
+    xchat_print(ph, "http://www.scriptkitties.com/tclplugin/\n");
+}
+
+int xchat_plugin_init(xchat_plugin * plugin_handle, char **plugin_name, char **plugin_desc, char **plugin_version, char *arg)
+{
+#ifdef WIN32
+    HINSTANCE lib;
+#endif
+
+    strncpy(VERSION, &RCSID[19], 5);
+
+    ph = plugin_handle;
+
+#ifdef WIN32
+    lib = LoadLibraryA(TCL_DLL);
+    if (!lib) {
+        xchat_print(ph, "You must have ActiveTCL installed in order to run Tcl scripts.\n" "http://aspn.activestate.com/ASPN/Tcl/\n" "Make sure Tcl's bin directory is in your PATH.\n\n");
+        return 0;
+    }
+    FreeLibrary(lib);
+#endif
+
+    if (initialized != 0) {
+        banner();
+        xchat_print(ph, "Tcl plugin already loaded");
+        reinit_tried++;
+        return 0;
+    }
+    initialized = 1;
+
+    *plugin_name = "Tcl";
+    *plugin_desc = "Tcl scripting interface";
+    *plugin_version = VERSION;
+
+    Tcl_Plugin_Init();
+
+    raw_line_hook = xchat_hook_server(ph, "RAW LINE", XCHAT_PRI_NORM, Server_raw_line, NULL);
+    Command_TCL_hook = xchat_hook_command(ph, "tcl", XCHAT_PRI_NORM, Command_TCL, 0, 0);
+    Command_Source_hook = xchat_hook_command(ph, "source", XCHAT_PRI_NORM, Command_Source, 0, 0);
+    Command_Reload_hook = xchat_hook_command(ph, "reloadall", XCHAT_PRI_NORM, Command_Reloadall, 0, 0);
+    Command_Load_hook = xchat_hook_command(ph, "LOAD", XCHAT_PRI_NORM, Command_Source, 0, 0);
+    Event_Handler_hook = xchat_hook_timer(ph, 100, TCL_Event_Handler, 0);
+    Null_Command_hook = xchat_hook_command(ph, "", XCHAT_PRI_NORM, Null_Command_Alias, "", 0);
+
+    banner();
+    xchat_print(ph, "Tcl interface loaded\n");
+
+    return 1;                   /* return 1 for success */
+}
+
+int xchat_plugin_deinit()
+{
+    if (reinit_tried) {
+        reinit_tried--;
+        return 1;
+    }
+
+    xchat_unhook(ph, raw_line_hook);
+    xchat_unhook(ph, Command_TCL_hook);
+    xchat_unhook(ph, Command_Source_hook);
+    xchat_unhook(ph, Command_Reload_hook);
+    xchat_unhook(ph, Command_Load_hook);
+    xchat_unhook(ph, Event_Handler_hook);
+    xchat_unhook(ph, Null_Command_hook);
+
+    Tcl_Plugin_DeInit();
+
+    xchat_print(ph, "Tcl interface unloaded\n");
+    initialized = 0;
+
+    return 1;
+}
+
+void xchat_plugin_get_info(char **name, char **desc, char **version, void **reserved)
+{
+   strncpy(VERSION, &RCSID[19], 5);
+   *name = "tclplugin";
+   *desc = "Tcl plugin for XChat";
+   *version = VERSION;
+   if (reserved)
+      *reserved = NULL;
+}
+
diff --git a/plugins/tcl/tclplugin.h b/plugins/tcl/tclplugin.h
new file mode 100644
index 00000000..075c28f8
--- /dev/null
+++ b/plugins/tcl/tclplugin.h
@@ -0,0 +1,98 @@
+/***************************************************************************
+                           tclplugin.h  -  TCL plugin header file
+                           -------------------------------------------------
+    begin                : Sat Nov  9 17:31:20 MST 2002
+    copyright            : Copyright 2002-2010 Daniel P. Stasinski
+    email                : daniel@avenues.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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#define BADARGS(nl,nh,example) \
+    if ((argc<(nl)) || (argc>(nh))) { \
+    Tcl_AppendResult(irp,"wrong # args: should be \"",argv[0], \
+        (example),"\"",NULL); \
+        return TCL_ERROR; \
+    }
+
+#define CHECKCTX(ctx) \
+    if (ctx == NULL) { \
+        Tcl_AppendResult(irp, "No such server/channel/nick", NULL); \
+        return TCL_ERROR; \
+    }
+
+typedef struct {
+    char *procPtr;
+    xchat_hook *hook;
+} alias;
+
+typedef struct {
+    int timerid;
+    time_t timestamp;
+    char *procPtr;
+    int count;
+    int seconds;
+} timer;
+
+typedef struct {
+    int result;
+    int defresult;
+    char **word;
+    char **word_eol;
+} t_complete;
+
+#define MAX_TIMERS 512
+#define MAX_COMPLETES 128
+
+static char *StrDup(const char *string, int *length);
+static char *myitoa(long value);
+static xchat_context *xchat_smart_context(const char *arg1, const char *arg2);
+static void queue_nexttimer();
+static int insert_timer(int seconds, int count, const char *script);
+static void do_timer();
+static int Server_raw_line(char *word[], char *word_eol[], void *userdata);
+static int Print_Hook(char *word[], void *userdata);
+static int tcl_timerexists(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_killtimer(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_timers(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_timer(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_on(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_off(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_alias(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_complete(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_raw(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_command(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_xchat_puts(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_print(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_channels(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_servers(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_queries(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_users(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_chats(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_ignores(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_dcclist(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_me(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_xchat_nickcmp(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_strip(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_topic(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_word(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_word_eol(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int tcl_notifylist(ClientData cd, Tcl_Interp * irp, int argc, const char *argv[]);
+static int Command_Alias(char *word[], char *word_eol[], void *userdata);
+static int Null_Command_Alias(char *word[], char *word_eol[], void *userdata);
+static int Command_TCL(char *word[], char *word_eol[], void *userdata);
+static int Command_Source(char *word[], char *word_eol[], void *userdata);
+static int Command_Reload(char *word[], char *word_eol[], void *userdata);
+static int TCL_Event_Handler(void *userdata);
+static void Tcl_Plugin_Init();
+static void Tcl_Plugin_DeInit();
+static void banner();
+int xchat_plugin_init(xchat_plugin * plugin_handle, char **plugin_name, char **plugin_desc, char **plugin_version, char *arg);
+int xchat_plugin_deinit();