Exemplo n.º 1
0
 def test_expect_exact_basic(self):
     p = PopenSpawn('cat', timeout=5)
     p.sendline(b'Hello')
     p.sendline(b'there')
     p.sendline(b'Mr. Python')
     p.expect_exact(b'Hello')
     p.expect_exact(b'there')
     p.expect_exact(b'Mr. Python')
     p.sendeof()
     p.expect_exact(pexpect.EOF)
Exemplo n.º 2
0
 def test_expect_basic(self):
     p = PopenSpawn("cat", timeout=5)
     p.sendline(b"Hello")
     p.sendline(b"there")
     p.sendline(b"Mr. Python")
     p.expect(b"Hello")
     p.expect(b"there")
     p.expect(b"Mr. Python")
     p.sendeof()
     p.expect(pexpect.EOF)
Exemplo n.º 3
0
 def test_expect_exact_basic(self):
     p = PopenSpawn('cat', timeout=5)
     p.sendline(b'Hello')
     p.sendline(b'there')
     p.sendline(b'Mr. Python')
     p.expect_exact(b'Hello')
     p.expect_exact(b'there')
     p.expect_exact(b'Mr. Python')
     p.sendeof()
     p.expect_exact(pexpect.EOF)
Exemplo n.º 4
0
 def test_expect_exact_basic(self):
     p = PopenSpawn("cat", timeout=5)
     p.sendline(b"Hello")
     p.sendline(b"there")
     p.sendline(b"Mr. Python")
     p.expect_exact(b"Hello")
     p.expect_exact(b"there")
     p.expect_exact(b"Mr. Python")
     p.sendeof()
     p.expect_exact(pexpect.EOF)
Exemplo n.º 5
0
def run_file(f, test):
    p = PopenSpawn(f"python {f}")
    if type(test) == type([]):
        p.send("\n".join(test))
    else:
        p.send(test)
    p.sendeof()

    out = p.read().decode('utf-8')
    if not out:
        return f"No output received from file {f}."

    return out
Exemplo n.º 6
0
def launch_polysh(args, input_data=None):
    args = ['../run.py'] + args
    options, unused_args = parse_cmdline()
    if options.coverage:
        args = ['./coverage.py', '-x', '-p'] + args
    if options.log:
        logfile = open(options.log, 'a', 0o644)
        args += ['--debug']
        print('Launching:', str(args), file=logfile)
    else:
        logfile = None

    if input_data is None:
        child = pexpect.spawn(args[0],
                              args=args[1:],
                              encoding='utf-8',
                              logfile=logfile)
    else:
        child = PopenSpawn(args, encoding='utf-8', logfile=logfile)
        child.send(input_data)
        child.sendeof()
    return child
