'Read until one from a list of a regular expressions matches.
The first argument is a list of regular expressions, either
compiled (re.RegexObject instances) or uncompiled (strings).
The optional second argument is a timeout, in seconds; default
is no timeout.
Return a tuple of three items: the index in the list of the
first regular expression that matches; the match object
returned; and the text read up till and including the match.
If EOF is read and no text was read, raise EOFError.
Otherwise, when nothing matches, return (-1, None, text) where
text is the text received so far (may be the empty string if a
timeout happened).
If a regular expression ends with a greedy match (e.g. \'.*\')
or if more than one expression can match the same input, the
results are undeterministic, and may depend on the I/O timing.'

def expect(self, list, timeout=None):

    re = None
    list = list[:]
    indices = range(len(list))
    for i in indices:
        if (not hasattr(list[i], 'search')):
            if (not re):
                import re
            list[i] = re.compile(list[i])
    if (timeout is not None):
        from time import time
        time_start = time()
    while 1:
        self.process_rawq()
        for i in indices:
            m = list[i].search(self.cookedq)
            if m:
                e = m.end()
                text = self.cookedq[:e]
                self.cookedq = self.cookedq[e:]
                return (i, m, text)
        if self.eof:
            break
        if (timeout is not None):
            elapsed = (time() - time_start)
            if (elapsed >= timeout):
                break
            s_args = ([self.fileno()], [], [], (timeout - elapsed))
            (r, w, x) = select.select(*s_args)
            if (not r):
                break
        self.fill_rawq()
    text = self.read_very_lazy()
    if ((not text) and self.eof):
        raise EOFError
    return ((-1), None, text)
