SchemeEval.h

Go to the documentation of this file.

/*
 * SchemeEval.h
 *
 * Scheme expression evaluator for OpenCog
 * Copyright (c) 2008, 2014 Linas Vepstas <linas@linas.org>
 */

#ifndef OPENCOG_SCHEME_EVAL_H
#define OPENCOG_SCHEME_EVAL_H
#ifdef HAVE_GUILE

#include <condition_variable>
#include <mutex>
#include <string>
#include <sstream>
#include <cstddef>
#include <libguile.h>
#include <opencog/atomspace/Handle.h>
#include <opencog/atomspace/TruthValue.h>
#include <opencog/shell/GenericEval.h>
#include <opencog/util/exceptions.h>

namespace opencog {
class AtomSpace;

class SchemeEval : public GenericEval
{
    private:
        // Initialization stuff
        void init(void);
        static void * c_wrap_init(void *);
        void per_thread_init(void);
        void thread_lock(void);
        void thread_unlock(void);

        // Destructor stuff
        void finish(void);
        static void * c_wrap_finish(void *);

        // Things related to (async) cogserver shell-evaluation
        void do_eval(const std::string &);
        std::string do_poll_result();
        static void * c_wrap_eval(void *);
        static void * c_wrap_poll(void *);
        const std::string *pexpr;
        std::string answer;
        SCM _rc;
        bool _eval_done;
        bool _poll_done;
        std::mutex _poll_mtx;
        std::condition_variable _wait_done;
        std::string poll_port();
        SCM _pipe;
        int _pipeno;

        // Output port, for any printing done by scheme code.
        SCM _outport;
        SCM _saved_outport;
        bool _in_shell;
        bool _in_server;
        int _in_redirect;
        void capture_port();
        void redirect_output();
        void restore_output();
        void drain_output();

        // Straight-up evaluation
        SCM do_scm_eval(SCM, SCM (*)(void *));
        static void * c_wrap_eval_h(void *);
        static void * c_wrap_eval_tv(void *);

        // Apply function to arguments, returning Handle or TV
        Handle do_apply(const std::string& func, Handle& varargs);
        SCM do_apply_scm(const std::string& func, Handle& varargs);
        Handle hargs;
        TruthValuePtr tvp;
        static void * c_wrap_apply(void *);
        static void * c_wrap_apply_tv(void *);

        // Exception and error handling stuff
        SCM error_string;
        std::string error_msg;
        void set_error_string(SCM);
        SCM captured_stack;
        void set_captured_stack(SCM);
        static SCM preunwind_handler_wrapper(void *, SCM, SCM);
        static SCM catch_handler_wrapper(void *, SCM, SCM);
        SCM preunwind_handler(SCM, SCM);
        SCM catch_handler(SCM, SCM);

        // Printing of basic types
        static std::string prt(SCM);

        static void * c_wrap_set_atomspace(void *);
        AtomSpace* atomspace;
        int _gc_ctr;
        bool _in_eval;

    public:
        // Call before first use.
        static void init_scheme(void);

        // Set per-thread global
        static void set_scheme_as(AtomSpace*);

        SchemeEval(AtomSpace* = NULL);
        ~SchemeEval();

        // Return per-thread, per-atomspace singleton
        static SchemeEval* get_evaluator(AtomSpace* = NULL);

        // The async-output interface.
        void begin_eval();
        void eval_expr(const std::string&);
        std::string poll_result();

        // The synchronous-output interfaces.
        std::string eval(const std::string& expr)
            { begin_eval(); eval_expr(expr); return poll_result(); }
        std::string eval(const std::stringstream& ss)
            { return eval(ss.str()); }

        // Evaluate expression, returning handle.
        Handle eval_h(const std::string&);
        Handle eval_h(const std::stringstream& ss) { return eval_h(ss.str()); }

        // Evaluate expression, returning TV.
        TruthValuePtr eval_tv(const std::string&);
        TruthValuePtr eval_tv(const std::stringstream& ss) { return eval_tv(ss.str()); }

        // Apply expression to args, returning Handle or TV
        Handle apply(const std::string& func, Handle varargs);
        TruthValuePtr apply_tv(const std::string& func, Handle varargs);

        // Nested invocations
        bool recursing(void) { return _in_eval; }
};



}

#endif/* HAVE_GUILE */

#endif /* OPENCOG_SCHEME_EVAL_H */