interpreter.h

Go to the documentation of this file.

/*
 *  GXML/Graphite: Geometry and Graphics Programming Library + Utilities
 *  Copyright (C) 2000 Bruno Levy
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  If you modify this software, you should include a notice giving the
 *  name of the person performing the modification, the date of modification,
 *  and the reason for such modification.
 *
 *  Contact: Bruno Levy
 *
 *     levy@loria.fr
 *
 *     ISA Project
 *     LORIA, INRIA Lorraine,
 *     Campus Scientifique, BP 239
 *     54506 VANDOEUVRE LES NANCY CEDEX
 *     FRANCE
 *
 *  Note that the GNU General Public License does not permit incorporating
 *  the Software into proprietary programs.
 */
 
#ifndef H_OGF_GOM_INTERPRETER_H
#define H_OGF_GOM_INTERPRETER_H
 
#include <OGF/gom/common/common.h>
#include <OGF/gom/types/object.h>
#include <geogram/basic/numeric.h>
#include <string>
#include <vector>
#include <map>
 
namespace OGF {
 
    class Interpreter;
    class Object;
    class MetaClass;
    class MetaMethod;
    class ArgList;
    class Request;
    class Callable;
    class Connection;
 
    /*************************************************************************/
 
    gom_attribute(abstract,"true")
    gom_class GOM_API Scope : public Object {
      public:
        Scope(Object* object);
 
        ~Scope() override;
 
        virtual Any resolve(const std::string& name) = 0;
 
        virtual void list_names(std::vector<std::string>& names) const;
 
        void search(
            const std::string& needle, const std::string& path=""
        ) override;
 
        virtual index_t get_nb_elements() const override;
 
        virtual void get_element(index_t i, Any& value) const override;
 
 
      protected:
        Object* object_;
    };
 
    typedef SmartPointer<Scope> Scope_var;
 
    /*************************************************************************/
 
    gom_class GOM_API GlobalScope : public Scope {
      public:
        GlobalScope(Interpreter* interpreter);
 
        ~GlobalScope() override;
 
        Any resolve(const std::string& name) override;
 
        void list_names(std::vector<std::string>& names) const override;
    };
 
    /************************************************************************/
 
    gom_class GOM_API InterfaceScope : public Scope {
      public:
        InterfaceScope(Object* object);
 
        ~InterfaceScope() override;
 
        Any resolve(const std::string& name) override;
 
        void list_names(std::vector<std::string>& names) const override;
    };
 
    /*************************************************************************/
 