Exemplo n.º 7
0
class SerAPI:
    def __init__(self, timeout, debug=False):
        'Initialize the SerAPI subprocess'
        self.debug = debug
        try:
            self.proc = PopenSpawn('sertop --implicit --omit_loc --print0',
                                   encoding='utf-8',
                                   timeout=timeout,
                                   maxread=10000000)
        except FileNotFoundError:
            log(
                'Please make sure the "sertop" program is in the PATH.\nYou may have to run "eval $(opam env)".',
                'ERROR')
            sys.exit(1)
        self.proc.expect_exact(
            '(Feedback((doc_id 0)(span_id 1)(route 0)(contents Processed)))\0')
        self.send('Noop')
        self.states_stack = []

        # global printing options
        self.execute('Unset Printing Notations.')
        self.execute('Unset Printing Wildcard.')
        self.execute('Set Printing Coercions.')
        self.execute('Unset Printing Allow Match Default Clause.')
        self.execute('Unset Printing Factorizable Match Patterns.')
        self.execute('Unset Printing Compact Contexts.')
        self.execute('Set Printing Implicit.')
        self.execute('Set Printing Depth 999999.')
        self.execute('Unset Printing Records.')

        # initialize the state stack
        self.push()

        self.ast_cache = {}
        self.dead = False

    def set_timeout(self, timeout):
        self.proc.timeout = timeout

    def get_timeout(self):
        return proc.timeout

    def send(self, cmd):
        'Send a command to SerAPI and retrieve the responses'
        #print(cmd)
        assert '\n' not in cmd
        self.proc.sendline(cmd)
        try:
            self.proc.expect([
                '\(Answer \d+ Ack\)\x00.*\(Answer \d+ Completed\)\x00',
                '\(Answer \d+ Ack\)\x00.*\(Answer \d+\(CoqExn.*\)\x00'
            ])
        except pexpect.TIMEOUT as ex:
            print(self.proc.before)
            raise CoqTimeout
        raw_responses = self.proc.after
        #print(raw_responses)
        ack_num = int(
            re.search(r'^\(Answer (?P<num>\d+)', raw_responses)['num'])
        for num in re.findall(r'(?<=\(Answer) \d+', raw_responses):
            assert int(num) == ack_num
        responses = []
        msg_str = []
        for item in raw_responses.split('\x00'):
            item = item.strip()
            if item == '':
                continue
            if not item.startswith('(Feedback') and not item.startswith(
                    '(Answer'):
                m = re.search(r'\(Feedback|\(Answer', item)
                if m is None:
                    continue
                item = item[m.span()[0]:]
                assert item.endswith(')')
            parsed_item = sexpdata.loads(item, nil=None, true=None)
            if 'CoqExn' in item:  # an error occured in Coq
                assert parsed_item[2][0] == Symbol('CoqExn')
                raise CoqExn(sexpdata.dumps(parsed_item[2][4]),
                             sexpdata.dumps(parsed_item[2]))
            if item.startswith('(Feedback'):  # ignore Feedback for now
                try:
                    msg = parsed_item[1][3][1]
                    if isinstance(msg,
                                  list) and msg != [] and msg[0] == Symbol(
                                      'Message'):
                        msg_sexp, _ = self.send(
                            '(Print ((pp_format PpStr)) (CoqPp %s))' %
                            sexpdata.dumps(msg[3]))
                        msg_str.extend(
                            [symbol2str(x[1]) for x in msg_sexp[1][2][1]])
                except IndexError:
                    pass
                continue
            responses.append(parsed_item)
        msg_str = '\n'.join(msg_str)
        return responses, raw_responses

    def send_add(self, cmd, return_ast):
        'Send a (Add () "XXX") command to SerAPI, return the state id and optionally the AST'
        responses, raw_responses = self.send('(Add () "%s")' % escape(cmd))
        state_ids = [
            int(sid) for sid in ADDED_STATE_PATTERN.findall(raw_responses)
        ]
        state_id = state_ids[-1]
        if self.states_stack != []:
            self.states_stack[-1].append(state_id)
        if return_ast:
            if cmd not in self.ast_cache:
                self.ast_cache[cmd] = self.query_ast(cmd)
            ast = self.ast_cache[cmd]
        else:
            ast = None
        return state_id, ast

    def query_ast(self, cmd):
        'Query the AST of the vernac command just added'
        responses, _ = self.send('(Parse () "%s")' % escape(cmd))
        ast = responses[1][2][1][0]
        assert ast[0] == Symbol('CoqAst')
        return ast

    def query_library(self, lib):
        responses, _ = self.send('(Query () (LocateLibrary "%s"))' % lib)
        physical_path = symbol2str(responses[1][2][1][0][3])
        return physical_path

    def query_qualid(self, qualid):
        responses, _ = self.send('(Query () (Locate "%s"))' % qualid)
        if responses[1][2][1] == [] and qualid.startswith('SerTop.'):
            qualid = qualid[len('SerTop.'):]
            responses, _ = self.send('(Query () (Locate "%s"))' % qualid)
        assert len(responses[1][2][1]) == 1
        short_responses = responses[1][2][1][0][1][0][1]
        assert short_responses[1][0] == Symbol('DirPath')
        short_ident = '.'.join(
            [symbol2str(x[1]) for x in short_responses[1][1][::-1]] +
            [symbol2str(short_responses[2][1])])
        return short_ident

    def query_env(self, current_file):
        'Query the global environment'
        responses, _ = self.send('(Query () Env)')
        env = responses[1][2][1][0]

        # store the constants
        constants = []
        for const in env[1][0][1][0][1]:
            # identifier
            qualid = print_mod_path(const[0][1]) + '.' + \
                '.'.join([symbol2str(x[1]) for x in const[0][2][1][::-1]] + [symbol2str(const[0][3][1])])
            if qualid.startswith('SerTop.'):
                logical_path = 'SerTop'
                physical_path = current_file
            else:
                logical_path = mod_path_file(const[0][1])
                assert qualid.startswith(logical_path)
                physical_path = os.path.relpath(
                    self.query_library(logical_path))
            physical_path += ':' + qualid[len(logical_path) + 1:]
            short_ident = self.query_qualid(qualid)
            # term
            assert const[1][0][1][0] == Symbol('const_body')
            if const[1][0][1][1][0] == Symbol('Undef'):  # delaration
                opaque = None
                term = None
            elif const[1][0][1][1][0] == Symbol(
                    'Def'):  # transparent definition
                opaque = False
                term = None
            else:
                assert const[1][0][1][1][0] == Symbol(
                    'OpaqueDef')  # opaque definition
                opaque = True
                term = None
            # type
            assert const[1][0][2][0] == Symbol('const_type')
            type_sexp = sexpdata.dumps(const[1][0][2][1])
            type = self.print_constr(type_sexp)
            sort = self.query_type(type_sexp, return_str=True)
            constants.append({
                'physical_path': physical_path,
                'short_ident': short_ident,
                'qualid': qualid,
                'term': term,
                'type': type,
                'sort': sort,
                'opaque': opaque,
                'sexp': sexpdata.dumps(const[1][0][2][1])
            })

        # store the inductives
        inductives = []
        for induct in env[1][0][1][1][1]:
            # identifier
            qualid = print_mod_path(induct[0][1]) + '.' + \
                '.'.join([symbol2str(x[1]) for x in induct[0][2][1][::-1]] + [symbol2str(induct[0][3][1])])
            short_ident = self.query_qualid(qualid)
            if qualid.startswith('SerTop.'):
                logical_path = 'SerTop'
                physical_path = current_file
            else:
                logical_path = mod_path_file(induct[0][1])
                physical_path = os.path.relpath(
                    self.query_library(logical_path))
            assert qualid.startswith(logical_path)
            physical_path += ':' + qualid[len(logical_path) + 1:]
            # blocks
            blocks = []
            for blk in induct[1][0][0][1]:
                blk_qualid = '.'.join(
                    qualid.split('.')[:-1] + [symbol2str(blk[0][1][1])])
                blk_short_ident = self.query_qualid(blk_qualid)
                # constructors
                constructors = []
                for c_name, c_type in zip(blk[3][1], blk[4][1]):
                    c_name = symbol2str(c_name[1])
                    c_type = self.print_constr(sexpdata.dumps(c_type))
                    #if c_type is not None:
                    #    c_type = UNBOUND_REL_PATTERN.sub(short_ident, c_type)
                    constructors.append((c_name, c_type))
                blocks.append({
                    'short_ident': blk_short_ident,
                    'qualid': blk_qualid,
                    'constructors': constructors
                })

            inductives.append({
                'physical_path':
                physical_path,
                'blocks':
                blocks,
                'is_record':
                induct[1][0][1][1] != Symbol('NotRecord'),
                'sexp':
                sexpdata.dumps(induct)
            })

        return constants, inductives

    def query_goals(self):
        'Retrieve a list of open goals'
        responses, _ = self.send('(Query () Goals)')
        assert responses[1][2][0] == Symbol('ObjList')
        if responses[1][2][1] == []:  #  no goals
            return [], [], [], []
        else:
            assert len(responses[1][2][1]) == 1

            def store_goals(goals_sexp):
                goals = []
                for g in goals_sexp:
                    hypotheses = []
                    for h in g[2][1]:
                        h_sexp = sexpdata.dumps(h[2])
                        hypotheses.append({
                            'idents':
                            [symbol2str(ident[1]) for ident in h[0][::-1]],
                            'term': [
                                None if t == [] else self.print_constr(
                                    sexpdata.dumps(t)) for t in h[1]
                            ],
                            'type':
                            self.print_constr(h_sexp),
                            'sexp':
                            h_sexp
                        })

                    type_sexp = sexpdata.dumps(g[1][1])
                    goals.append({
                        'id': int(g[0][1]),
                        'type': self.print_constr(type_sexp),
                        'sexp': type_sexp,
                        'hypotheses': hypotheses[::-1]
                    })
                return goals

            fg_goals = store_goals(responses[1][2][1][0][1][0][1])
            bg_goals = store_goals(
                list(
                    chain.from_iterable(
                        chain.from_iterable(responses[1][2][1][0][1][1][1]))))
            shelved_goals = store_goals(responses[1][2][1][0][1][2][1])
            given_up_goals = store_goals(responses[1][2][1][0][1][3][1])
            return fg_goals, bg_goals, shelved_goals, given_up_goals

    def has_open_goals(self):
        responses, _ = self.send('(Query () Goals)')
        assert responses[1][2][0] == Symbol('ObjList')
        return responses[1][2][1] != []

    def print_constr(self, sexp_str):
        if not hasattr(self, 'constr_cache'):
            self.constr_cache = {}
        if sexp_str not in self.constr_cache:
            try:
                responses, _ = self.send(
                    '(Print ((pp_format PpStr)) (CoqConstr %s))' % sexp_str)
                self.constr_cache[sexp_str] = normalize_spaces(
                    symbol2str(responses[1][2][1][0][1]))
            except CoqExn as ex:
                if ex.err_msg == 'Not_found':
                    return None
                else:
                    raise ex
            except TypeError as ex:
                self.constr_cache[sexp_str] = normalize_spaces(
                    symbol2str(responses[0][2][1][0][1]))
        return self.constr_cache[sexp_str]

    def query_vernac(self, cmd):
        return self.send('(Query () (Vernac "%s"))' % escape(cmd))

    def query_type(self, term_sexp, return_str=False):
        try:
            responses, _ = self.send('(Query () (Type %s))' % term_sexp)
        except CoqExn as ex:
            if ex.err_msg == 'Not_found':
                return None
            else:
                raise ex
        assert responses[1][2][1][0][0] == Symbol('CoqConstr')
        type_sexp = responses[1][2][1][0][1]
        if return_str:
            return self.print_constr(sexpdata.dumps(type_sexp))
        else:
            return type_sexp

    def execute(self, cmd, return_ast=False):
        'Execute a vernac command'
        state_id, ast = self.send_add(cmd, return_ast)
        responses, _ = self.send('(Exec %d)' % state_id)
        return responses, sexpdata.dumps(ast)

    def push(self):
        'push a new frame on the state stack (a checkpoint), which can be used to roll back to the current state'
        self.states_stack.append([])

    def cancel(self, states):
        self.send('(Cancel (%s))' % ' '.join([str(s) for s in states]))

    def pull(self):
        'remove a checkpoint created by push'
        states = self.states_stack.pop()
        self.states_stack[-1].extend(states)

    def pop(self):
        'rollback to a checkpoint created by push'
        self.cancel(self.states_stack.pop())

    def clean(self):
        self.proc.sendeof()
        self.proc.wait()
        self.dead = True

    def shutdown(self):
        self.proc.kill(signal.SIGKILL)
        self.dead = True

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self.clean()
Exemplo n.º 8
0
class SerAPI:
    def __init__(self, timeout, debug=False):
        "Initialize the SerAPI subprocess"
        self.debug = debug
        try:
            self.proc = PopenSpawn(
                "sertop --implicit --omit_loc --print0",
                encoding="utf-8",
                timeout=timeout,
                maxread=10000000,
            )
        except FileNotFoundError:
            log(
                'Please make sure the "sertop" program is in the PATH.\nYou may have to run "eval $(opam env)".',
                "ERROR",
            )
            sys.exit(1)
        self.proc.expect_exact(
            "(Feedback((doc_id 0)(span_id 1)(route 0)(contents Processed)))\0")
        self.send("Noop")
        self.states_stack = []

        # global printing options
        self.execute("Unset Printing Notations.")
        self.execute("Unset Printing Wildcard.")
        self.execute("Set Printing Coercions.")
        self.execute("Unset Printing Allow Match Default Clause.")
        self.execute("Unset Printing Factorizable Match Patterns.")
        self.execute("Unset Printing Compact Contexts.")
        self.execute("Set Printing Implicit.")
        self.execute("Set Printing Depth 999999.")
        self.execute("Unset Printing Records.")

        # initialize the state stack
        self.push()

        self.ast_cache = {}
        self.dead = False

    def set_timeout(self, timeout):
        self.proc.timeout = timeout

    def get_timeout(self):
        return proc.timeout

    def send(self, cmd):
        "Send a command to SerAPI and retrieve the responses"
        # print(cmd)
        assert "\n" not in cmd
        self.proc.sendline(cmd)
        try:
            self.proc.expect([
                "\(Answer \d+ Ack\)\x00.*\(Answer \d+ Completed\)\x00",
                "\(Answer \d+ Ack\)\x00.*\(Answer \d+\(CoqExn.*\)\x00",
            ])
        except pexpect.TIMEOUT as ex:
            print(self.proc.before)
            raise CoqTimeout
        raw_responses = self.proc.after
        # print(raw_responses)
        ack_num = int(
            re.search(r"^\(Answer (?P<num>\d+)", raw_responses)["num"])
        for num in re.findall(r"(?<=\(Answer) \d+", raw_responses):
            assert int(num) == ack_num
        responses = []
        msg_str = []
        for item in raw_responses.split("\x00"):
            item = item.strip()
            if item == "":
                continue
            if not item.startswith("(Feedback") and not item.startswith(
                    "(Answer"):
                m = re.search(r"\(Feedback|\(Answer", item)
                if m is None:
                    continue
                item = item[m.span()[0]:]
                assert item.endswith(")")
            parsed_item = sexpdata.loads(item, nil=None, true=None)
            if "CoqExn" in item:  # an error occured in Coq
                assert parsed_item[2][0] == Symbol("CoqExn")
                raise CoqExn(sexpdata.dumps(parsed_item[2][4]),
                             sexpdata.dumps(parsed_item[2]))
            if item.startswith("(Feedback"):  # ignore Feedback for now
                try:
                    msg = parsed_item[1][3][1]
                    if (isinstance(msg, list) and msg != []
                            and msg[0] == Symbol("Message")):
                        msg_sexp, _ = self.send(
                            "(Print ((pp_format PpStr)) (CoqPp %s))" %
                            sexpdata.dumps(msg[3]))
                        msg_str.extend(
                            [symbol2str(x[1]) for x in msg_sexp[1][2][1]])
                except IndexError:
                    pass
                continue
            responses.append(parsed_item)
        msg_str = "\n".join(msg_str)
        return responses, raw_responses

    def send_add(self, cmd, return_ast):
        'Send a (Add () "XXX") command to SerAPI, return the state id and optionally the AST'
        responses, raw_responses = self.send('(Add () "%s")' % escape(cmd))
        state_ids = [
            int(sid) for sid in ADDED_STATE_PATTERN.findall(raw_responses)
        ]
        state_id = state_ids[-1]
        if self.states_stack != []:
            self.states_stack[-1].append(state_id)
        if return_ast:
            if cmd not in self.ast_cache:
                self.ast_cache[cmd] = self.query_ast(cmd)
            ast = self.ast_cache[cmd]
        else:
            ast = None
        return state_id, ast

    def query_ast(self, cmd):
        "Query the AST of the vernac command just added"
        responses, _ = self.send('(Parse () "%s")' % escape(cmd))
        ast = responses[1][2][1][0]
        assert ast[0] == Symbol("CoqAst")
        return ast

    def query_library(self, lib):
        responses, _ = self.send('(Query () (LocateLibrary "%s"))' % lib)
        physical_path = symbol2str(responses[1][2][1][0][3])
        return physical_path

    def query_qualid(self, qualid):
        responses, _ = self.send('(Query () (Locate "%s"))' % qualid)
        if responses[1][2][1] == [] and qualid.startswith("SerTop."):
            qualid = qualid[len("SerTop."):]
            responses, _ = self.send('(Query () (Locate "%s"))' % qualid)
        assert len(responses[1][2][1]) == 1
        short_responses = responses[1][2][1][0][1][0][1]
        assert short_responses[1][0] == Symbol("DirPath")
        short_ident = ".".join(
            [symbol2str(x[1]) for x in short_responses[1][1][::-1]] +
            [symbol2str(short_responses[2][1])])
        return short_ident

    def query_env(self, current_file):
        "Query the global environment"
        responses, _ = self.send("(Query () Env)")
        env = responses[1][2][1][0]

        # store the constants
        constants = []
        for const in env[1][0][1][0][1]:
            # identifier
            qualid = (
                print_mod_path(const[0][1]) + "." +
                ".".join([symbol2str(x[1]) for x in const[0][2][1][::-1]] +
                         [symbol2str(const[0][3][1])]))
            if qualid.startswith("SerTop."):
                logical_path = "SerTop"
                physical_path = current_file
            else:
                logical_path = mod_path_file(const[0][1])
                assert qualid.startswith(logical_path)
                physical_path = os.path.relpath(
                    self.query_library(logical_path))
            physical_path += ":" + qualid[len(logical_path) + 1:]
            short_ident = self.query_qualid(qualid)
            # term
            assert const[1][0][1][0] == Symbol("const_body")
            if const[1][0][1][1][0] == Symbol("Undef"):  # delaration
                opaque = None
                term = None
            elif const[1][0][1][1][0] == Symbol(
                    "Def"):  # transparent definition
                opaque = False
                term = None
            else:
                assert const[1][0][1][1][0] == Symbol(
                    "OpaqueDef")  # opaque definition
                opaque = True
                term = None
            # type
            assert const[1][0][2][0] == Symbol("const_type")
            type_sexp = sexpdata.dumps(const[1][0][2][1])
            type = self.print_constr(type_sexp)
            sort = self.query_type(type_sexp, return_str=True)
            constants.append({
                "physical_path": physical_path,
                "short_ident": short_ident,
                "qualid": qualid,
                "term": term,
                "type": type,
                "sort": sort,
                "opaque": opaque,
                "sexp": sexpdata.dumps(const[1][0][2][1]),
            })

        # store the inductives
        inductives = []
        for induct in env[1][0][1][1][1]:
            # identifier
            qualid = (
                print_mod_path(induct[0][1]) + "." +
                ".".join([symbol2str(x[1]) for x in induct[0][2][1][::-1]] +
                         [symbol2str(induct[0][3][1])]))
            short_ident = self.query_qualid(qualid)
            if qualid.startswith("SerTop."):
                logical_path = "SerTop"
                physical_path = current_file
            else:
                logical_path = mod_path_file(induct[0][1])
                physical_path = os.path.relpath(
                    self.query_library(logical_path))
            assert qualid.startswith(logical_path)
            physical_path += ":" + qualid[len(logical_path) + 1:]
            # blocks
            blocks = []
            for blk in induct[1][0][0][1]:
                blk_qualid = ".".join(
                    qualid.split(".")[:-1] + [symbol2str(blk[0][1][1])])
                blk_short_ident = self.query_qualid(blk_qualid)
                # constructors
                constructors = []
                for c_name, c_type in zip(blk[3][1], blk[4][1]):
                    c_name = symbol2str(c_name[1])
                    c_type = self.print_constr(sexpdata.dumps(c_type))
                    # if c_type is not None:
                    #    c_type = UNBOUND_REL_PATTERN.sub(short_ident, c_type)
                    constructors.append((c_name, c_type))
                blocks.append({
                    "short_ident": blk_short_ident,
                    "qualid": blk_qualid,
                    "constructors": constructors,
                })

            inductives.append({
                "physical_path":
                physical_path,
                "blocks":
                blocks,
                "is_record":
                induct[1][0][1][1] != Symbol("NotRecord"),
                "sexp":
                sexpdata.dumps(induct),
            })

        return constants, inductives

    def query_goals(self):
        "Retrieve a list of open goals"
        responses, _ = self.send("(Query () Goals)")
        assert responses[1][2][0] == Symbol("ObjList")
        if responses[1][2][1] == []:  #  no goals
            return [], [], [], []
        else:
            assert len(responses[1][2][1]) == 1

            def store_goals(goals_sexp):
                goals = []
                for g in goals_sexp:
                    hypotheses = []
                    for h in g[2][1]:
                        h_sexp = sexpdata.dumps(h[2])
                        hypotheses.append({
                            "idents":
                            [symbol2str(ident[1]) for ident in h[0][::-1]],
                            "term": [
                                None if t == [] else self.print_constr(
                                    sexpdata.dumps(t)) for t in h[1]
                            ],
                            "type":
                            self.print_constr(h_sexp),
                            "sexp":
                            h_sexp,
                        })

                    type_sexp = sexpdata.dumps(g[1][1])
                    goals.append({
                        "id": int(g[0][1]),
                        "type": self.print_constr(type_sexp),
                        "sexp": type_sexp,
                        "hypotheses": hypotheses[::-1],
                    })
                return goals

            fg_goals = store_goals(responses[1][2][1][0][1][0][1])
            bg_goals = store_goals(
                list(
                    chain.from_iterable(
                        chain.from_iterable(responses[1][2][1][0][1][1][1]))))
            shelved_goals = store_goals(responses[1][2][1][0][1][2][1])
            given_up_goals = store_goals(responses[1][2][1][0][1][3][1])
            return fg_goals, bg_goals, shelved_goals, given_up_goals

    def has_open_goals(self):
        responses, _ = self.send("(Query () Goals)")
        assert responses[1][2][0] == Symbol("ObjList")
        return responses[1][2][1] != []

    def print_constr(self, sexp_str):
        if not hasattr(self, "constr_cache"):
            self.constr_cache = {}
        if sexp_str not in self.constr_cache:
            try:
                responses, _ = self.send(
                    "(Print ((pp_format PpStr)) (CoqConstr %s))" % sexp_str)
                self.constr_cache[sexp_str] = normalize_spaces(
                    symbol2str(responses[1][2][1][0][1]))
            except CoqExn as ex:
                if ex.err_msg == "Not_found":
                    return None
                else:
                    raise ex
            except TypeError as ex:
                self.constr_cache[sexp_str] = normalize_spaces(
                    symbol2str(responses[0][2][1][0][1]))
        return self.constr_cache[sexp_str]

    def query_vernac(self, cmd):
        return self.send('(Query () (Vernac "%s"))' % escape(cmd))

    def query_type(self, term_sexp, return_str=False):
        try:
            responses, _ = self.send("(Query () (Type %s))" % term_sexp)
        except CoqExn as ex:
            if ex.err_msg == "Not_found":
                return None
            else:
                raise ex
        assert responses[1][2][1][0][0] == Symbol("CoqConstr")
        type_sexp = responses[1][2][1][0][1]
        if return_str:
            return self.print_constr(sexpdata.dumps(type_sexp))
        else:
            return type_sexp

    def execute(self, cmd, return_ast=False):
        "Execute a vernac command"
        state_id, ast = self.send_add(cmd, return_ast)
        responses, _ = self.send("(Exec %d)" % state_id)
        return responses, sexpdata.dumps(ast)

    def push(self):
        "push a new frame on the state stack (a checkpoint), which can be used to roll back to the current state"
        self.states_stack.append([])

    def cancel(self, states):
        self.send("(Cancel (%s))" % " ".join([str(s) for s in states]))

    def pull(self):
        "remove a checkpoint created by push"
        states = self.states_stack.pop()
        self.states_stack[-1].extend(states)
        return len(states)

    def pop(self):
        "rollback to a checkpoint created by push"
        self.cancel(self.states_stack.pop())

    def pop_n(self, cnt):
        states = []
        for i in range(cnt):
            states.append(self.states_stack[-1].pop())
        self.cancel(states)

    def clean(self):
        self.proc.sendeof()
        self.proc.wait()
        self.dead = True

    def shutdown(self):
        self.proc.kill(signal.SIGKILL)
        self.dead = True

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self.clean()