How to use the bashlex.errors function in bashlex

def test_escape_error(self):
        return # TODO

        s = "a b\\"

        self.assertRaisesRegexp(errors.ParsingError, "No escaped character.*position 2", tokenize, s)

def test_unparsed(self):
        cmd = '(bar; bar) c'
        self.assertRaises(bashlex.errors.ParsingError,
                          matcher.matcher(cmd, s).match)

def test_malformed_if(self):
        s = 'if foo; bar; fi'
        self.assertRaisesRegexp(errors.ParsingError, "unexpected token 'fi'.*position 13", parse, s)

        s = 'if foo; then bar;'
        self.assertRaisesRegexp(errors.ParsingError, "unexpected EOF.*position 17", parse, s)

        s = 'if foo; then bar; elif baz; fi'
        self.assertRaisesRegexp(errors.ParsingError, "unexpected token 'fi'.*position 28", parse, s)

def p_error(p):
    assert isinstance(p, tokenizer.token)

    if p.ttype == tokenizer.tokentype.EOF:
        raise errors.ParsingError('unexpected EOF',
                                  p.lexer.source,
                                  len(p.lexer.source))
    else:
        raise errors.ParsingError('unexpected token %r' % p.value,
                                  p.lexer.source, p.lexpos)

'transform',
                  'uncompress',
                  'execglam2',
                  'execglam2scan',
                  'CGATparameter',
                  'checkpoint',
                  'for']

    for statement in statements:
        # use bashlex to parse statements
        commands = []
        try:
            # print(statement)
            parts = bashlex.parse(statement)
            get_cmd_names(parts[0], commands)
        except bashlex.errors.ParsingError:
            pass

        for command in commands:
            # print(command)
            if command.lower() not in exceptions:
                if command not in deps:
                    deps[command] = 1
                else:
                    deps[command] += 1

    # list of unmet dependencies
    check_path_failures = []

    # print dictionary ordered by value
    for k in sorted(deps, key=deps.get, reverse=True):
        if shutil.which(k) is None:

elif c == '$' and len(string) > 1:
            tindex = sindex[0]
            node, sindex[0] = _paramexpand(parserobj, string, sindex[0])
            if node:
                parts.append(node)
            istring += string[tindex:sindex[0]]
        elif c == '`':
            tindex = sindex[0]
            # bare instance of ``
            if nextchar() == '`':
                sindex[0] += 1
                istring += '``'
            else:
                x = _stringextract(string, sindex[0], "`")
                if x == -1:
                    raise errors.ParsingError('bad substitution: no closing "`" '
                                              'in %s' % string)
                else:
                    if wordtoken.flags & flags.word.NOCOMSUB:
                        pass
                    else:
                        sindex[0] = x

                        word = string[tindex+1:sindex[0]]
                        command, ttindex = _recursiveparse(parserobj, word, 0)
                        _adjustpositions(command, tindex+1, len(string))
                        ttindex += 1 # ttindex is on the closing char

                        # assert sindex[0] == ttindex
                        # go one past the closing `
                        sindex[0] += 1

fullline = fullline[1:]

        if not fullline:
            continue

        if fullline[:-1] == redirword and fullline[len(redirword)] == '\n':
            document.append(fullline[:-1])
            # document_done
            break

        document.append(fullline)
        #fullline = self.readline(bool(redirnode.flags & flags.word.QUOTED))
        fullline = tokenizer.readline(False)

    if not fullline:
        raise errors.ParsingError("here-document at line %d delimited by end-of-file (wanted %r)" % (lineno, redirword), tokenizer._shell_input_line, tokenizer._shell_input_line_index)

    document = ''.join(document)
    endpos = tokenizer._shell_input_line_index - 1

    assert hasattr(redirnode, 'heredoc')
    redirnode.heredoc = ast.node(kind='heredoc', value=document,
                                 pos=(startpos, endpos))

    # if the heredoc immediately follows this node, fix its end pos
    if redirnode.pos[1] + 1 == startpos:
        redirnode.pos = (redirnode.pos[0], endpos)

    return document

"while" : tokentype.WHILE,
    "until" : tokentype.UNTIL,
    "do" : tokentype.DO,
    "done" : tokentype.DONE,
    "in" : tokentype.IN,
    "function" : tokentype.FUNCTION,
    "time" : tokentype.TIME,
    "{" : tokentype.LEFT_CURLY,
    "}" : tokentype.RIGHT_CURLY,
    "!" : tokentype.BANG,
    "[[" : tokentype.COND_START,
    "]]" : tokentype.COND_END,
    "coproc" : tokentype.COPROC
}

class MatchedPairError(errors.ParsingError):
    def __init__(self, startline, message, tokenizer):
        # TODO use startline?
        super(MatchedPairError, self).__init__(message,
                                               tokenizer.source,
                                               tokenizer._shell_input_line_index - 1)

wordflags = flags.word
parserflags = flags.parser

class token(object):
    def __init__(self, type_, value, pos=None, flags=None):
        if type_ is not None:
            assert isinstance(type_, tokentype)

        if flags is None:
            flags = set()

def p_error(p):
    assert isinstance(p, tokenizer.token)

    if p.ttype == tokenizer.tokentype.EOF:
        raise errors.ParsingError('unexpected EOF',
                                  p.lexer.source,
                                  len(p.lexer.source))
    else:
        raise errors.ParsingError('unexpected token %r' % p.value,
                                  p.lexer.source, p.lexpos)

command = command[:1000] # trim commands longer than 1000 characters
    if '\n' in command:
        return render_template('errors/error.html', title='parsing error!',
                               message='no newlines please')

    s = store.store('explainshell', config.MONGO_URI)
    try:
        matches, helptext = explaincommand(command, s)
        return render_template('explain.html',
                               matches=matches,
                               helptext=helptext,
                               getargs=command)

    except errors.ProgramDoesNotExist, e:
        return render_template('errors/missingmanpage.html', title='missing man page', e=e)
    except bashlex.errors.ParsingError, e:
        logger.warn('%r parsing error: %s', command, e.message)
        return render_template('errors/parsingerror.html', title='parsing error!', e=e)
    except NotImplementedError, e:
        logger.warn('not implemented error trying to explain %r', command)
        msg = ("the parser doesn't support %r constructs in the command you tried. you may "
               "<a href="https://github.com/idank/explainshell/issues">report a "
               "bug</a> to have this added, if one doesn't already exist.") % e.args[0]

        return render_template('errors/error.html', title='error!', message=msg)
    except:
        logger.error('uncaught exception trying to explain %r', command, exc_info=True)
        msg = 'something went wrong... this was logged and will be checked'
        return render_template('errors/error.html', title='error!', message=msg)