    gom_class GOM_API MetaTypesScope : public Scope {
      public:
        MetaTypesScope(const std::string& prefix = "");
 
        ~MetaTypesScope() override;
 
        Any resolve(const std::string& name) override;
 
        void list_names(std::vector<std::string>& names) const override;
 
    gom_slots:
        MetaTypesScope* create_subscope(const std::string& name);
 
    private:
        std::string prefix_;
        std::map<std::string, Scope_var> subscopes_;
    };
 
 
    /*************************************************************************/
 
 
    gom_attribute(abstract,"true")
    gom_class GOM_API Interpreter : public Object {
 
    public:
 
        Interpreter();
 
        virtual void reset()=0;
 
        virtual Any resolve(const std::string& id, bool quiet=true) const;
 
        virtual void bind(const std::string& id, const Any& value) = 0;
 
        virtual void list_names(std::vector<std::string>& names) const;
 
        virtual Any eval(
            const std::string& expression, bool quiet=true
        ) const;
 
 
    gom_slots:
        void inspect(Object* object);
 
        void inspect_meta_type(MetaType* meta_type);
 
        void list_classes();
 
        void bind_object(const std::string& id, Object* object);
 
        Object* resolve_object(const std::string& id, bool quiet=true) const;
 
 
        Object* resolve_object_by_global_id(
            const std::string& id, bool quiet=true
        ) const;
 
        Object* eval_object(
            const std::string& expression, bool quiet=true
        ) const;
 
        std::string eval_string(
            const std::string& expression, bool quiet=true
        ) const;
 
        virtual MetaType* resolve_meta_type(const std::string& type_name) const;
 
        virtual bool bind_meta_type(MetaType* mtype);
 
        virtual Object* create(const ArgList& args);
 
        virtual std::string get_environment_value(const std::string& name);
 
        virtual void set_environment_value(
            const std::string& name, const std::string& value
        );
 
        virtual bool execute(
            const std::string& command,
            bool save_in_history = true,
            bool log = true
        ) = 0;
 
        virtual bool execute_file(const std::string& file_name);
 
        virtual void out(
            const std::string& message, const std::string& tag = "GOM"
        );
 
        virtual void err(
            const std::string& message, const std::string& tag = "GOM"
        );
 
        virtual void warn(
            const std::string& message, const std::string& tag = "GOM"
        );
 
        virtual void status(const std::string& message);
 
        virtual void append_dynamic_libraries_path(const std::string& path);
 
        virtual void append_to_ogf_path(const std::string& path);
 
        virtual bool load_module(const std::string& module_name);
 
        virtual Connection* connect(Request* from, Callable* to);
 
 
        Interpreter* interpreter(const std::string& language) {
            return instance_by_language(language);
        }
 
        Interpreter* interpreter_by_file_extension(
            const std::string& extension
        ) {
            return instance_by_file_extension(extension);
        }
 
        void search(
            const std::string& needle, const std::string& path=""
        ) override;
 
        virtual void save_history(const std::string& file_name) const;
 
        virtual void clear_history();
 
        void add_to_history(const std::string& command);
 
        virtual std::string back_resolve(Object* object) const;
 
      public:
        static Interpreter* default_interpreter() {
            return default_interpreter_;
        }
 
      gom_properties:
        virtual std::string get_history() const;
 
        const std::string& get_language() const {
            return language_;
        }
 
        const std::string& get_filename_extension() const {
            return extension_;
        }
 
        Scope* get_globals() const {
            return globals_;
        }
 
        Scope* get_meta_types() const {
            return meta_types_;
        }
 
        bool get_record_set_property() const {
            return record_set_property_;
        }
 
 
        void set_record_set_property(bool x) {
            record_set_property_ = x;
        }
 
        bool get_show_add_to_history() const {
            return show_add_to_history_;
        }
 
        void set_show_add_to_history(bool x) {
            show_add_to_history_ = x;
        }
 
      public:
 
        static Interpreter* instance_by_language(const std::string& language);
 
        static Interpreter* instance_by_file_extension(
            const std::string& extension
        );
 
        ~Interpreter() override;
 
        static void initialize(
            Interpreter* instance, const std::string& language,
            const std::string& extension
        );
 
 
        static void terminate(
            const std::string& language, const std::string& extension
        );
 
        static void terminate();
 
        Object* create(const std::string& classname, const ArgList& args);
 
        virtual void automatic_completion(
            const std::string& line, index_t startw, index_t endw,
            const std::string& cmpword, std::vector<std::string>& matches
        );
 
 
        virtual void record_invoke_in_history(
            Object* target, const std::string& slot_name, const ArgList& args
        );
 
        virtual void record_set_property_in_history(
            Object* target, const std::string& prop_name, const Any& value
        );
 
        size_t history_size() const {
            return history_.size();
        }
 
        std::string history_line(unsigned int l) const {
            return l < history_size() ? history_[l] : std::string("");
        }
 
 
        virtual std::string back_parse(
            const Any& any, MetaType* mtype=nullptr
        ) const;
 
      protected:
        void filename_completion(
            const std::string& prefix,
            std::vector<std::string>& completions
        );
 
        void filter_completion_candidates(
            const std::string& prefix, std::vector<std::string>& completions
        );
 
        virtual void get_keys(
            const std::string& context, std::vector<std::string>& keys
        );
 
        virtual void get_keys(
            Any& context, std::vector<std::string>& keys
        );
 
        void inspect_method(Object* object, MetaMethod* mmethod);
 
        void inspect_meta_class(Object* object, MetaClass* mclass);
 
        void inspect_meta_method(MetaMethod* mmethod);
 
        void set_language(const std::string& language) {
            language_ = language;
        }
 
        void set_filename_extension(const std::string& extension) {
            extension_ = extension;
        }
 
        virtual std::string stringify(const std::string& str) const;
 
        virtual std::string name_value_pair_call(const std::string& args) const;
 
        virtual bool is_keyword(const std::string& name) const;
 
        virtual bool name_needs_quotes(const std::string& name) const;
 
    protected:
        std::vector<std::string> history_;
        std::string language_;
        std::string extension_;
        // If not set, record_set_property_in_history()) is ignored.
        bool record_set_property_;
        // If set, commands added to history are shown in the terminal
        bool show_add_to_history_;
 
    private:
        static std::map<
            std::string, SmartPointer<Interpreter>
        > instance_;
        static std::map<std::string, Interpreter*>
            instance_by_file_extension_;
        static Interpreter* default_interpreter_;
 
        Scope_var globals_;
        Scope_var meta_types_;
    };
 
    typedef SmartPointer<Interpreter> Interpreter_var;
 
    /*************************************************************************/
 
}
 
#endif