chainlink_base.h

/****************************************************************************
 This file is part of ChainLink
 Copyright (C) 2007 Jeremy Magland (Jeremy.Magland@gmail.com)

 ChainLink 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.

 ChainLink 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 ChainLink; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*****************************************************************************/



#ifndef CHAINLINK_BASE_H
#define CHAINLINK_BASE_H

#include "chainlink_complex.h"
#include "chainlink_string.h"
#include "mda.h"

//the vector and matrix types are nothing more than mdas
//the ChainLink framework will do some checking to ensure that a vector is 1D and matrix is 2D
typedef mda vector; 
typedef mda matrix;

typedef int32 integer;

class mdac_object_base  {
public:
        void *data;
        char data_type[100];

        mdac_object_base() {
                strcpy(data_type,"NULL");
                data=0;
        };
        virtual ~mdac_object_base() {
        };
};

bool convert_object(mdac_object_base *dest,mdac_object_base *src);
bool can_convert(char *dest_str,mdac_object_base *src);

class workspace_shell {
public:
        virtual ~workspace_shell() {};
        virtual void display(const char *str,bool is_error=false) {
        }

        virtual void clear_command_window() {
        }

        virtual void display_prompt() {
        }
        virtual void on_exit() {
        }
};

class workspace {
public:
        workspace_shell *the_shell;
        char current_directory[500];

        workspace() {
                strcpy(current_directory,"");
                the_shell=0;
        };
        virtual ~workspace() {
        };      

        virtual void display_object(mdac_object_base *obj) {
        }
        virtual void delete_object(mdac_object_base *obj) {
        }
        virtual bool copy_object(mdac_object_base *obj_dest,mdac_object_base *obj_src) {
                return true;
        }
        virtual mdac_object_base *allocate_mdac_object() {
                return new mdac_object_base;
        }

        
        void display(const char *str,bool is_error=false);
        void execute_command(char *str);
        virtual bool execute_code(char *str) {
                return true;
        }

        virtual void change_working_directory(char *str) {}
        virtual void list_directory(char *pattern) {}
        virtual void create_directory(char *dirname) {}
        virtual void remove_directory(char *dirname) {}
        
        void display_prompt() {
                if (the_shell) the_shell->display_prompt();
        }

        
};

#define MAX_PARAMETERS 100
#define MAX_LIBRARY_FUNCTIONS 500
#define MAX_LIBRARY_DATATYPES 100
#define MAX_ADDITIONAL_OBJECTS 10

typedef mdac_object_base *mdac_object_base_ptr;

class additional_object_list {
public:
        int num_objects;
        mdac_object_base_ptr objects[MAX_ADDITIONAL_OBJECTS];

        additional_object_list() {
                num_objects=0;
        }
        void add_object(mdac_object_base *obj);
};

struct mdac_function_parameter {
        char data_type[20];
        char name[40];
};

typedef mdac_function_parameter *mdac_function_parameter_ptr;

class mdac_library;

class mdac_function {
public:
        char name[100];
        int num_input_params,num_optional_input_params;
        mdac_function_parameter_ptr input_params[MAX_PARAMETERS];
        mdac_function_parameter_ptr optional_input_params[MAX_PARAMETERS];
        mdac_function_parameter output_param;
        long begin_line_number,end_line_number;
        mdac_library *library;

        mdac_object_base_ptr converted_parameters[MAX_PARAMETERS];
        mdac_object_base_ptr optional_converted_parameters[MAX_PARAMETERS];
        bool converted_parameters_allocated;

        mdac_function(mdac_library *library_in);
        virtual ~mdac_function() {
                delete_parameters();
        }
        virtual bool matches(char *function_name,int num_input_params_in,mdac_object_base_ptr *input_params_in);
        virtual bool execute(int num_input_params,mdac_object_base_ptr *input_params,mdac_object_base_ptr output_param,additional_object_list &additional_outputs,bool do_alloc=true) {
                return false;
        }
        mdac_object_base *allocate_mdac_object();

        void delete_parameters();
        void allocate_parameters();
        void allocate_converted_parameters();
        
        bool matches_exact(char *function_name,int num_input_params_in,mdac_object_base_ptr *input_params_in);
        void convert_parameters(int num_input_params_in,mdac_object_base_ptr *input_params_in);
        void clear_converted_parameters(int num_input_params_in,mdac_object_base_ptr *input_params_in);
};

typedef mdac_function *mdac_function_ptr;

class mdac_datatype {
public:
        char name[100];
        mdac_library *library;
        mdac_datatype(mdac_library *library_in);
        virtual bool delete_object(mdac_object_base *ptr);
        virtual bool copy_object(mdac_object_base *dest,mdac_object_base *src);
};

typedef mdac_datatype *mdac_datatype_ptr;

class mdac_library {
public:
        mdac_function_ptr functions[MAX_LIBRARY_FUNCTIONS];
        mdac_datatype_ptr datatypes[MAX_LIBRARY_DATATYPES];
        int num_functions,num_datatypes;
        char library_name[100];
        workspace *WS;

        mdac_library();
        virtual ~mdac_library();

        void add_function(mdac_function *ptr);
        mdac_function *find_function(char *function_name,int num_input_params,mdac_object_base_ptr *input_params);
        mdac_function *find_function_exact(char *function_name,int num_input_params,mdac_object_base_ptr *input_params);
        void add_datatype(mdac_datatype *ptr);
        mdac_datatype *find_datatype(char *datatype_name);
        mdac_function *execute_function(char *function_name,int num_input_params,mdac_object_base_ptr *input_params,mdac_object_base_ptr output_param,
                                                                  additional_object_list &additional_outputs,bool &did_find);
        mdac_function *execute_function_exact(char *function_name,int num_input_params,mdac_object_base_ptr *input_params,mdac_object_base_ptr output_param,
                                                                  additional_object_list &additional_outputs,bool &did_find);

};

typedef mdac_library *mdac_library_ptr;

bool get_real_value(mdac_object_base *obj,real &ret);
bool get_complex_value(mdac_object_base *obj,complex &ret);

integer to_integer(real val);
bool is_integer(real val);




#endif

---