00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef CLIPSENVIRONMENT_H
00020 #define CLIPSENVIRONMENT_H
00021
00022 #include <string>
00023 #include <map>
00024 #include <stdexcept>
00025 #include <map>
00026 #include <queue>
00027
00028 #include <cstdio>
00029
00030 #include <sigc++/sigc++.h>
00031 #include <glibmm.h>
00032
00033 #include <clipsmm/enum.h>
00034 #include <clipsmm/object.h>
00035
00036 #include <clipsmm/activation.h>
00037 #include <clipsmm/defaultfacts.h>
00038 #include <clipsmm/fact.h>
00039 #include <clipsmm/function.h>
00040 #include <clipsmm/global.h>
00041 #include <clipsmm/module.h>
00042 #include <clipsmm/rule.h>
00043 #include <clipsmm/template.h>
00044
00045 #include <clipsmm/utility.h>
00046 #include <clipsmm/any.h>
00047
00048 extern "C" {
00049 int EnvDefineFunction2WithContext( void *, char *, int, int ( * ) ( void * ), char *, char *, void * );
00050 }
00051
00052 namespace CLIPS {
00053
00057 class Environment: public Object {
00058 public:
00059 typedef CLIPSPointer<Environment> pointer;
00060
00061 Environment();
00062
00063 ~Environment();
00064
00069 bool batch_evaluate( const std::string& filename );
00070
00075 bool binary_load( const std::string& filename );
00076
00081 bool binary_save( const std::string& filename );
00082
00087 bool build( const std::string& construct );
00088
00092 void clear( );
00093
00099 Values evaluate( const std::string& expression );
00100
00106 Values function( const std::string& function_name, const std::string& arguments=std::string() );
00107
00119 int load( const std::string& filename );
00120
00124 void reset();
00125
00130 bool save( const std::string& filename );
00131
00138 bool auto_float_dividend_enabled();
00139
00147 bool use_auto_float_dividend( bool use = true );
00148
00155 bool dynamic_constraint_checking_enabled();
00156
00164 bool use_dynamic_constraint_checking( bool use = true );
00165
00172 bool sequence_operator_recognition_enabled();
00173
00181 bool use_sequence_operator_recognition( bool use = true );
00182
00189 bool static_constraint_checking_enabled();
00190
00197 bool use_static_constraint_checking( bool use = true );
00198
00206 bool fact_duplication_enabled();
00207
00214 bool use_fact_duplication( bool use = true );
00215
00216 bool incremental_reset_enabled();
00217
00218 bool use_incremental_reset( bool use = true );
00219
00220 bool global_reset_enable();
00221
00222 bool use_global_reset( bool use=true );
00223
00228 bool is_dribble_active( );
00229
00234 bool dribble_off( );
00235
00240 bool dribble_on( const std::string& dribble_file );
00241
00249 int is_watched( const std::string& item );
00250
00251 bool watch( const std::string& item );
00252
00253 bool unwatch( const std::string& item );
00254
00255 void set_as_current();
00256
00257 Fact::pointer assert_fact( const std::string& factstring );
00258 Fact::pointer assert_fact( Fact::pointer fact );
00259 Fact::pointer assert_fact_f( const char *format, ... );
00260
00261 void clear_focus_stack();
00262
00270 Fact::pointer get_facts();
00271
00272 DefaultFacts::pointer get_default_facts( const std::string& default_facts_name );
00273
00275 std::vector<std::string> get_default_facts_names();
00276
00278 std::vector<std::string> get_default_facts_names( const Module& module );
00279
00281 std::vector<std::string> get_default_facts_names( Module::pointer module );
00282
00283 DefaultFacts::pointer get_default_facts_list_head();
00284
00285 Template::pointer get_template( const std::string& template_name );
00286
00288 std::vector<std::string> get_template_names();
00289
00291 std::vector<std::string> get_template_names( const Module& module );
00292
00294 std::vector<std::string> get_template_names( Module::pointer module );
00295
00296 Template::pointer get_template_list_head();
00297
00298 Rule::pointer get_rule( const std::string& rule_name );
00299
00301 std::vector<std::string> get_rule_names();
00302
00304 std::vector<std::string> get_rule_names( const Module& module );
00305
00307 std::vector<std::string> get_rule_names( Module::pointer module );
00308
00309 Rule::pointer get_rule_list_head();
00310
00311 void remove_rules();
00312
00313 Module::pointer get_module( const std::string& module_name );
00314
00315 Module::pointer get_current_module();
00316
00317 std::vector<std::string> get_module_names();
00318
00319 Module::pointer get_module_list_head();
00320
00326 void refresh_agenda();
00327
00333 void refresh_agenda( const Module& module );
00334
00340 void refresh_agenda( Module::pointer module );
00341
00347 void reorder_agenda();
00348
00354 void reorder_agenda( const Module& module );
00355
00361 void reorder_agenda( Module::pointer module );
00362
00372 long int run( long int runlimit = -1 );
00373
00392 void run_threaded( long int runlimit = -1, int priority = 0 );
00393
00395 void join_run_thread();
00396
00398 sigc::signal<void, long int> signal_run();
00399
00401 SalienceEvaluation get_salience_evaluation();
00402
00407 SalienceEvaluation set_salience_evaluation( SalienceEvaluation se );
00408
00410 ConflictResolution get_conflict_resolution_strategy();
00411
00416 ConflictResolution set_conflict_resolution_strategy( ConflictResolution cr );
00417
00426 bool check_agenda_changed();
00427
00428 Module::pointer get_focused_module();
00429
00430 std::vector<std::string> get_focus_stack();
00431
00432 Activation::pointer get_activation_list_head();
00433
00434 Global::pointer get_global( const std::string& global_name );
00435
00436 Global::pointer get_global_list_head();
00437
00439 std::vector<std::string> get_globals_names();
00440
00442 std::vector<std::string> get_globals_names( const Module& module );
00443
00445 std::vector<std::string> get_globals_names( Module::pointer module );
00446
00447 bool check_globals_changed();
00448
00449 Function::pointer get_function( const std::string& function_name );
00450
00451 Function::pointer get_function_list_head();
00452
00454 std::vector<std::string> get_function_names();
00455
00457 std::vector<std::string> get_function_names( const Module& module );
00458
00460 std::vector<std::string> get_function_names( Module::pointer module );
00461
00462 sigc::signal<void> signal_clear();
00463 sigc::signal<void> signal_periodic();
00464 sigc::signal<void> signal_reset();
00465 sigc::signal<void> signal_rule_firing();
00466 sigc::signal<void> signal_agenda_changed();
00467 sigc::signal<void> signal_globals_changed();
00468
00469 template < typename T_return >
00470 bool add_function( std::string name, const sigc::slot0<T_return>& slot);
00471
00472 template < typename T_return, typename T_arg1 >
00473 bool add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot);
00474
00475 template < typename T_return, typename T_arg1, typename T_arg2 >
00476 bool add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot);
00477
00478 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00479 bool add_function( std::string name, const sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>& slot);
00480
00481 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00482 bool add_function( std::string name, const sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>& slot);
00483
00484 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00485 bool add_function( std::string name, const sigc::slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& slot);
00486
00487 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00488 bool add_function( std::string name, const sigc::slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& slot);
00489
00490 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00491 bool add_function( std::string name, const sigc::slot7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& slot);
00492
00493 bool remove_function( std::string name );
00494
00495 protected:
00502 std::map<std::string,any> m_slots;
00503
00504 sigc::signal<void> m_signal_clear;
00505 sigc::signal<void> m_signal_periodic;
00506 sigc::signal<void> m_signal_reset;
00507 sigc::signal<void> m_signal_rule_firing;
00508 sigc::signal<void> m_signal_agenda_changed;
00509 sigc::signal<void> m_signal_globals_changed;
00510
00512 typedef struct Job {
00514 Job( int p, long int rl ) : priority(p), runlimit(rl) { }
00515
00517 bool operator<( const Job& other ) const { return priority < other.priority; }
00518
00520 int priority;
00521
00526 long int runlimit;
00527 } Job;
00528
00529 Glib::Thread* m_run_thread;
00530 std::priority_queue<Job> m_run_queue;
00531 Glib::Mutex m_mutex_run_queue;
00532 Glib::Mutex m_mutex_run;
00533 Glib::Mutex m_mutex_threaded_run;
00534 Glib::Mutex m_mutex_run_signal;
00535 sigc::signal<void, long int> m_signal_run;
00546 std::map<std::string, char *> m_func_restr;
00547
00549 void threaded_run();
00550
00551 static std::map<void*, Environment*> m_environment_map;
00552
00553
00554 static void clear_callback( void* env );
00555 static void periodic_callback( void* env );
00556 static void reset_callback( void* env );
00557 static void rule_firing_callback( void* end );
00558
00559 static void* strcallback( void* theEnv );
00560
00561 template < typename T_arg1 >
00562 static void* strcallback( void* theEnv );
00563
00564 template < typename T_arg1, typename T_arg2 >
00565 static void* strcallback( void* theEnv );
00566
00567 template < typename T_arg1, typename T_arg2, typename T_arg3 >
00568 static void* strcallback( void* theEnv );
00569
00570 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00571 static void* strcallback( void* theEnv );
00572
00573 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00574 static void* strcallback( void* theEnv );
00575
00576 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00577 static void* strcallback( void* theEnv );
00578
00579 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00580 static void* strcallback( void* theEnv );
00581
00582 template < typename T_return >
00583 static T_return callback( void* theEnv );
00584
00585 template < typename T_return, typename T_arg1 >
00586 static T_return callback( void* theEnv );
00587
00588 template < typename T_return, typename T_arg1, typename T_arg2 >
00589 static T_return callback( void* theEnv );
00590
00591 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00592 static T_return callback( void* theEnv );
00593
00594 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00595 static T_return callback( void* theEnv );
00596
00597 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00598 static T_return callback( void* theEnv );
00599
00600 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00601 static T_return callback( void* theEnv );
00602
00603 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00604 static T_return callback( void* theEnv );
00605
00606 static void callback_multifield( void* theEnv, void *rv);
00607
00608 template <typename T_arg1>
00609 static void callback_multifield( void* theEnv, void *rv );
00610
00611 template <typename T_arg1, typename T_arg2>
00612 static void callback_multifield( void* theEnv, void *rv );
00613
00614 template <typename T_arg1, typename T_arg2, typename T_arg3>
00615 static void callback_multifield( void* theEnv, void *rv );
00616
00617 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00618 static void callback_multifield( void* theEnv, void *rv );
00619
00620 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00621 typename T_arg5>
00622 static void callback_multifield( void* theEnv, void *rv );
00623
00624 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00625 typename T_arg5, typename T_arg6>
00626 static void callback_multifield( void* theEnv, void *rv );
00627
00628 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00629 typename T_arg5, typename T_arg6, typename T_arg7>
00630 static void callback_multifield( void* theEnv, void *rv );
00631
00632
00633 static void callback_unknown( void* theEnv, void *rv);
00634
00635 template <typename T_arg1>
00636 static void callback_unknown( void* theEnv, void *rv );
00637
00638 template <typename T_arg1, typename T_arg2>
00639 static void callback_unknown( void* theEnv, void *rv );
00640
00641 template <typename T_arg1, typename T_arg2, typename T_arg3>
00642 static void callback_unknown( void* theEnv, void *rv );
00643
00644 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00645 static void callback_unknown( void* theEnv, void *rv );
00646
00647 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00648 typename T_arg5>
00649 static void callback_unknown( void* theEnv, void *rv );
00650
00651 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00652 typename T_arg5, typename T_arg6>
00653 static void callback_unknown( void* theEnv, void *rv );
00654
00655 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00656 typename T_arg5, typename T_arg6, typename T_arg7>
00657 static void callback_unknown( void* theEnv, void *rv );
00658
00659 int ( *get_callback( const sigc::slot0<std::string>& slot ))( void* )
00660 { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback; }
00661
00662 template < typename T_arg1 >
00663 int ( *get_callback( const sigc::slot1<std::string,T_arg1>& slot ))( void* )
00664 { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1>; }
00665
00666 template < typename T_arg1, typename T_arg2 >
00667 int ( *get_callback( const sigc::slot2<std::string,T_arg1,T_arg2>& slot ))( void* )
00668 { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1,T_arg2>; }
00669
00670 template < typename T_arg1, typename T_arg2, typename T_arg3 >
00671 int ( *get_callback( const sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00672 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3>; }
00673
00674 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00675 int ( *get_callback( const sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00676 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4>; }
00677
00678 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00679 int ( *get_callback( const sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00680 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00681
00682 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00683 int ( *get_callback( const sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00684 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00685
00686 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00687 int ( *get_callback( const sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00688 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00689
00690 int ( *get_callback( const sigc::slot0<Values>& slot ))( void* )
00691 { return (int (*) (void*)) (void (*) (void*, void*)) callback_multifield; }
00692
00693 template <typename T_arg1>
00694 int ( *get_callback( const sigc::slot1<Values,T_arg1>& slot ))( void* )
00695 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1>; }
00696
00697 template <typename T_arg1, typename T_arg2>
00698 int ( *get_callback( const sigc::slot2<Values,T_arg1,T_arg2>& slot ))( void* )
00699 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2>; }
00700
00701 template <typename T_arg1, typename T_arg2, typename T_arg3>
00702 int ( *get_callback( const sigc::slot3<Values,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00703 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3>; }
00704
00705 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00706 int ( *get_callback( const sigc::slot4<Values,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00707 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4>; }
00708
00709 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00710 int ( *get_callback( const sigc::slot5<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00711 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00712
00713 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00714 int ( *get_callback( const sigc::slot6<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00715 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00716
00717 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00718 int ( *get_callback( const sigc::slot7<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00719 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00720
00721
00722 int ( *get_callback( const sigc::slot0<Value>& slot ))( void* )
00723 { return (int (*) (void*)) (void (*) (void*, void*)) callback_unknown; }
00724
00725 template <typename T_arg1>
00726 int ( *get_callback( const sigc::slot1<Value,T_arg1>& slot ))( void* )
00727 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1>; }
00728
00729 template <typename T_arg1, typename T_arg2>
00730 int ( *get_callback( const sigc::slot2<Value,T_arg1,T_arg2>& slot ))( void* )
00731 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2>; }
00732
00733 template <typename T_arg1, typename T_arg2, typename T_arg3>
00734 int ( *get_callback( const sigc::slot3<Value,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00735 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3>; }
00736
00737 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00738 int ( *get_callback( const sigc::slot4<Value,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00739 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4>; }
00740
00741 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00742 int ( *get_callback( const sigc::slot5<Value,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00743 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00744
00745 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00746 int ( *get_callback( const sigc::slot6<Value,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00747 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00748
00749 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00750 int ( *get_callback( const sigc::slot7<Value,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00751 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00752
00753
00754 template < typename T_return >
00755 int ( *get_callback( const sigc::slot0<T_return>& slot ))( void* )
00756 { return (int (*) (void*)) ( T_return ( * ) ( void* ) ) callback<T_return>; }
00757
00758 template < typename T_return, typename T_arg1 >
00759 int ( *get_callback( const sigc::slot1<T_return,T_arg1>& slot ))( void* )
00760 { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1>; }
00761
00762 template < typename T_return, typename T_arg1, typename T_arg2 >
00763 int ( *get_callback( const sigc::slot2<T_return,T_arg1,T_arg2>& slot ))( void* )
00764 { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1,T_arg2>; }
00765
00766 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00767 int ( *get_callback( const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00768 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3>; }
00769
00770 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00771 int ( *get_callback( const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00772 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4>; }
00773
00774 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00775 int ( *get_callback( const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00776 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00777
00778 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00779 int ( *get_callback( const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00780 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00781
00782 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00783 int ( *get_callback( const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00784 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00785
00786 char * get_function_restriction(std::string &name);
00787
00788 template <typename T_arg1>
00789 char * get_function_restriction(std::string &name);
00790
00791 template <typename T_arg1, typename T_arg2>
00792 char * get_function_restriction(std::string &name);
00793
00794 template <typename T_arg1, typename T_arg2, typename T_arg3>
00795 char * get_function_restriction(std::string &name);
00796
00797 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00798 char * get_function_restriction(std::string &name);
00799
00800 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00801 char * get_function_restriction(std::string &name);
00802
00803 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00804 char * get_function_restriction(std::string &name);
00805
00806 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00807 char * get_function_restriction(std::string &name);
00808
00809
00810 static int get_arg_count( void* env );
00811 static void* get_function_context( void* env );
00812 static void set_return_values( void *env, void *rv, const Values &v);
00813 static void set_return_value( void *env, void *rv, const Value &v);
00814 static void* add_symbol( const char* s );
00815
00816
00817 };
00818
00819
00820 inline char *
00821 Environment::get_function_restriction(std::string &name) {
00822 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00823 char *restr = (char *)malloc(4); m_func_restr[name] = restr;
00824 snprintf(restr, 4, "00u");
00825 return restr;
00826 }
00827
00828 template <typename T_arg1>
00829 inline char *
00830 Environment::get_function_restriction(std::string &name) {
00831 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00832 char *restr = (char *)malloc(5); m_func_restr[name] = restr;
00833 snprintf(restr, 5, "11u%c", get_argument_code<T_arg1>());
00834 return restr;
00835 }
00836
00837 template <typename T_arg1, typename T_arg2>
00838 inline char *
00839 Environment::get_function_restriction(std::string &name) {
00840 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00841 char *restr = (char *)malloc(6); m_func_restr[name] = restr;
00842 snprintf(restr, 6, "22u%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>());
00843 return restr;
00844 }
00845
00846 template <typename T_arg1, typename T_arg2, typename T_arg3>
00847 inline char *
00848 Environment::get_function_restriction(std::string &name) {
00849 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00850 char *restr = (char *)malloc(7); m_func_restr[name] = restr;
00851 snprintf(restr, 7, "33u%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00852 get_argument_code<T_arg3>());
00853 return restr;
00854 }
00855
00856 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00857 inline char *
00858 Environment::get_function_restriction(std::string &name) {
00859 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00860 char *restr = (char *)malloc(8); m_func_restr[name] = restr;
00861 snprintf(restr, 8, "44u%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00862 get_argument_code<T_arg3>(), get_argument_code<T_arg4>());
00863 return restr;
00864 }
00865
00866 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00867 typename T_arg5>
00868 inline char *
00869 Environment::get_function_restriction(std::string &name) {
00870 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00871 char *restr = (char *)malloc(9); m_func_restr[name] = restr;
00872 snprintf(restr, 9, "55u%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00873 get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>());
00874 return restr;
00875 }
00876
00877 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00878 typename T_arg5, typename T_arg6>
00879 inline char *
00880 Environment::get_function_restriction(std::string &name) {
00881 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00882 char *restr = (char *)malloc(10); m_func_restr[name] = restr;
00883 snprintf(restr, 10, "66u%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00884 get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>(),
00885 get_argument_code<T_arg6>());
00886 return restr;
00887 }
00888
00889 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00890 typename T_arg5, typename T_arg6, typename T_arg7>
00891 inline char *
00892 Environment::get_function_restriction(std::string &name) {
00893 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00894 char *restr = (char *)malloc(11); m_func_restr[name] = restr;
00895 snprintf(restr, 11, "77u%c%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00896 get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>(),
00897 get_argument_code<T_arg6>(), get_argument_code<T_arg7>());
00898 return restr;
00899 }
00900
00901
00902 template < typename T_return>
00903 inline
00904 T_return Environment::callback( void* theEnv ) {
00905 sigc::slot0<T_return>* cb;
00906 void * cbptr = get_function_context( theEnv );
00907 if ( cbptr ) {
00908 if ( get_arg_count( theEnv ) != 0 )
00909 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 0" );
00910 cb = static_cast<sigc::slot0<T_return>*>( cbptr );
00911 return ( *cb ) ();
00912 }
00913 throw;
00914 }
00915
00916 template < typename T_return, typename T_arg1 >
00917 inline
00918 T_return Environment::callback( void* theEnv ) {
00919 sigc::slot1<T_return,T_arg1>* cb;
00920 void * cbptr = get_function_context( theEnv );
00921 T_arg1 arg1;
00922 if ( cbptr ) {
00923 if ( get_arg_count( theEnv ) != 1 )
00924 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
00925 get_argument( theEnv, 1, arg1 );
00926 cb = static_cast<sigc::slot1<T_return,T_arg1>*>( cbptr );
00927 return ( *cb ) ( arg1 );
00928 }
00929 throw;
00930 }
00931
00932 template < typename T_return, typename T_arg1, typename T_arg2 >
00933 inline
00934 T_return Environment::callback( void* theEnv ) {
00935 sigc::slot2<T_return, T_arg1, T_arg2>* cb;
00936 void * cbptr = get_function_context( theEnv );
00937 T_arg1 arg1;
00938 T_arg2 arg2;
00939 if ( cbptr ) {
00940 if ( get_arg_count( theEnv ) != 2 )
00941 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
00942 get_argument( theEnv, 1, arg1 );
00943 get_argument( theEnv, 2, arg2 );
00944 cb = static_cast<sigc::slot2<T_return, T_arg1, T_arg2>*>( cbptr );
00945 return ( *cb ) ( arg1, arg2 );
00946 }
00947 throw;
00948 }
00949
00950 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00951 inline
00952 T_return Environment::callback( void* theEnv ) {
00953 sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* cb;
00954 void * cbptr = get_function_context( theEnv );
00955 T_arg1 arg1;
00956 T_arg2 arg2;
00957 T_arg3 arg3;
00958 if ( cbptr ) {
00959 if ( get_arg_count( theEnv ) != 3 )
00960 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
00961 get_argument( theEnv, 1, arg1 );
00962 get_argument( theEnv, 2, arg2 );
00963 get_argument( theEnv, 3, arg3 );
00964 cb = static_cast<sigc::slot3<T_return, T_arg1, T_arg2,T_arg3>*>( cbptr );
00965 return ( *cb ) ( arg1, arg2, arg3 );
00966 }
00967 throw;
00968 }
00969
00970 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00971 inline
00972 T_return Environment::callback( void* theEnv ) {
00973 sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
00974 void * cbptr = get_function_context( theEnv );
00975 T_arg1 arg1;
00976 T_arg2 arg2;
00977 T_arg3 arg3;
00978 T_arg4 arg4;
00979 if ( cbptr ) {
00980 if ( get_arg_count( theEnv ) != 4 )
00981 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
00982 get_argument( theEnv, 1, arg1 );
00983 get_argument( theEnv, 2, arg2 );
00984 get_argument( theEnv, 3, arg3 );
00985 get_argument( theEnv, 4, arg4 );
00986 cb = static_cast<sigc::slot4<T_return, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
00987 return ( *cb ) ( arg1, arg2, arg3, arg4 );
00988 }
00989 throw;
00990 }
00991
00992 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00993 inline
00994 T_return Environment::callback( void* theEnv ) {
00995 sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
00996 void * cbptr = get_function_context( theEnv );
00997 T_arg1 arg1;
00998 T_arg2 arg2;
00999 T_arg3 arg3;
01000 T_arg4 arg4;
01001 T_arg5 arg5;
01002 if ( cbptr ) {
01003 if ( get_arg_count( theEnv ) != 5 )
01004 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
01005 get_argument( theEnv, 1, arg1 );
01006 get_argument( theEnv, 2, arg2 );
01007 get_argument( theEnv, 3, arg3 );
01008 get_argument( theEnv, 4, arg4 );
01009 get_argument( theEnv, 5, arg5 );
01010 cb = static_cast<sigc::slot5<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
01011 return ( *cb ) ( arg1, arg2, arg3, arg4, arg5 );
01012 }
01013 throw;
01014 }
01015
01016 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
01017 inline
01018 T_return Environment::callback( void* theEnv ) {
01019 sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
01020 void * cbptr = get_function_context( theEnv );
01021 T_arg1 arg1;
01022 T_arg2 arg2;
01023 T_arg3 arg3;
01024 T_arg4 arg4;
01025 T_arg5 arg5;
01026 T_arg6 arg6;
01027 if ( cbptr ) {
01028 if ( get_arg_count( theEnv ) != 6 )
01029 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
01030 get_argument( theEnv, 1, arg1 );
01031 get_argument( theEnv, 2, arg2 );
01032 get_argument( theEnv, 3, arg3 );
01033 get_argument( theEnv, 4, arg4 );
01034 get_argument( theEnv, 5, arg5 );
01035 get_argument( theEnv, 6, arg6 );
01036 cb = static_cast<sigc::slot6<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
01037 return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 );
01038 }
01039 throw;
01040 }
01041
01042 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
01043 inline
01044 T_return Environment::callback( void* theEnv ) {
01045 sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
01046 void * cbptr = get_function_context( theEnv );
01047 T_arg1 arg1;
01048 T_arg2 arg2;
01049 T_arg3 arg3;
01050 T_arg4 arg4;
01051 T_arg5 arg5;
01052 T_arg6 arg6;
01053 T_arg7 arg7;
01054 if ( cbptr ) {
01055 if ( get_arg_count( theEnv ) != 7 )
01056 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
01057 get_argument( theEnv, 1, arg1 );
01058 get_argument( theEnv, 2, arg2 );
01059 get_argument( theEnv, 3, arg3 );
01060 get_argument( theEnv, 4, arg4 );
01061 get_argument( theEnv, 5, arg5 );
01062 get_argument( theEnv, 6, arg6 );
01063 get_argument( theEnv, 7, arg7 );
01064 cb = static_cast<sigc::slot7<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
01065 return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 );
01066 }
01067 throw;
01068 }
01069
01070 inline
01071 void Environment::callback_multifield( void* theEnv, void *rv) {
01072 sigc::slot0<Values>* cb;
01073 void * cbptr = get_function_context( theEnv );
01074 if ( cbptr ) {
01075 if ( get_arg_count( theEnv ) != 0 )
01076 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 0" );
01077 cb = static_cast<sigc::slot0<Values>*>( cbptr );
01078 Values v = ( *cb ) ();
01079 set_return_values(theEnv, rv, v);
01080 return;
01081 }
01082 throw;
01083 }
01084
01085 template <typename T_arg1>
01086 inline
01087 void Environment::callback_multifield( void* theEnv, void *rv) {
01088 sigc::slot1<Values, T_arg1>* cb;
01089 void * cbptr = get_function_context( theEnv );
01090 T_arg1 arg1;
01091 if ( cbptr ) {
01092 if ( get_arg_count( theEnv ) != 1 )
01093 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 1" );
01094 cb = static_cast<sigc::slot1<Values, T_arg1>*>( cbptr );
01095 get_argument(theEnv, 1, arg1);
01096 Values v = ( *cb ) (arg1);
01097 set_return_values(theEnv, rv, v);
01098 return;
01099 }
01100 throw;
01101 }
01102
01103 template <typename T_arg1, typename T_arg2>
01104 inline
01105 void Environment::callback_multifield( void* theEnv, void *rv) {
01106 sigc::slot2<Values, T_arg1, T_arg2>* cb;
01107 void * cbptr = get_function_context( theEnv );
01108 T_arg1 arg1;
01109 T_arg2 arg2;
01110 if ( cbptr ) {
01111 if ( get_arg_count( theEnv ) != 2 )
01112 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 2" );
01113 cb = static_cast<sigc::slot2<Values, T_arg1, T_arg2>*>( cbptr );
01114 get_argument(theEnv, 1, arg1);
01115 get_argument(theEnv, 2, arg2);
01116 Values v = ( *cb ) (arg1, arg2);
01117 set_return_values(theEnv, rv, v);
01118 return;
01119 }
01120 throw;
01121 }
01122
01123
01124 template <typename T_arg1, typename T_arg2, typename T_arg3>
01125 inline
01126 void Environment::callback_multifield( void* theEnv, void *rv) {
01127 sigc::slot3<Values, T_arg1, T_arg2, T_arg3>* cb;
01128 void * cbptr = get_function_context( theEnv );
01129 T_arg1 arg1;
01130 T_arg2 arg2;
01131 T_arg3 arg3;
01132 if ( cbptr ) {
01133 if ( get_arg_count( theEnv ) != 3 )
01134 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 3" );
01135 cb = static_cast<sigc::slot3<Values, T_arg1, T_arg2, T_arg3>*>( cbptr );
01136 get_argument(theEnv, 1, arg1);
01137 get_argument(theEnv, 2, arg2);
01138 get_argument(theEnv, 3, arg3);
01139 Values v = ( *cb ) (arg1, arg2, arg3);
01140 set_return_values(theEnv, rv, v);
01141 return;
01142 }
01143 throw;
01144 }
01145
01146 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
01147 inline
01148 void Environment::callback_multifield( void* theEnv, void *rv) {
01149 sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>* cb;
01150 void * cbptr = get_function_context( theEnv );
01151 T_arg1 arg1;
01152 T_arg2 arg2;
01153 T_arg3 arg3;
01154 T_arg4 arg4;
01155 if ( cbptr ) {
01156 if ( get_arg_count( theEnv ) != 4 )
01157 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 4" );
01158 cb = static_cast<sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>*>(cbptr);
01159 get_argument(theEnv, 1, arg1);
01160 get_argument(theEnv, 2, arg2);
01161 get_argument(theEnv, 3, arg3);
01162 get_argument(theEnv, 4, arg4);
01163 Values v = ( *cb ) (arg1, arg2, arg3, arg4);
01164 set_return_values(theEnv, rv, v);
01165 return;
01166 }
01167 throw;
01168 }
01169
01170 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01171 typename T_arg5>
01172 inline
01173 void Environment::callback_multifield( void* theEnv, void *rv) {
01174 sigc::slot5<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* cb;
01175 void * cbptr = get_function_context( theEnv );
01176 T_arg1 arg1;
01177 T_arg2 arg2;
01178 T_arg3 arg3;
01179 T_arg4 arg4;
01180 T_arg5 arg5;
01181 if ( cbptr ) {
01182 if ( get_arg_count( theEnv ) != 5 )
01183 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 5" );
01184 cb = static_cast<sigc::slot5<Values, T_arg1, T_arg2, T_arg3,
01185 T_arg4, T_arg5>*>(cbptr);
01186 get_argument(theEnv, 1, arg1);
01187 get_argument(theEnv, 2, arg2);
01188 get_argument(theEnv, 3, arg3);
01189 get_argument(theEnv, 4, arg4);
01190 get_argument(theEnv, 5, arg5);
01191 Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5);
01192 set_return_values(theEnv, rv, v);
01193 return;
01194 }
01195 throw;
01196 }
01197
01198
01199 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01200 typename T_arg5, typename T_arg6>
01201 inline
01202 void Environment::callback_multifield( void* theEnv, void *rv) {
01203 sigc::slot6<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* cb;
01204 void * cbptr = get_function_context( theEnv );
01205 T_arg1 arg1;
01206 T_arg2 arg2;
01207 T_arg3 arg3;
01208 T_arg4 arg4;
01209 T_arg5 arg5;
01210 T_arg6 arg6;
01211 if ( cbptr ) {
01212 if ( get_arg_count( theEnv ) != 6 )
01213 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 6" );
01214 cb = static_cast<sigc::slot6<Values, T_arg1, T_arg2, T_arg3,
01215 T_arg4, T_arg5, T_arg6>*>(cbptr);
01216 get_argument(theEnv, 1, arg1);
01217 get_argument(theEnv, 2, arg2);
01218 get_argument(theEnv, 3, arg3);
01219 get_argument(theEnv, 4, arg4);
01220 get_argument(theEnv, 5, arg5);
01221 get_argument(theEnv, 6, arg6);
01222 Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6);
01223 set_return_values(theEnv, rv, v);
01224 return;
01225 }
01226 throw;
01227 }
01228
01229 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01230 typename T_arg5, typename T_arg6, typename T_arg7>
01231 inline
01232 void Environment::callback_multifield( void* theEnv, void *rv) {
01233 sigc::slot7<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* cb;
01234 void * cbptr = get_function_context( theEnv );
01235 T_arg1 arg1;
01236 T_arg2 arg2;
01237 T_arg3 arg3;
01238 T_arg4 arg4;
01239 T_arg5 arg5;
01240 T_arg6 arg6;
01241 T_arg7 arg7;
01242 if ( cbptr ) {
01243 if ( get_arg_count( theEnv ) != 7 )
01244 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 7" );
01245 cb = static_cast<sigc::slot7<Values, T_arg1, T_arg2, T_arg3,
01246 T_arg4, T_arg5, T_arg6, T_arg7>*>(cbptr);
01247 get_argument(theEnv, 1, arg1);
01248 get_argument(theEnv, 2, arg2);
01249 get_argument(theEnv, 3, arg3);
01250 get_argument(theEnv, 4, arg4);
01251 get_argument(theEnv, 5, arg5);
01252 get_argument(theEnv, 6, arg6);
01253 get_argument(theEnv, 7, arg7);
01254 Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6, arg7);
01255 set_return_values(theEnv, rv, v);
01256 return;
01257 }
01258 throw;
01259 }
01260
01261
01262
01263
01264 inline
01265 void Environment::callback_unknown( void* theEnv, void *rv) {
01266 sigc::slot0<Value>* cb;
01267 void * cbptr = get_function_context( theEnv );
01268 if ( cbptr ) {
01269 if ( get_arg_count( theEnv ) != 0 )
01270 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 0" );
01271 cb = static_cast<sigc::slot0<Value>*>( cbptr );
01272 Value v = ( *cb ) ();
01273 set_return_value(theEnv, rv, v);
01274 return;
01275 }
01276 throw;
01277 }
01278
01279 template <typename T_arg1>
01280 inline
01281 void Environment::callback_unknown( void* theEnv, void *rv) {
01282 sigc::slot1<Value, T_arg1>* cb;
01283 void * cbptr = get_function_context( theEnv );
01284 T_arg1 arg1;
01285 if ( cbptr ) {
01286 if ( get_arg_count( theEnv ) != 1 )
01287 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 1" );
01288 cb = static_cast<sigc::slot1<Value, T_arg1>*>( cbptr );
01289 get_argument(theEnv, 1, arg1);
01290 Value v = ( *cb ) (arg1);
01291 set_return_value(theEnv, rv, v);
01292 return;
01293 }
01294 throw;
01295 }
01296
01297 template <typename T_arg1, typename T_arg2>
01298 inline
01299 void Environment::callback_unknown( void* theEnv, void *rv) {
01300 sigc::slot2<Value, T_arg1, T_arg2>* cb;
01301 void * cbptr = get_function_context( theEnv );
01302 T_arg1 arg1;
01303 T_arg2 arg2;
01304 if ( cbptr ) {
01305 if ( get_arg_count( theEnv ) != 2 )
01306 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 2" );
01307 cb = static_cast<sigc::slot2<Value, T_arg1, T_arg2>*>( cbptr );
01308 get_argument(theEnv, 1, arg1);
01309 get_argument(theEnv, 2, arg2);
01310 Value v = ( *cb ) (arg1, arg2);
01311 set_return_value(theEnv, rv, v);
01312 return;
01313 }
01314 throw;
01315 }
01316
01317
01318 template <typename T_arg1, typename T_arg2, typename T_arg3>
01319 inline
01320 void Environment::callback_unknown( void* theEnv, void *rv) {
01321 sigc::slot3<Value, T_arg1, T_arg2, T_arg3>* cb;
01322 void * cbptr = get_function_context( theEnv );
01323 T_arg1 arg1;
01324 T_arg2 arg2;
01325 T_arg3 arg3;
01326 if ( cbptr ) {
01327 if ( get_arg_count( theEnv ) != 3 )
01328 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 3" );
01329 cb = static_cast<sigc::slot3<Value, T_arg1, T_arg2, T_arg3>*>( cbptr );
01330 get_argument(theEnv, 1, arg1);
01331 get_argument(theEnv, 2, arg2);
01332 get_argument(theEnv, 3, arg3);
01333 Value v = ( *cb ) (arg1, arg2, arg3);
01334 set_return_value(theEnv, rv, v);
01335 return;
01336 }
01337 throw;
01338 }
01339
01340 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
01341 inline
01342 void Environment::callback_unknown( void* theEnv, void *rv) {
01343 sigc::slot4<Value, T_arg1, T_arg2, T_arg3, T_arg4>* cb;
01344 void * cbptr = get_function_context( theEnv );
01345 T_arg1 arg1;
01346 T_arg2 arg2;
01347 T_arg3 arg3;
01348 T_arg4 arg4;
01349 if ( cbptr ) {
01350 if ( get_arg_count( theEnv ) != 4 )
01351 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 4" );
01352 cb = static_cast<sigc::slot4<Value, T_arg1, T_arg2, T_arg3, T_arg4>*>(cbptr);
01353 get_argument(theEnv, 1, arg1);
01354 get_argument(theEnv, 2, arg2);
01355 get_argument(theEnv, 3, arg3);
01356 get_argument(theEnv, 4, arg4);
01357 Value v = ( *cb ) (arg1, arg2, arg3, arg4);
01358 set_return_value(theEnv, rv, v);
01359 return;
01360 }
01361 throw;
01362 }
01363
01364 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01365 typename T_arg5>
01366 inline
01367 void Environment::callback_unknown( void* theEnv, void *rv) {
01368 sigc::slot5<Value, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* cb;
01369 void * cbptr = get_function_context( theEnv );
01370 T_arg1 arg1;
01371 T_arg2 arg2;
01372 T_arg3 arg3;
01373 T_arg4 arg4;
01374 T_arg5 arg5;
01375 if ( cbptr ) {
01376 if ( get_arg_count( theEnv ) != 5 )
01377 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 5" );
01378 cb = static_cast<sigc::slot5<Value, T_arg1, T_arg2, T_arg3,
01379 T_arg4, T_arg5>*>(cbptr);
01380 get_argument(theEnv, 1, arg1);
01381 get_argument(theEnv, 2, arg2);
01382 get_argument(theEnv, 3, arg3);
01383 get_argument(theEnv, 4, arg4);
01384 get_argument(theEnv, 5, arg5);
01385 Value v = ( *cb ) (arg1, arg2, arg3, arg4, arg5);
01386 set_return_value(theEnv, rv, v);
01387 return;
01388 }
01389 throw;
01390 }
01391
01392
01393 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01394 typename T_arg5, typename T_arg6>
01395 inline
01396 void Environment::callback_unknown( void* theEnv, void *rv) {
01397 sigc::slot6<Value, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* cb;
01398 void * cbptr = get_function_context( theEnv );
01399 T_arg1 arg1;
01400 T_arg2 arg2;
01401 T_arg3 arg3;
01402 T_arg4 arg4;
01403 T_arg5 arg5;
01404 T_arg6 arg6;
01405 if ( cbptr ) {
01406 if ( get_arg_count( theEnv ) != 6 )
01407 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 6" );
01408 cb = static_cast<sigc::slot6<Value, T_arg1, T_arg2, T_arg3,
01409 T_arg4, T_arg5, T_arg6>*>(cbptr);
01410 get_argument(theEnv, 1, arg1);
01411 get_argument(theEnv, 2, arg2);
01412 get_argument(theEnv, 3, arg3);
01413 get_argument(theEnv, 4, arg4);
01414 get_argument(theEnv, 5, arg5);
01415 get_argument(theEnv, 6, arg6);
01416 Value v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6);
01417 set_return_value(theEnv, rv, v);
01418 return;
01419 }
01420 throw;
01421 }
01422
01423 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01424 typename T_arg5, typename T_arg6, typename T_arg7>
01425 inline
01426 void Environment::callback_unknown( void* theEnv, void *rv) {
01427 sigc::slot7<Value, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* cb;
01428 void * cbptr = get_function_context( theEnv );
01429 T_arg1 arg1;
01430 T_arg2 arg2;
01431 T_arg3 arg3;
01432 T_arg4 arg4;
01433 T_arg5 arg5;
01434 T_arg6 arg6;
01435 T_arg7 arg7;
01436 if ( cbptr ) {
01437 if ( get_arg_count( theEnv ) != 7 )
01438 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 7" );
01439 cb = static_cast<sigc::slot7<Value, T_arg1, T_arg2, T_arg3,
01440 T_arg4, T_arg5, T_arg6, T_arg7>*>(cbptr);
01441 get_argument(theEnv, 1, arg1);
01442 get_argument(theEnv, 2, arg2);
01443 get_argument(theEnv, 3, arg3);
01444 get_argument(theEnv, 4, arg4);
01445 get_argument(theEnv, 5, arg5);
01446 get_argument(theEnv, 6, arg6);
01447 get_argument(theEnv, 7, arg7);
01448 Value v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6, arg7);
01449 set_return_value(theEnv, rv, v);
01450 return;
01451 }
01452 throw;
01453 }
01454
01455
01456
01457
01458 inline
01459 void* Environment::strcallback( void* theEnv ) {
01460 sigc::slot0<std::string>* cb;
01461 void * cbptr = get_function_context( theEnv );
01462 if ( cbptr ) {
01463 if ( get_arg_count( theEnv ) != 0 )
01464 throw std::logic_error( "clipsmm/string: wrong # args on slot callback; expected 0" );
01465 cb = static_cast<sigc::slot0<std::string>*>( cbptr );
01466 return add_symbol( ( ( *cb ) ( )).c_str() );
01467 }
01468 throw;
01469 }
01470
01471 template < typename T_arg1 >
01472 inline
01473 void* Environment::strcallback( void* theEnv ) {
01474 sigc::slot1<std::string,T_arg1>* cb;
01475 void * cbptr = get_function_context( theEnv );
01476 T_arg1 arg1;
01477 if ( cbptr ) {
01478 if ( get_arg_count( theEnv ) != 1 )
01479 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
01480 get_argument( theEnv, 1, arg1 );
01481 cb = static_cast<sigc::slot1<std::string,T_arg1>*>( cbptr );
01482 return add_symbol( ( ( *cb ) ( arg1 )).c_str() );
01483 }
01484 throw;
01485 }
01486
01487 template < typename T_arg1, typename T_arg2 >
01488 inline
01489 void* Environment::strcallback( void* theEnv ) {
01490 sigc::slot2<std::string, T_arg1, T_arg2>* cb;
01491 void * cbptr = get_function_context( theEnv );
01492 T_arg1 arg1;
01493 T_arg2 arg2;
01494 if ( cbptr ) {
01495 if ( get_arg_count( theEnv ) != 2 )
01496 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
01497 get_argument( theEnv, 1, arg1 );
01498 get_argument( theEnv, 2, arg2 );
01499 cb = static_cast<sigc::slot2<std::string, T_arg1, T_arg2>*>( cbptr );
01500 return add_symbol( ( ( *cb ) ( arg1, arg2 )).c_str() );
01501 }
01502 throw;
01503 }
01504
01505 template < typename T_arg1, typename T_arg2, typename T_arg3 >
01506 inline
01507 void* Environment::strcallback( void* theEnv ) {
01508 sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>* cb;
01509 void * cbptr = get_function_context( theEnv );
01510 T_arg1 arg1;
01511 T_arg2 arg2;
01512 T_arg3 arg3;
01513 if ( cbptr ) {
01514 if ( get_arg_count( theEnv ) != 3 )
01515 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
01516 get_argument( theEnv, 1, arg1 );
01517 get_argument( theEnv, 2, arg2 );
01518 get_argument( theEnv, 3, arg3 );
01519 cb = static_cast<sigc::slot3<std::string, T_arg1, T_arg2,T_arg3>*>( cbptr );
01520 return add_symbol( ( ( *cb ) ( arg1, arg2, arg3 )).c_str() );
01521 }
01522 throw;
01523 }
01524
01525 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
01526 inline
01527 void* Environment::strcallback( void* theEnv ) {
01528 sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
01529 void * cbptr = get_function_context( theEnv );
01530 T_arg1 arg1;
01531 T_arg2 arg2;
01532 T_arg3 arg3;
01533 T_arg4 arg4;
01534 std::string s;
01535 if ( cbptr ) {
01536 if ( get_arg_count( theEnv ) != 4 )
01537 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
01538 get_argument( theEnv, 1, arg1 );
01539 get_argument( theEnv, 2, arg2 );
01540 get_argument( theEnv, 3, arg3 );
01541 get_argument( theEnv, 4, arg4 );
01542 cb = static_cast<sigc::slot4<std::string, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
01543 s = ( *cb ) ( arg1, arg2, arg3, arg4 );
01544 return add_symbol( s.c_str() );
01545 }
01546 throw;
01547 }
01548
01549 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
01550 inline
01551 void* Environment::strcallback( void* theEnv ) {
01552 sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
01553 void * cbptr = get_function_context( theEnv );
01554 T_arg1 arg1;
01555 T_arg2 arg2;
01556 T_arg3 arg3;
01557 T_arg4 arg4;
01558 T_arg5 arg5;
01559 if ( cbptr ) {
01560 if ( get_arg_count( theEnv ) != 5 )
01561 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
01562 get_argument( theEnv, 1, arg1 );
01563 get_argument( theEnv, 2, arg2 );
01564 get_argument( theEnv, 3, arg3 );
01565 get_argument( theEnv, 4, arg4 );
01566 get_argument( theEnv, 5, arg5 );
01567 cb = static_cast<sigc::slot5<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
01568 return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5 )).c_str() );
01569 }
01570 throw;
01571 }
01572
01573 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
01574 inline
01575 void* Environment::strcallback( void* theEnv ) {
01576 sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
01577 void * cbptr = get_function_context( theEnv );
01578 T_arg1 arg1;
01579 T_arg2 arg2;
01580 T_arg3 arg3;
01581 T_arg4 arg4;
01582 T_arg5 arg5;
01583 T_arg6 arg6;
01584 if ( cbptr ) {
01585 if ( get_arg_count( theEnv ) != 6 )
01586 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
01587 get_argument( theEnv, 1, arg1 );
01588 get_argument( theEnv, 2, arg2 );
01589 get_argument( theEnv, 3, arg3 );
01590 get_argument( theEnv, 4, arg4 );
01591 get_argument( theEnv, 5, arg5 );
01592 get_argument( theEnv, 6, arg6 );
01593 cb = static_cast<sigc::slot6<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
01594 return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 )).c_str() );
01595 }
01596 throw;
01597 }
01598
01599 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
01600 inline
01601 void* Environment::strcallback( void* theEnv ) {
01602 sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
01603 void * cbptr = get_function_context( theEnv );
01604 T_arg1 arg1;
01605 T_arg2 arg2;
01606 T_arg3 arg3;
01607 T_arg4 arg4;
01608 T_arg5 arg5;
01609 T_arg6 arg6;
01610 T_arg7 arg7;
01611 if ( cbptr ) {
01612 if ( get_arg_count( theEnv ) != 7 )
01613 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
01614 get_argument( theEnv, 1, arg1 );
01615 get_argument( theEnv, 2, arg2 );
01616 get_argument( theEnv, 3, arg3 );
01617 get_argument( theEnv, 4, arg4 );
01618 get_argument( theEnv, 5, arg5 );
01619 get_argument( theEnv, 6, arg6 );
01620 get_argument( theEnv, 7, arg7 );
01621 cb = static_cast<sigc::slot7<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
01622 return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 )).c_str() );
01623 }
01624 throw;
01625 }
01626
01627 template < typename T_return >
01628 inline
01629 bool Environment::add_function( std::string name, const sigc::slot0<T_return>& slot) {
01630 char retcode = get_return_code<T_return>( );
01631 char *argstring = get_function_restriction(name);
01632 sigc::slot0<T_return>* scb = new sigc::slot0<T_return>(slot);
01633 any holder = CLIPSPointer<sigc::slot0<T_return> >(scb);
01634 m_slots[name] = holder;
01635 return ( EnvDefineFunction2WithContext( m_cobj,
01636 const_cast<char*>( name.c_str() ),
01637 retcode,
01638 get_callback(slot),
01639 const_cast<char*>( name.c_str() ),
01640 argstring,
01641 ( void* ) scb ) );
01642 }
01643
01644 template < typename T_return, typename T_arg1 >
01645 inline
01646 bool Environment::add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot) {
01647 char retcode = get_return_code<T_return>( );
01648 char *argstring = get_function_restriction<T_arg1>(name);
01649 sigc::slot1<T_return, T_arg1>* scb = new sigc::slot1<T_return, T_arg1>(slot);
01650 any holder = CLIPSPointer<sigc::slot1<T_return, T_arg1> >(scb);
01651 m_slots[name] = holder;
01652 return ( EnvDefineFunction2WithContext( m_cobj,
01653 const_cast<char*>( name.c_str() ),
01654 retcode,
01655 get_callback(slot),
01656 const_cast<char*>( name.c_str() ),
01657 argstring,
01658 scb ) );
01659 }
01660
01661 template < typename T_return, typename T_arg1, typename T_arg2 >
01662 inline
01663 bool Environment::add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot) {
01664 char retcode = get_return_code<T_return>( );
01665 char *argstring = get_function_restriction<T_arg1,T_arg2>(name);
01666 sigc::slot2<T_return, T_arg1, T_arg2>* scb = new sigc::slot2<T_return, T_arg1, T_arg2>(slot);
01667 any holder = CLIPSPointer<sigc::slot2<T_return, T_arg1, T_arg2> >(scb);
01668 m_slots[name] = holder;
01669 return ( EnvDefineFunction2WithContext( m_cobj,
01670 const_cast<char*>( name.c_str() ),
01671 retcode,
01672 get_callback(slot),
01673 const_cast<char*>( name.c_str() ),
01674 argstring,
01675 scb ) );
01676 }
01677
01678 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
01679 inline
01680 bool Environment::add_function( std::string name, const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot) {
01681 char retcode = get_return_code<T_return>( );
01682 char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3>(name);
01683 sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* scb =
01684 new sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>(slot);
01685 any holder = CLIPSPointer<sigc::slot3<T_return,T_arg1,T_arg2,T_arg3> >(scb);
01686 m_slots[name] = holder;
01687 return ( EnvDefineFunction2WithContext( m_cobj,
01688 const_cast<char*>( name.c_str() ),
01689 retcode,
01690 get_callback(slot),
01691 const_cast<char*>( name.c_str() ),
01692 argstring,
01693 scb )
01694 );
01695 }
01696
01697 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
01698 inline
01699 bool Environment::add_function( std::string name, const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot) {
01700 char retcode = get_return_code<T_return>( );
01701 char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4>(name);
01702 sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* scb =
01703 new sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>(slot);
01704 any holder = CLIPSPointer<sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4> >(scb);
01705 m_slots[name] = holder;
01706 return ( EnvDefineFunction2WithContext( m_cobj,
01707 const_cast<char*>( name.c_str() ),
01708 retcode,
01709 get_callback(slot),
01710 const_cast<char*>( name.c_str() ),
01711 argstring,
01712 scb )
01713 );
01714 }
01715
01716 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
01717 inline
01718 bool Environment::add_function( std::string name,
01719 const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot) {
01720 char retcode = get_return_code<T_return>( );
01721 char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(name);
01722 sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* scb =
01723 new sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(slot);
01724 any holder = CLIPSPointer<sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> >(scb);
01725 m_slots[name] = holder;
01726 return ( EnvDefineFunction2WithContext( m_cobj,
01727 const_cast<char*>( name.c_str() ),
01728 retcode,
01729 get_callback(slot),
01730 const_cast<char*>( name.c_str() ),
01731 argstring,
01732 scb )
01733 );
01734 }
01735
01736 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
01737 inline
01738 bool Environment::add_function( std::string name,
01739 const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot) {
01740 char retcode = get_return_code<T_return>( );
01741 char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(name);
01742 sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* scb =
01743 new sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(slot);
01744 any holder = CLIPSPointer<sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> >(scb);
01745 m_slots[name] = holder;
01746 return ( EnvDefineFunction2WithContext( m_cobj,
01747 const_cast<char*>( name.c_str() ),
01748 retcode,
01749 get_callback(slot),
01750 const_cast<char*>( name.c_str() ),
01751 argstring,
01752 scb )
01753 );
01754 }
01755
01756 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
01757 inline
01758 bool Environment::add_function( std::string name,
01759 const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot) {
01760 char retcode = get_return_code<T_return>( );
01761 char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(name);
01762 sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* scb =
01763 new sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(slot);
01764 any holder = CLIPSPointer<sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> >(scb);
01765 m_slots[name] = holder;
01766 return ( EnvDefineFunction2WithContext( m_cobj,
01767 const_cast<char*>( name.c_str() ),
01768 retcode,
01769 get_callback(slot),
01770 const_cast<char*>( name.c_str() ),
01771 argstring,
01772 scb )
01773 );
01774 }
01775
01776 }
01777
01778
01779 #endif