add patch from Jose Quinteiro to send whole lines to embedded interpreter (bug #196216)

(Portage version: 2.1.3.9)

3 files changed, 664 insertions, 4 deletions

diff --git a/games-mud/mcl/ChangeLog b/games-mud/mcl/ChangeLog
index 7d89f91f99b2..4a247d5f337a 100644
--- a/games-mud/mcl/ChangeLog
+++ b/games-mud/mcl/ChangeLog
@@ -1,6 +1,11 @@
 # ChangeLog for games-mud/mcl
-# Copyright 2002-2006 Gentoo Foundation; Distributed under the GPL v2
-# $Header: /var/cvsroot/gentoo-x86/games-mud/mcl/ChangeLog,v 1.15 2006/11/28 20:29:04 nyhm Exp $
+# Copyright 2002-2007 Gentoo Foundation; Distributed under the GPL v2
+# $Header: /var/cvsroot/gentoo-x86/games-mud/mcl/ChangeLog,v 1.16 2007/10/21 05:54:09 mr_bones_ Exp $
+
+  21 Oct 2007; Michael Sterrett <mr_bones_@gentoo.org>
+  +files/mcl-0.53.00-inputlines.patch, mcl-0.53.00.ebuild:
+  add patch from Jose Quinteiro to send whole lines to embedded interpreter (bug
+  #196216)
 
   28 Nov 2006; Tristan Heaven <nyhm@gentoo.org>
   +files/mcl-0.53.00-libdir.patch, mcl-0.53.00.ebuild:
diff --git a/games-mud/mcl/files/mcl-0.53.00-inputlines.patch b/games-mud/mcl/files/mcl-0.53.00-inputlines.patch
new file mode 100644
index 000000000000..37d1fc64c68c
--- /dev/null
+++ b/games-mud/mcl/files/mcl-0.53.00-inputlines.patch
@@ -0,0 +1,648 @@
+Patch from Jose Quinteiro
+via http://bugs.gentoo.org/show_bug.cgi?id=196216
+
+Index: StatusLine.cc
+===================================================================
+--- StatusLine.cc (revision 1)
++++ StatusLine.cc (revision 3)
+@@ -27,5 +27,5 @@
+ 
+ // Set the status line (using a formatted string)
+-void StatusLine::setf(const char *fmt ...)
++void StatusLine::setf(const char *fmt, ...)
+ {
+ 	char buf[256];
+Index: misc.cc
+===================================================================
+--- misc.cc (revision 1)
++++ misc.cc (revision 3)
+@@ -135,5 +135,4 @@
+ }
+ 
+-#define MAX_COLOR_BUF 256
+ int ColorConverter::convert (const unsigned char *s, int size) {
+ 	char    buf[MAX_COLOR_BUF];
+Index: Session.cc
+===================================================================
+--- Session.cc (revision 1)
++++ Session.cc (revision 3)
+@@ -18,4 +18,5 @@
+ #include "Curses.h"
+ #include "Chat.h"
++#include "StatusLine.h"
+ 
+ const int connectTimeout = 30;
+@@ -235,9 +236,12 @@
+ }
+ 
+-Session::Session(MUD& _mud, Window *_window, int _fd) : Socket(_fd), state(disconnected),mud(_mud), window(_window), pos(0),
+-nsw(NULL), timer(NULL),  statWindow(NULL), last_nsw_update(0)
++Session::Session(MUD& _mud, Window *_window, int _fd) : Socket(_fd), state(disconnected),mud(_mud),
++    window(_window), nsw(NULL), timer(NULL),  statWindow(NULL), last_nsw_update(0), m_input_state(text)
+ {
+-	input_buffer[0] = NUL;
+-	prompt[0] = NUL;
++	m_ansi_buf[0] = NUL;
++	m_ansi_pos = m_ansi_buf;
++	m_output_buf[0] = NUL;
++	m_output_pos = m_output_buf;
++	m_last_line = m_output_buf;
+ 	memset(&stats,0,sizeof(stats));
+ 
+@@ -391,21 +395,17 @@
+ 
+ // Data from the MUD has arrived
+-void Session::inputReady() {
+-    char    out_buf[MAX_MUD_BUF];
+-    char    temp_buf[MAX_MUD_BUF];
+-    char   *out;
+-    int     code_pos;
+-    char   *prompt_begin;
+-    
+-    int     count;
+-    int     i;
+-
+-    count = read(temp_buf, MAX_MUD_BUF-1);
+-
+-    globalStats.bytes_read += count;
+-    stats.bytes_read += count;
++void Session::inputReady()
++{
++    unsigned char    l_cur_buf[MAX_MUD_BUF];
++    char    l_temp_buf[MAX_MUD_BUF];
++    int     l_count;
++
++    l_count = read(l_temp_buf, MAX_MUD_BUF-1);
++
++    globalStats.bytes_read += l_count;
++    stats.bytes_read += l_count;
+     
+     // Filter through mudcompress
+-    mudcompress_receive(mcinfo, temp_buf, count);
++    mudcompress_receive(mcinfo, l_temp_buf, l_count);
+     
+     // Error?
+@@ -423,186 +423,204 @@
+     }
+     
+-    while (mudcompress_pending(mcinfo) && pos < MAX_MUD_BUF-1) {
++    while (mudcompress_pending(mcinfo))
++    {
+         // Get some data
+-        count = mudcompress_get(mcinfo, (char*) input_buffer + pos, MAX_MUD_BUF - pos - 1);
+-
+-        if (count > 0 && chatServerSocket)
+-            chatServerSocket->handleSnooping((char*)(input_buffer+pos), count);
+-
+-        prompt_begin = NULL;
+-        out = out_buf;
+-        
+-        /* If we have data from last call, this means we got some incomplete ansi */
+-        if (pos)
+-            code_pos = 0;
+-        else
+-            code_pos = -1;
+-        
+-        /* Process the buffer */
+-        for (i = 0; i < count + pos; i++)
+-        {
+-            /* Lose patience of code does not terminate within 16 characters */
+-            if (code_pos >= 0 && i - code_pos > 16)
+-                code_pos = -1;
+-            
+-            
+-            /* IAC: next character is a telnet command */
+-            if (input_buffer[i] == IAC)
+-            {
+-                if (++i < count + pos)	/* just forget it if it appears at the end of a buffer */
+-                {
+-                    /* spec: handle prompts that split across reads */
+-                    if (input_buffer[i] == GA || input_buffer[i] == EOR) /* this is a prompt */
+-                    {
+-                        /* if we have a prompt_begin, that's the start of
+-                         * the prompt. If we don't, then the contents
+-                         * of the 'prompt' buffer, plus any output we
+-                         * have, is the prompt.
+-                         */
+-                        if(!config->getOption(opt_snarf_prompt)) {
+-                            if(prompt_begin) {
+-                                int len = out - prompt_begin;
+-                                char *buf = new char[len + 1];
+-                                memcpy(buf, prompt_begin+1, len);
+-                                buf[len] = '\0';
+-                                embed_interp->run_quietly("sys/prompt", buf, buf);
+-                            }
++        l_count = mudcompress_get(mcinfo, (char*) l_cur_buf, MAX_MUD_BUF - 1);
++
++        if (l_count > 0 && chatServerSocket)
++            chatServerSocket->handleSnooping((char*)(l_cur_buf), l_count);
++
++	for(int i = 0; i < l_count; i++)
++	{
++	    if( (m_output_pos - m_output_buf) == MAX_MUD_BUF ) {
++		//We've buffered as much as we can, let's write it out
++		//TODO: Trigger scripts here? Looks like a corner case
++		//log.warn("Buffer exhausted, flushing\n");
++		*m_output_pos = NUL;
++		print( m_output_buf );
++		m_output_pos = m_output_buf;
++		m_last_line = m_output_buf;
++	    }
++	    if( (m_ansi_pos - m_ansi_buf) == MAX_COLOR_BUF ) {
++		*m_ansi_pos = NUL;
++		//log.warn("ANSI sequence %s too long, ignoring\n", m_ansi_buf);
++		m_ansi_pos = m_ansi_buf;
++	    }
++
++	    switch(m_input_state)
++	    {
++	    case text:
++		if( l_cur_buf[i] == IAC ) {
++		    m_state_stack.push_back(m_input_state);
++		    m_input_state = found_iac;
++		    continue;
++		}
++		if( l_cur_buf[i] == '\e' ) {
++		    m_state_stack.push_back(m_input_state);
++		    m_input_state = found_esc;
++		    continue;
++		}
++		if (l_cur_buf[i] == '\a' && config->getOption(opt_mudbeep)) {
++		    ::write(STDOUT_FILENO, "\a", 1); // use screen->flash() here?
++		    continue;
++		}
++		if (l_cur_buf[i] == '\r') {
++		    //log.debug("Discarded carriage return");
++		    continue;
++		}
++		if (l_cur_buf[i] == '\n') 
++		{
++		    triggerCheck(m_last_line, m_output_pos - m_last_line, &m_output_pos);
++		    m_last_line = m_output_pos + 1;
++                }
++
++		*m_output_pos++ = l_cur_buf[i];
++		continue;
++
++	    case found_iac:
++		if( l_cur_buf[i] >= WILL  && l_cur_buf[i] <= DONT ) {
++		    m_input_state = telnet_option;
++		    continue;
++		}
++		if( l_cur_buf[i] == EOR || l_cur_buf[i] == GA )
++		{
++		    *m_output_pos = NUL;
++		    if( config->getOption(opt_snarf_prompt) ) {
++			set_prompt( m_last_line, (int)strlen(m_last_line) );
++		    } else {
++			embed_interp->run_quietly("sys/prompt", m_last_line, m_last_line);
++		    }
++
++		    if( config->getOption(opt_showprompt) ) {
++			*m_output_pos++ = '\n';
++			*m_output_pos = NUL;
++			print( m_output_buf );
++		    } else {
++			*m_last_line = NUL;
++			print( m_output_buf );
++		    }
++         	    m_output_pos = m_output_buf;
++		    m_last_line = m_output_buf;
++		    m_input_state = m_state_stack.back();
++		    m_state_stack.pop_back();
++		    continue;
++		}
++		//log.warn("Ignoring telnet command %d\n", l_cur_buf[i]);
++		m_input_state = m_state_stack.back();
++		m_state_stack.pop_back();
++		continue;
++
++	    case telnet_option:
++		if( l_cur_buf[i] == TELOPT_EOR) {
++		    //TODO: use telnet.h defines here
++		    write ("\377\375\31", 3);
++		} else {
++		    //log.warn("Ignoring telnet option %c\n", l_cur_buf[i]);
++		}
++                m_input_state = m_state_stack.back();
++		m_state_stack.pop_back();
++		continue;
++
++	    case found_esc:
++		if( l_cur_buf[i] == IAC ) {
++		    m_state_stack.push_back(m_input_state);
++		    m_input_state = found_iac;
++		    continue;
++		}
++		if( l_cur_buf[i] ='[' ) {
++		    if( m_ansi_pos != m_ansi_buf ) {
++			//log.warn("New ANSI escape sequence started before the last one was finished");
++			m_ansi_pos = m_ansi_buf;
++		    }
++		    *m_ansi_pos++ = '\e';
++		    *m_ansi_pos++ = l_cur_buf[i];
++		    m_input_state = ansi_sequence;
++		    continue;
++		}
++		//log.warn("Ignoring escape sequence ESC%c\n", l_cur_buf[i]);
++		m_input_state = m_state_stack.back();
++		m_state_stack.pop_back();
++		continue;
++
++	    case ansi_sequence:
++                if( l_cur_buf[i] == IAC ) {
++		    m_state_stack.push_back(m_input_state);
++		    m_input_state = found_iac;
++		    continue;
++		}
++		if( isdigit(l_cur_buf[i]) || l_cur_buf[i] == ';' ){
++		    *m_ansi_pos++ = l_cur_buf[i];
++		    continue;
++		}
++		if(l_cur_buf[i] == '"') {
++		    *m_ansi_pos++ = l_cur_buf[i];
++		    m_state_stack.push_back(m_input_state);
++		    m_input_state = ansi_found_quot;
++		    continue;
++		}
++		if( isalpha(l_cur_buf[i]) )
++		{
++		    if( l_cur_buf[i] == 'm' || l_cur_buf[i] == 'R' )
++		    {
++                        /* Conver this color code to internal representation */
++			int l_color;
++                        if( (l_color = m_colorConverter.convert((const byte*)m_ansi_buf, m_ansi_pos - m_ansi_buf)) > 0 )
++                        {
++                            *m_output_pos++ = SET_COLOR;
++                            *m_output_pos++ = l_color;
+                         }
+-                        else if (prompt_begin)
+-                        {
+-                            set_prompt (prompt_begin + 1, out - prompt_begin - 1);
+-                            if (!config->getOption(opt_showprompt))
+-                                out = prompt_begin + 1;
++                        if (m_colorConverter.checkReportStatus()) { /* suggested by Chris Litchfield */
++                            output->printf("\n(Sending location code\n");
++                            writeMUD("\e[40;13R\n");
+                         }
+-                        else
+-                        {
+-                            if (prompt[0] || out[0])
+-                            {
+-                                unsigned char   *temp = prompt + strlen ((char*)prompt);
+-                                
+-                                *out = NUL;
+-                                strcat ((char*)prompt, out_buf);
+-                                set_prompt ((char*)prompt, (int)strlen ((char*)prompt));
+-                                *temp = NUL;
+-                            }
+-                            if (!config->getOption(opt_showprompt))
+-                                out = out_buf;
+-                        }
+-                        // Insert a clear color code here
+-                        // It'd be better to interpret color codes in the prompt properly,
+-                        // but that is surprisingly hard to do
+-                        *out++ = SET_COLOR;
+-                        *out++ = bg_black|fg_white; // Is that really the *default* color?
+-                        
+-                        prompt[0] = NUL;
+-                        prompt_begin = out;
+-                    }
+-                    // React to IAC WILL EOR and send back IAC DO EOR
+-                    else if (input_buffer[i] == WILL && (i+1) < count+pos && input_buffer[i+1] == TELOPT_EOR)
+-                    {
+-                        i++;
+-                        
+-                        // @@ use telnet.h defines here
+-                        write ("\377\375\31", 3);
+-                    }
+-                    /* Skip the next character if this is an option */
+-                    else if (input_buffer[i] >= WILL && input_buffer[i] <= DONT)
+-                        i++;
+-                }
+-                
++		    } else {
++                        *m_ansi_pos = NUL;
++                        //log.warn("Ignoring ANSI sequence %s%c\n", m_ansi_buf, l_cur_buf[i]);
++		    }
++		    m_ansi_pos = m_ansi_buf;
++		    m_input_state = m_state_stack.back();
++		    m_state_stack.pop_back();
++                    continue;
++		}
++                *m_ansi_pos = NUL;
++		//log.warn("Ignoring ANSI sequence %s%c\n", m_ansi_buf, l_cur_buf[i]);
++                m_ansi_pos = m_ansi_buf;
++                m_input_state = m_state_stack.back();
++                m_state_stack.pop_back();
+                 continue;
+-            }
+-            
+-            // Escape sequence
+-            else if (input_buffer[i] == '\e')		
+-                code_pos = i;
+-            
+-            // Attention
+-            else if (input_buffer[i] == '\a' && config->getOption(opt_mudbeep))
+-                ::write(STDOUT_FILENO, "\a", 1); // use screen->flash() here?
+-            
+-            else if (code_pos == -1) { // not inside a color code, real text
+-                if (input_buffer[i] == '\n')  {
+-                    // Do regexp trigger magic
+-                    bool cancel_line = triggerCheck(prompt_begin ? prompt_begin+1 : (char*) out_buf,
+-                                                    prompt_begin ? out-prompt_begin-1: out-out_buf, &out);
+-                    prompt_begin = out;
+-                    if (cancel_line) {
+-                        // We just gagged that line, so the \n which otherwise would be the beginning of the prompt
+-                        // is eaten up.
+-                        if (out > out_buf)
+-                            prompt_begin = out-1;
+-                        else
+-                            prompt_begin = NULL;
+-                        continue;
+-                    }
+-                }
+-                
+-                if (input_buffer[i] != '\r')	/* discard those */
+-                    *out++ = input_buffer[i];	/* Add to output buffer */
+-            }
+-            
+-            /* Check if the code should terminate here */
+-            if (code_pos >= 0 && isalpha (input_buffer[i]))
+-            {
+-                int     color;
+-                
+-                /* Conver this color code to internal representation */
+-                if ((color = colorConverter.convert (input_buffer + code_pos, i - code_pos + 1)) > 0)
+-                {
+-                    *out++ = SET_COLOR;
+-                    *out++ = color;
+-                }
+-                if (colorConverter.checkReportStatus()) { /* suggested by Chris Litchfield */
+-                    output->printf("\n(Sending location code\n");
+-                    writeMUD("\e[40;13R\n");
+-                }
+-                
+-                code_pos = -1;
+-            }
+-        }
+-        
+-        *out = NUL;
+-
+-        // Run triggers on incompletely received lines
+-        bool cancel_line = triggerCheck(prompt_begin ? prompt_begin+1 : (char*) out_buf,
+-                                        prompt_begin ? out-prompt_begin-1: out-out_buf, &out);
+-        prompt_begin = out;
+-        if (cancel_line) {
+-            // We just gagged that line, so the \n which otherwise would be the beginning of the prompt
+-            // is eaten up.
+-            if (out > out_buf)
+-                prompt_begin = out-1;
+-            else
+-                prompt_begin = NULL;
+-        }
+-        
+-        print (out_buf);
+-        
+-        /* Do we have some leftover data, an incomplete ANSI sequence? */
+-        if (code_pos >= 0)
+-        {
+-            /* Copy so that the buffer is at the beginning of that code */
+-            memcpy (input_buffer, input_buffer + code_pos, count + pos - code_pos);
+-            
+-            /* Next incoming data will be put there */
+-            pos = count + pos - code_pos;
+-        }
+-        else
+-            pos = 0;
+-        
+-        
+-        
+-        /* spec: fix up partial lines for subsequent prompts */
+-        if (prompt_begin)
+-            strcpy ((char*)prompt, prompt_begin);
+-        else if (strlen((char*)prompt) < MAX_MUD_BUF/4 && strlen(out_buf) < MAX_MUD_BUF/4) {
+-            // guard against too long lines
+-            strcat((char*)prompt, out_buf);
+-        }
+-
+-
+-    } // end while
+-}
++		//case ansi_sequence
++
++	    case ansi_found_quot:
++                if( l_cur_buf[i] == IAC ) {
++		    m_state_stack.push_back(m_input_state);
++		    m_input_state = found_iac;
++		    continue;
++		}
++		//Is literally anything allowed between quotes in an ANSI key redefinition sequence?
++		//I think so
++		*m_ansi_pos++ = l_cur_buf[i];
++		if(l_cur_buf[i] == '"') {
++		    //Should always fall back to ansi_sequence
++                    m_input_state = m_state_stack.back();
++                    m_state_stack.pop_back();
++		}
++		continue;
++
++	    }//switch(m_input_state)
++
++	}//for(int i = 0; i < l_count; i++)
++    } // end while (mudcompress_pending(mcinfo))
++
++    //We got a complete line, flush it out
++    //TODO: is newline (\n) a valid character in any mode besides text?
++    //i.e., should I check for m_input_state == text here?
++    if( m_output_pos > m_output_buf && *(m_output_pos - 1) == '\n' )
++    {
++	*m_output_pos = NUL;
++        print( m_output_buf );
++        m_output_pos = m_output_buf;
++        m_last_line = m_output_buf;
++    }
++} //inputReady()
+ 
+ void Session::show_timer() {
+Index: h/StatusLine.h
+===================================================================
+--- h/StatusLine.h (revision 1)
++++ h/StatusLine.h (revision 3)
+@@ -11,5 +11,5 @@
+ 	virtual void idle();				// Check if it is time to remove the text
+ 	void set(const char *s);			// Set status lien to this message
+-	void setf(const char *fmt ...); 	// As above ,but formatted string
++	void setf(const char *fmt, ...); 	// As above ,but formatted string
+ 	
+ 	virtual void redraw();
+Index: h/Session.h
+===================================================================
+--- h/Session.h (revision 1)
++++ h/Session.h (revision 3)
+@@ -4,6 +4,9 @@
+ #include "mccpDecompress.h"
+ #include "Socket.h"
++#include <vector>
+ 
+-typedef enum {disconnected, connecting, connected} state_t;
++typedef enum {
++	disconnected, connecting, connected
++} state_t;
+ 
+ class NetworkStateWindow;
+@@ -11,61 +14,80 @@
+ class StatWindow;
+ class Window;
++class MUD;
++class ColorConverter;
++class Action;
+ 
+ class Session : public Socket {
+- public:
+-    Session(MUD& _mud, Window *_window, int _fd = -1);	// Initialize a new session to this mud
+-    ~Session();
+-    bool open();							// Connect
+-    bool close();							// Disconnect
+-    void idle();							// Do time-based updates
+-    
+-    void show_nsw();						// Show the NSW
+-    void show_timer();						// Show the Timer Window
+-    bool expand_macros(int key);			// Expand this macro key
+-    void writeMUD (const char *s);	     	// Send this
+-    
+-    state_t state;			// Are offline, connecting or connected?
+-    MUD& mud;
+-    
++public:
++	Session(MUD& _mud, Window *_window, int _fd = -1);	// Initialize a new session to this mud
++	~Session();
++	bool open();							// Connect
++	bool close();							// Disconnect
++	void idle();							// Do time-based updates
++
++	void show_nsw();						// Show the NSW
++	void show_timer();						// Show the Timer Window
++	bool expand_macros(int key);			// Expand this macro key
++	void writeMUD (const char *s);			// Send this
++
++	state_t state;			// Are offline, connecting or connected?
++	MUD& mud;
++	enum input_state_t {
++		text, found_iac, telnet_option, found_esc, ansi_sequence, ansi_found_quot
++	};
++
++
+ private:
+-    Window *window;			// Window we are writing to
+-    
+-    // Incomplete ANSI codes should be left in this buffer 
+-    unsigned char input_buffer[MAX_MUD_BUF];
+-    
+-    // and this one, partial lines (for prompts) 
+-    unsigned char prompt[MAX_MUD_BUF];
+-    int pos;
+-    
+-    NetworkStateWindow *nsw;	// if non-NULL, we display stats there when idle'ing
+-    TimerWindow *timer;			// Timer window
+-    StatWindow *statWindow;     // Input/Output statitstics here
+-	
+-    // Some statistics
+-    struct {
+-	int bytes_written, bytes_read;	// # of bytes read/written
+-	time_t connect_time;			// When did we connect?
+-	time_t dial_time;
+-    } stats;
+-    
+-    time_t last_nsw_update;
+-    mc_state *mcinfo;
+-    ColorConverter colorConverter;
++	Window *window;			// Window we are writing to
+ 
+-    friend class NetworkStateWindow;
+-    friend class StatWindow;
+-    friend class TimerWindow;
++	NetworkStateWindow *nsw;	// if non-NULL, we display stats there when idle'ing
++	TimerWindow *timer;			// Timer window
++	StatWindow *statWindow;		// Input/Output statitstics here
+ 
+-    void print(const char *s);				// Write to our output/log
++	// Some statistics
++	struct {
++		int bytes_written, bytes_read;	// # of bytes read/written
++		time_t connect_time;			// When did we connect?
++		time_t dial_time;
++	} stats;
+ 
+-    void set_prompt (const char *s, int len);
+-    bool triggerCheck (char *line, int len, char **out);
+-    void runTrigger(Action *a, char *buf, char *line, int& len, char **out);
+-    void establishConnection(bool quick_restore); // run on connect, qr = true if 'hot' boot
+-    int  convert_color (const unsigned char *s, int size);
++	time_t last_nsw_update;
++	mc_state *mcinfo;
++	ColorConverter m_colorConverter;
+ 
+-    virtual void connectionEstablished();
+-    virtual void inputReady();
+-    virtual void errorEncountered(int);
++	//Current input parser state
++	input_state_t m_input_state;
++	//State history. We need to know which state we should
++	//return to after processing escape sequences and/or
++	//telnet commands
++	std::vector<input_state_t> m_state_stack;
++
++	// Incomplete ANSI codes should be left in this buffer 
++	char m_ansi_buf[MAX_COLOR_BUF];
++	//points to the last char
++	char *m_ansi_pos;
++ 
++	//Incomplete lines
++	char m_output_buf[MAX_MUD_BUF];
++	//points to the last char
++	char *m_output_pos;
++	//points to the beginning of the last line
++	char *m_last_line;
++
++	friend class NetworkStateWindow;
++	friend class StatWindow;
++	friend class TimerWindow;
++
++	void print(const char *s);				// Write to our output/log
++
++	void set_prompt (const char *s, int len);
++	bool triggerCheck (char *line, int len, char **out);
++	void runTrigger(Action *a, char *buf, char *line, int& len, char **out);
++	void establishConnection(bool quick_restore); // run on connect, qr = true if 'hot' boot
++	int  convert_color (const unsigned char *s, int size);
++
++	virtual void connectionEstablished();
++	virtual void inputReady();
++	virtual void errorEncountered(int);
+ 
+ };
+Index: h/Socket.h
+===================================================================
+--- h/Socket.h (revision 1)
++++ h/Socket.h (revision 3)
+@@ -4,4 +4,8 @@
+ 
+ #include <netinet/in.h>
++#include "defs.h"
++#include "Buffer.h"
++
++class Selectable;
+ 
+ class Socket : public Selectable {
+Index: h/defs.h
+===================================================================
+--- h/defs.h (revision 1)
++++ h/defs.h (revision 3)
+@@ -4,4 +4,6 @@
+ #define MAX_MUD_BUF 4096
+ #define MAX_INPUT_BUF 1024
++#define MAX_COLOR_BUF 256
++
+ #define NUL '\0'
+ 
diff --git a/games-mud/mcl/mcl-0.53.00.ebuild b/games-mud/mcl/mcl-0.53.00.ebuild
index 051389f9d14c..fa0aa6da33e0 100644
--- a/games-mud/mcl/mcl-0.53.00.ebuild
+++ b/games-mud/mcl/mcl-0.53.00.ebuild
@@ -1,6 +1,6 @@
 # Copyright 1999-2007 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
-# $Header: /var/cvsroot/gentoo-x86/games-mud/mcl/mcl-0.53.00.ebuild,v 1.15 2007/04/09 18:34:31 nyhm Exp $
+# $Header: /var/cvsroot/gentoo-x86/games-mud/mcl/mcl-0.53.00.ebuild,v 1.16 2007/10/21 05:54:09 mr_bones_ Exp $
 
 inherit eutils games
 
@@ -25,12 +25,19 @@ src_unpack() {
 		"${FILESDIR}"/${PV}-vc.patch \
 		"${FILESDIR}"/${P}-gcc34.patch \
 		"${FILESDIR}"/${PV}-dynacomplete.patch \
-		"${FILESDIR}"/${P}-libdir.patch
+		"${FILESDIR}"/${P}-libdir.patch \
+		"${FILESDIR}"/${P}-inputlines.patch
 
 	sed -i \
 		-e "/MCL_LIBRARY_PATH/ s:/usr/lib/mcl:$(games_get_libdir)/${PN}:" \
 		h/mcl.h \
 		|| die "sed h/mcl.h failed"
+
+	# no strip for you
+	sed -i \
+		-e "/LDFLAGS=.*-s/s:-s::" \
+		configure \
+		|| die "sed failed"
 }
 
 src_compile() {