clipsmm - C++ CLIPS Interface Library

clipsmm logo
environment.h
Go to the documentation of this file.
1 /***************************************************************************
2  * Copyright (C) 2006 by Rick L. Vinyard, Jr. <rvinyard@cs.nmsu.edu> *
3  * Copyright (C) 2011-2013 by Tim Niemueller [http://www.niemueller.de] *
4  * *
5  * This file is part of the clipsmm library. *
6  * *
7  * The clipsmm library is free software; you can redistribute it and/or *
8  * modify it under the terms of the GNU General Public License *
9  * version 3 as published by the Free Software Foundation. *
10  * *
11  * The clipsmm library is distributed in the hope that it will be *
12  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty *
13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
14  * General Public License for more details. *
15  * *
16  * You should have received a copy of the GNU General Public License *
17  * along with this software. If not see <http://www.gnu.org/licenses/>. *
18  ***************************************************************************/
19 #ifndef CLIPSENVIRONMENT_H
20 #define CLIPSENVIRONMENT_H
21 
22 #include <string>
23 #include <map>
24 #include <stdexcept>
25 #include <map>
26 #include <queue>
27 
28 #include <cstdio>
29 
30 #include <sigc++/sigc++.h>
31 #include <glibmm.h>
32 
33 #include <clipsmm/enum.h>
34 #include <clipsmm/object.h>
35 
36 #include <clipsmm/activation.h>
37 #include <clipsmm/defaultfacts.h>
38 #include <clipsmm/fact.h>
39 #include <clipsmm/function.h>
40 #include <clipsmm/global.h>
41 #include <clipsmm/module.h>
42 #include <clipsmm/rule.h>
43 #include <clipsmm/template.h>
44 
45 #include <clipsmm/utility.h>
46 #include <clipsmm/any.h>
47 
48 extern "C" {
49  int EnvDefineFunction2WithContext( void *, char *, int, int ( * ) ( void * ), char *, char *, void * );
50 }
51 
52 namespace CLIPS {
53 
57  class Environment: public Object {
58  public:
59  typedef CLIPSPointer<Environment> pointer;
60 
61  Environment();
62 
63  ~Environment();
64 
69  bool batch_evaluate( const std::string& filename );
70 
75  bool binary_load( const std::string& filename );
76 
81  bool binary_save( const std::string& filename );
82 
87  bool build( const std::string& construct );
88 
92  void clear( );
93 
99  Values evaluate( const std::string& expression );
100 
106  Values function( const std::string& function_name, const std::string& arguments=std::string() );
107 
119  int load( const std::string& filename );
120 
124  void reset();
125 
130  bool save( const std::string& filename );
131 
139 
147  bool use_auto_float_dividend( bool use = true );
148 
156 
164  bool use_dynamic_constraint_checking( bool use = true );
165 
173 
181  bool use_sequence_operator_recognition( bool use = true );
182 
190 
197  bool use_static_constraint_checking( bool use = true );
198 
207 
214  bool use_fact_duplication( bool use = true );
215 
217 
218  bool use_incremental_reset( bool use = true );
219 
220  bool global_reset_enable();
221 
222  bool use_global_reset( bool use=true );
223 
228  bool is_dribble_active( );
229 
234  bool dribble_off( );
235 
240  bool dribble_on( const std::string& dribble_file );
241 
249  int is_watched( const std::string& item );
250 
251  bool watch( const std::string& item );
252 
253  bool unwatch( const std::string& item );
254 
255  void set_as_current();
256 
257  Fact::pointer assert_fact( const std::string& factstring );
259  Fact::pointer assert_fact_f( const char *format, ... );
260 
261  void clear_focus_stack();
262 
271 
272  DefaultFacts::pointer get_default_facts( const std::string& default_facts_name );
273 
275  std::vector<std::string> get_default_facts_names();
276 
278  std::vector<std::string> get_default_facts_names( const Module& module );
279 
281  std::vector<std::string> get_default_facts_names( Module::pointer module );
282 
284 
285  Template::pointer get_template( const std::string& template_name );
286 
288  std::vector<std::string> get_template_names();
289 
291  std::vector<std::string> get_template_names( const Module& module );
292 
294  std::vector<std::string> get_template_names( Module::pointer module );
295 
297 
298  Rule::pointer get_rule( const std::string& rule_name );
299 
301  std::vector<std::string> get_rule_names();
302 
304  std::vector<std::string> get_rule_names( const Module& module );
305 
307  std::vector<std::string> get_rule_names( Module::pointer module );
308 
310 
311  void remove_rules();
312 
313  Module::pointer get_module( const std::string& module_name );
314 
316 
317  std::vector<std::string> get_module_names();
318 
320 
326  void refresh_agenda();
327 
333  void refresh_agenda( const Module& module );
334 
340  void refresh_agenda( Module::pointer module );
341 
347  void reorder_agenda();
348 
354  void reorder_agenda( const Module& module );
355 
361  void reorder_agenda( Module::pointer module );
362 
372  long int run( long int runlimit = -1 );
373 
392  void run_threaded( long int runlimit = -1, int priority = 0 );
393 
395  void join_run_thread();
396 
398  sigc::signal<void, long int> signal_run();
399 
402 
408 
411 
417 
426  bool check_agenda_changed();
427 
429 
430  std::vector<std::string> get_focus_stack();
431 
433 
434  Global::pointer get_global( const std::string& global_name );
435 
437 
439  std::vector<std::string> get_globals_names();
440 
442  std::vector<std::string> get_globals_names( const Module& module );
443 
445  std::vector<std::string> get_globals_names( Module::pointer module );
446 
447  bool check_globals_changed();
448 
449  Function::pointer get_function( const std::string& function_name );
450 
452 
454  std::vector<std::string> get_function_names();
455 
457  std::vector<std::string> get_function_names( const Module& module );
458 
460  std::vector<std::string> get_function_names( Module::pointer module );
461 
462  sigc::signal<void> signal_clear();
463  sigc::signal<void> signal_periodic();
464  sigc::signal<void> signal_reset();
465  sigc::signal<void> signal_rule_firing();
466  sigc::signal<void> signal_agenda_changed();
467  sigc::signal<void> signal_globals_changed();
468 
469  template < typename T_return >
470  bool add_function( std::string name, const sigc::slot0<T_return>& slot);
471 
472  template < typename T_return, typename T_arg1 >
473  bool add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot);
474 
475  template < typename T_return, typename T_arg1, typename T_arg2 >
476  bool add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot);
477 
478  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
479  bool add_function( std::string name, const sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>& slot);
480 
481  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
482  bool add_function( std::string name, const sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>& slot);
483 
484  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
485  bool add_function( std::string name, const sigc::slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& slot);
486 
487  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
488  bool add_function( std::string name, const sigc::slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& slot);
489 
490  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 >
491  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);
492 
493  bool remove_function( std::string name );
494 
495  protected:
502  std::map<std::string,any> m_slots;
503 
504  sigc::signal<void> m_signal_clear;
505  sigc::signal<void> m_signal_periodic;
506  sigc::signal<void> m_signal_reset;
507  sigc::signal<void> m_signal_rule_firing;
508  sigc::signal<void> m_signal_agenda_changed;
509  sigc::signal<void> m_signal_globals_changed;
510 
512  typedef struct Job {
514  Job( int p, long int rl ) : priority(p), runlimit(rl) { }
515 
517  bool operator<( const Job& other ) const { return priority < other.priority; }
518 
520  int priority;
521 
526  long int runlimit;
527  } Job;
528 
529  Glib::Thread* m_run_thread;
530  std::priority_queue<Job> m_run_queue;
531  Glib::Mutex m_mutex_run_queue;
532  Glib::Mutex m_mutex_run;
533  Glib::Mutex m_mutex_threaded_run;
534  Glib::Mutex m_mutex_run_signal;
535  sigc::signal<void, long int> m_signal_run;
546  std::map<std::string, char *> m_func_restr;
547 
549  void threaded_run();
550 
551  static std::map<void*, Environment*> m_environment_map;
552 
553 
554  static void clear_callback( void* env );
555  static void periodic_callback( void* env );
556  static void reset_callback( void* env );
557  static void rule_firing_callback( void* end );
558 
559  static void* strcallback( void* theEnv );
560 
561  template < typename T_arg1 >
562  static void* strcallback( void* theEnv );
563 
564  template < typename T_arg1, typename T_arg2 >
565  static void* strcallback( void* theEnv );
566 
567  template < typename T_arg1, typename T_arg2, typename T_arg3 >
568  static void* strcallback( void* theEnv );
569 
570  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
571  static void* strcallback( void* theEnv );
572 
573  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
574  static void* strcallback( void* theEnv );
575 
576  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
577  static void* strcallback( void* theEnv );
578 
579  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
580  static void* strcallback( void* theEnv );
581 
582  template < typename T_return >
583  static T_return callback( void* theEnv );
584 
585  template < typename T_return, typename T_arg1 >
586  static T_return callback( void* theEnv );
587 
588  template < typename T_return, typename T_arg1, typename T_arg2 >
589  static T_return callback( void* theEnv );
590 
591  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
592  static T_return callback( void* theEnv );
593 
594  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
595  static T_return callback( void* theEnv );
596 
597  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
598  static T_return callback( void* theEnv );
599 
600  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
601  static T_return callback( void* theEnv );
602 
603  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 >
604  static T_return callback( void* theEnv );
605 
606  static void callback_multifield( void* theEnv, void *rv);
607 
608  template <typename T_arg1>
609  static void callback_multifield( void* theEnv, void *rv );
610 
611  template <typename T_arg1, typename T_arg2>
612  static void callback_multifield( void* theEnv, void *rv );
613 
614  template <typename T_arg1, typename T_arg2, typename T_arg3>
615  static void callback_multifield( void* theEnv, void *rv );
616 
617  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
618  static void callback_multifield( void* theEnv, void *rv );
619 
620  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
621  typename T_arg5>
622  static void callback_multifield( void* theEnv, void *rv );
623 
624  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
625  typename T_arg5, typename T_arg6>
626  static void callback_multifield( void* theEnv, void *rv );
627 
628  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
629  typename T_arg5, typename T_arg6, typename T_arg7>
630  static void callback_multifield( void* theEnv, void *rv );
631 
632 
633  static void callback_unknown( void* theEnv, void *rv);
634 
635  template <typename T_arg1>
636  static void callback_unknown( void* theEnv, void *rv );
637 
638  template <typename T_arg1, typename T_arg2>
639  static void callback_unknown( void* theEnv, void *rv );
640 
641  template <typename T_arg1, typename T_arg2, typename T_arg3>
642  static void callback_unknown( void* theEnv, void *rv );
643 
644  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
645  static void callback_unknown( void* theEnv, void *rv );
646 
647  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
648  typename T_arg5>
649  static void callback_unknown( void* theEnv, void *rv );
650 
651  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
652  typename T_arg5, typename T_arg6>
653  static void callback_unknown( void* theEnv, void *rv );
654 
655  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
656  typename T_arg5, typename T_arg6, typename T_arg7>
657  static void callback_unknown( void* theEnv, void *rv );
658 
659  int ( *get_callback( const sigc::slot0<std::string>& slot ))( void* )
660  { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback; }
661 
662  template < typename T_arg1 >
663  int ( *get_callback( const sigc::slot1<std::string,T_arg1>& slot ))( void* )
664  { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1>; }
665 
666  template < typename T_arg1, typename T_arg2 >
667  int ( *get_callback( const sigc::slot2<std::string,T_arg1,T_arg2>& slot ))( void* )
668  { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1,T_arg2>; }
669 
670  template < typename T_arg1, typename T_arg2, typename T_arg3 >
671  int ( *get_callback( const sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>& slot ))( void* )
672  { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3>; }
673 
674  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
675  int ( *get_callback( const sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
676  { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4>; }
677 
678  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
679  int ( *get_callback( const sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
680  { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
681 
682  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
683  int ( *get_callback( const sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
684  { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
685 
686  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
687  int ( *get_callback( const sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
688  { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
689 
690  int ( *get_callback( const sigc::slot0<Values>& slot ))( void* )
691  { return (int (*) (void*)) (void (*) (void*, void*)) callback_multifield; }
692 
693  template <typename T_arg1>
694  int ( *get_callback( const sigc::slot1<Values,T_arg1>& slot ))( void* )
695  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1>; }
696 
697  template <typename T_arg1, typename T_arg2>
698  int ( *get_callback( const sigc::slot2<Values,T_arg1,T_arg2>& slot ))( void* )
699  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2>; }
700 
701  template <typename T_arg1, typename T_arg2, typename T_arg3>
702  int ( *get_callback( const sigc::slot3<Values,T_arg1,T_arg2,T_arg3>& slot ))( void* )
703  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3>; }
704 
705  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
706  int ( *get_callback( const sigc::slot4<Values,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
707  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4>; }
708 
709  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
710  int ( *get_callback( const sigc::slot5<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
711  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
712 
713  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
714  int ( *get_callback( const sigc::slot6<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
715  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
716 
717  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
718  int ( *get_callback( const sigc::slot7<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
719  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
720 
721 
722  int ( *get_callback( const sigc::slot0<Value>& slot ))( void* )
723  { return (int (*) (void*)) (void (*) (void*, void*)) callback_unknown; }
724 
725  template <typename T_arg1>
726  int ( *get_callback( const sigc::slot1<Value,T_arg1>& slot ))( void* )
727  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1>; }
728 
729  template <typename T_arg1, typename T_arg2>
730  int ( *get_callback( const sigc::slot2<Value,T_arg1,T_arg2>& slot ))( void* )
731  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2>; }
732 
733  template <typename T_arg1, typename T_arg2, typename T_arg3>
734  int ( *get_callback( const sigc::slot3<Value,T_arg1,T_arg2,T_arg3>& slot ))( void* )
735  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3>; }
736 
737  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
738  int ( *get_callback( const sigc::slot4<Value,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
739  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4>; }
740 
741  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
742  int ( *get_callback( const sigc::slot5<Value,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
743  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
744 
745  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
746  int ( *get_callback( const sigc::slot6<Value,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
747  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
748 
749  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
750  int ( *get_callback( const sigc::slot7<Value,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
751  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
752 
753 
754  template < typename T_return >
755  int ( *get_callback( const sigc::slot0<T_return>& slot ))( void* )
756  { return (int (*) (void*)) ( T_return ( * ) ( void* ) ) callback<T_return>; }
757 
758  template < typename T_return, typename T_arg1 >
759  int ( *get_callback( const sigc::slot1<T_return,T_arg1>& slot ))( void* )
760  { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1>; }
761 
762  template < typename T_return, typename T_arg1, typename T_arg2 >
763  int ( *get_callback( const sigc::slot2<T_return,T_arg1,T_arg2>& slot ))( void* )
764  { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1,T_arg2>; }
765 
766  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
767  int ( *get_callback( const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot ))( void* )
768  { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3>; }
769 
770  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
771  int ( *get_callback( const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
772  { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4>; }
773 
774  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
775  int ( *get_callback( const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
776  { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
777 
778  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
779  int ( *get_callback( const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
780  { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
781 
782  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 >
783  int ( *get_callback( const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
784  { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
785 
786  char * get_function_restriction(std::string &name);
787 
788  template <typename T_arg1>
789  char * get_function_restriction(std::string &name);
790 
791  template <typename T_arg1, typename T_arg2>
792  char * get_function_restriction(std::string &name);
793 
794  template <typename T_arg1, typename T_arg2, typename T_arg3>
795  char * get_function_restriction(std::string &name);
796 
797  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
798  char * get_function_restriction(std::string &name);
799 
800  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
801  char * get_function_restriction(std::string &name);
802 
803  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
804  char * get_function_restriction(std::string &name);
805 
806  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
807  char * get_function_restriction(std::string &name);
808 
809 
810  static int get_arg_count( void* env );
811  static void* get_function_context( void* env );
812  static void set_return_values( void *env, void *rv, const Values &v);
813  static void set_return_value( void *env, void *rv, const Value &v);
814  static void* add_symbol( const char* s );
815 
816 
817  };
818 
819 
820  inline char *
822  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
823  char *restr = (char *)malloc(4); m_func_restr[name] = restr;
824  snprintf(restr, 4, "00u");
825  return restr;
826  }
827 
828  template <typename T_arg1>
829  inline char *
830  Environment::get_function_restriction(std::string &name) {
831  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
832  char *restr = (char *)malloc(5); m_func_restr[name] = restr;
833  snprintf(restr, 5, "11u%c", get_argument_code<T_arg1>());
834  return restr;
835  }
836 
837  template <typename T_arg1, typename T_arg2>
838  inline char *
839  Environment::get_function_restriction(std::string &name) {
840  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
841  char *restr = (char *)malloc(6); m_func_restr[name] = restr;
842  snprintf(restr, 6, "22u%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>());
843  return restr;
844  }
845 
846  template <typename T_arg1, typename T_arg2, typename T_arg3>
847  inline char *
848  Environment::get_function_restriction(std::string &name) {
849  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
850  char *restr = (char *)malloc(7); m_func_restr[name] = restr;
851  snprintf(restr, 7, "33u%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
852  get_argument_code<T_arg3>());
853  return restr;
854  }
855 
856  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
857  inline char *
858  Environment::get_function_restriction(std::string &name) {
859  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
860  char *restr = (char *)malloc(8); m_func_restr[name] = restr;
861  snprintf(restr, 8, "44u%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
862  get_argument_code<T_arg3>(), get_argument_code<T_arg4>());
863  return restr;
864  }
865 
866  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
867  typename T_arg5>
868  inline char *
869  Environment::get_function_restriction(std::string &name) {
870  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
871  char *restr = (char *)malloc(9); m_func_restr[name] = restr;
872  snprintf(restr, 9, "55u%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
873  get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>());
874  return restr;
875  }
876 
877  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
878  typename T_arg5, typename T_arg6>
879  inline char *
880  Environment::get_function_restriction(std::string &name) {
881  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
882  char *restr = (char *)malloc(10); m_func_restr[name] = restr;
883  snprintf(restr, 10, "66u%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
884  get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>(),
885  get_argument_code<T_arg6>());
886  return restr;
887  }
888 
889  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
890  typename T_arg5, typename T_arg6, typename T_arg7>
891  inline char *
892  Environment::get_function_restriction(std::string &name) {
893  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
894  char *restr = (char *)malloc(11); m_func_restr[name] = restr;
895  snprintf(restr, 11, "77u%c%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
896  get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>(),
897  get_argument_code<T_arg6>(), get_argument_code<T_arg7>());
898  return restr;
899  }
900 
901 
902  template < typename T_return>
903  inline
904  T_return Environment::callback( void* theEnv ) {
905  sigc::slot0<T_return>* cb;
906  void * cbptr = get_function_context( theEnv );
907  if ( cbptr ) {
908  if ( get_arg_count( theEnv ) != 0 )
909  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 0" );
910  cb = static_cast<sigc::slot0<T_return>*>( cbptr );
911  return ( *cb ) ();
912  }
913  throw;
914  }
915 
916  template < typename T_return, typename T_arg1 >
917  inline
918  T_return Environment::callback( void* theEnv ) {
919  sigc::slot1<T_return,T_arg1>* cb;
920  void * cbptr = get_function_context( theEnv );
921  T_arg1 arg1;
922  if ( cbptr ) {
923  if ( get_arg_count( theEnv ) != 1 )
924  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
925  get_argument( theEnv, 1, arg1 );
926  cb = static_cast<sigc::slot1<T_return,T_arg1>*>( cbptr );
927  return ( *cb ) ( arg1 );
928  }
929  throw;
930  }
931 
932  template < typename T_return, typename T_arg1, typename T_arg2 >
933  inline
934  T_return Environment::callback( void* theEnv ) {
935  sigc::slot2<T_return, T_arg1, T_arg2>* cb;
936  void * cbptr = get_function_context( theEnv );
937  T_arg1 arg1;
938  T_arg2 arg2;
939  if ( cbptr ) {
940  if ( get_arg_count( theEnv ) != 2 )
941  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
942  get_argument( theEnv, 1, arg1 );
943  get_argument( theEnv, 2, arg2 );
944  cb = static_cast<sigc::slot2<T_return, T_arg1, T_arg2>*>( cbptr );
945  return ( *cb ) ( arg1, arg2 );
946  }
947  throw;
948  }
949 
950  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
951  inline
952  T_return Environment::callback( void* theEnv ) {
953  sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* cb;
954  void * cbptr = get_function_context( theEnv );
955  T_arg1 arg1;
956  T_arg2 arg2;
957  T_arg3 arg3;
958  if ( cbptr ) {
959  if ( get_arg_count( theEnv ) != 3 )
960  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
961  get_argument( theEnv, 1, arg1 );
962  get_argument( theEnv, 2, arg2 );
963  get_argument( theEnv, 3, arg3 );
964  cb = static_cast<sigc::slot3<T_return, T_arg1, T_arg2,T_arg3>*>( cbptr );
965  return ( *cb ) ( arg1, arg2, arg3 );
966  }
967  throw;
968  }
969 
970  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
971  inline
972  T_return Environment::callback( void* theEnv ) {
973  sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
974  void * cbptr = get_function_context( theEnv );
975  T_arg1 arg1;
976  T_arg2 arg2;
977  T_arg3 arg3;
978  T_arg4 arg4;
979  if ( cbptr ) {
980  if ( get_arg_count( theEnv ) != 4 )
981  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
982  get_argument( theEnv, 1, arg1 );
983  get_argument( theEnv, 2, arg2 );
984  get_argument( theEnv, 3, arg3 );
985  get_argument( theEnv, 4, arg4 );
986  cb = static_cast<sigc::slot4<T_return, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
987  return ( *cb ) ( arg1, arg2, arg3, arg4 );
988  }
989  throw;
990  }
991 
992  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
993  inline
994  T_return Environment::callback( void* theEnv ) {
995  sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
996  void * cbptr = get_function_context( theEnv );
997  T_arg1 arg1;
998  T_arg2 arg2;
999  T_arg3 arg3;
1000  T_arg4 arg4;
1001  T_arg5 arg5;
1002  if ( cbptr ) {
1003  if ( get_arg_count( theEnv ) != 5 )
1004  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
1005  get_argument( theEnv, 1, arg1 );
1006  get_argument( theEnv, 2, arg2 );
1007  get_argument( theEnv, 3, arg3 );
1008  get_argument( theEnv, 4, arg4 );
1009  get_argument( theEnv, 5, arg5 );
1010  cb = static_cast<sigc::slot5<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
1011  return ( *cb ) ( arg1, arg2, arg3, arg4, arg5 );
1012  }
1013  throw;
1014  }
1015 
1016  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
1017  inline
1018  T_return Environment::callback( void* theEnv ) {
1019  sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
1020  void * cbptr = get_function_context( theEnv );
1021  T_arg1 arg1;
1022  T_arg2 arg2;
1023  T_arg3 arg3;
1024  T_arg4 arg4;
1025  T_arg5 arg5;
1026  T_arg6 arg6;
1027  if ( cbptr ) {
1028  if ( get_arg_count( theEnv ) != 6 )
1029  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
1030  get_argument( theEnv, 1, arg1 );
1031  get_argument( theEnv, 2, arg2 );
1032  get_argument( theEnv, 3, arg3 );
1033  get_argument( theEnv, 4, arg4 );
1034  get_argument( theEnv, 5, arg5 );
1035  get_argument( theEnv, 6, arg6 );
1036  cb = static_cast<sigc::slot6<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
1037  return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 );
1038  }
1039  throw;
1040  }
1041 
1042  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 >
1043  inline
1044  T_return Environment::callback( void* theEnv ) {
1045  sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
1046  void * cbptr = get_function_context( theEnv );
1047  T_arg1 arg1;
1048  T_arg2 arg2;
1049  T_arg3 arg3;
1050  T_arg4 arg4;
1051  T_arg5 arg5;
1052  T_arg6 arg6;
1053  T_arg7 arg7;
1054  if ( cbptr ) {
1055  if ( get_arg_count( theEnv ) != 7 )
1056  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
1057  get_argument( theEnv, 1, arg1 );
1058  get_argument( theEnv, 2, arg2 );
1059  get_argument( theEnv, 3, arg3 );
1060  get_argument( theEnv, 4, arg4 );
1061  get_argument( theEnv, 5, arg5 );
1062  get_argument( theEnv, 6, arg6 );
1063  get_argument( theEnv, 7, arg7 );
1064  cb = static_cast<sigc::slot7<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
1065  return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 );
1066  }
1067  throw;
1068  }
1069 
1070  inline
1071  void Environment::callback_multifield( void* theEnv, void *rv) {
1072  sigc::slot0<Values>* cb;
1073  void * cbptr = get_function_context( theEnv );
1074  if ( cbptr ) {
1075  if ( get_arg_count( theEnv ) != 0 )
1076  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 0" );
1077  cb = static_cast<sigc::slot0<Values>*>( cbptr );
1078  Values v = ( *cb ) ();
1079  set_return_values(theEnv, rv, v);
1080  return;
1081  }
1082  throw;
1083  }
1084 
1085  template <typename T_arg1>
1086  inline
1087  void Environment::callback_multifield( void* theEnv, void *rv) {
1088  sigc::slot1<Values, T_arg1>* cb;
1089  void * cbptr = get_function_context( theEnv );
1090  T_arg1 arg1;
1091  if ( cbptr ) {
1092  if ( get_arg_count( theEnv ) != 1 )
1093  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 1" );
1094  cb = static_cast<sigc::slot1<Values, T_arg1>*>( cbptr );
1095  get_argument(theEnv, 1, arg1);
1096  Values v = ( *cb ) (arg1);
1097  set_return_values(theEnv, rv, v);
1098  return;
1099  }
1100  throw;
1101  }
1102 
1103  template <typename T_arg1, typename T_arg2>
1104  inline
1105  void Environment::callback_multifield( void* theEnv, void *rv) {
1106  sigc::slot2<Values, T_arg1, T_arg2>* cb;
1107  void * cbptr = get_function_context( theEnv );
1108  T_arg1 arg1;
1109  T_arg2 arg2;
1110  if ( cbptr ) {
1111  if ( get_arg_count( theEnv ) != 2 )
1112  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 2" );
1113  cb = static_cast<sigc::slot2<Values, T_arg1, T_arg2>*>( cbptr );
1114  get_argument(theEnv, 1, arg1);
1115  get_argument(theEnv, 2, arg2);
1116  Values v = ( *cb ) (arg1, arg2);
1117  set_return_values(theEnv, rv, v);
1118  return;
1119  }
1120  throw;
1121  }
1122 
1123 
1124  template <typename T_arg1, typename T_arg2, typename T_arg3>
1125  inline
1126  void Environment::callback_multifield( void* theEnv, void *rv) {
1127  sigc::slot3<Values, T_arg1, T_arg2, T_arg3>* cb;
1128  void * cbptr = get_function_context( theEnv );
1129  T_arg1 arg1;
1130  T_arg2 arg2;
1131  T_arg3 arg3;
1132  if ( cbptr ) {
1133  if ( get_arg_count( theEnv ) != 3 )
1134  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 3" );
1135  cb = static_cast<sigc::slot3<Values, T_arg1, T_arg2, T_arg3>*>( cbptr );
1136  get_argument(theEnv, 1, arg1);
1137  get_argument(theEnv, 2, arg2);
1138  get_argument(theEnv, 3, arg3);
1139  Values v = ( *cb ) (arg1, arg2, arg3);
1140  set_return_values(theEnv, rv, v);
1141  return;
1142  }
1143  throw;
1144  }
1145 
1146  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
1147  inline
1148  void Environment::callback_multifield( void* theEnv, void *rv) {
1149  sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>* cb;
1150  void * cbptr = get_function_context( theEnv );
1151  T_arg1 arg1;
1152  T_arg2 arg2;
1153  T_arg3 arg3;
1154  T_arg4 arg4;
1155  if ( cbptr ) {
1156  if ( get_arg_count( theEnv ) != 4 )
1157  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 4" );
1158  cb = static_cast<sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>*>(cbptr);
1159  get_argument(theEnv, 1, arg1);
1160  get_argument(theEnv, 2, arg2);
1161  get_argument(theEnv, 3, arg3);
1162  get_argument(theEnv, 4, arg4);
1163  Values v = ( *cb ) (arg1, arg2, arg3, arg4);
1164  set_return_values(theEnv, rv, v);
1165  return;
1166  }
1167  throw;
1168  }
1169 
1170  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1171  typename T_arg5>
1172  inline
1173  void Environment::callback_multifield( void* theEnv, void *rv) {
1174  sigc::slot5<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* cb;
1175  void * cbptr = get_function_context( theEnv );
1176  T_arg1 arg1;
1177  T_arg2 arg2;
1178  T_arg3 arg3;
1179  T_arg4 arg4;
1180  T_arg5 arg5;
1181  if ( cbptr ) {
1182  if ( get_arg_count( theEnv ) != 5 )
1183  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 5" );
1184  cb = static_cast<sigc::slot5<Values, T_arg1, T_arg2, T_arg3,
1185  T_arg4, T_arg5>*>(cbptr);
1186  get_argument(theEnv, 1, arg1);
1187  get_argument(theEnv, 2, arg2);
1188  get_argument(theEnv, 3, arg3);
1189  get_argument(theEnv, 4, arg4);
1190  get_argument(theEnv, 5, arg5);
1191  Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5);
1192  set_return_values(theEnv, rv, v);
1193  return;
1194  }
1195  throw;
1196  }
1197 
1198 
1199  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1200  typename T_arg5, typename T_arg6>
1201  inline
1202  void Environment::callback_multifield( void* theEnv, void *rv) {
1203  sigc::slot6<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* cb;
1204  void * cbptr = get_function_context( theEnv );
1205  T_arg1 arg1;
1206  T_arg2 arg2;
1207  T_arg3 arg3;
1208  T_arg4 arg4;
1209  T_arg5 arg5;
1210  T_arg6 arg6;
1211  if ( cbptr ) {
1212  if ( get_arg_count( theEnv ) != 6 )
1213  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 6" );
1214  cb = static_cast<sigc::slot6<Values, T_arg1, T_arg2, T_arg3,
1215  T_arg4, T_arg5, T_arg6>*>(cbptr);
1216  get_argument(theEnv, 1, arg1);
1217  get_argument(theEnv, 2, arg2);
1218  get_argument(theEnv, 3, arg3);
1219  get_argument(theEnv, 4, arg4);
1220  get_argument(theEnv, 5, arg5);
1221  get_argument(theEnv, 6, arg6);
1222  Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6);
1223  set_return_values(theEnv, rv, v);
1224  return;
1225  }
1226  throw;
1227  }
1228 
1229  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1230  typename T_arg5, typename T_arg6, typename T_arg7>
1231  inline
1232  void Environment::callback_multifield( void* theEnv, void *rv) {
1233  sigc::slot7<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* cb;
1234  void * cbptr = get_function_context( theEnv );
1235  T_arg1 arg1;
1236  T_arg2 arg2;
1237  T_arg3 arg3;
1238  T_arg4 arg4;
1239  T_arg5 arg5;
1240  T_arg6 arg6;
1241  T_arg7 arg7;
1242  if ( cbptr ) {
1243  if ( get_arg_count( theEnv ) != 7 )
1244  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 7" );
1245  cb = static_cast<sigc::slot7<Values, T_arg1, T_arg2, T_arg3,
1246  T_arg4, T_arg5, T_arg6, T_arg7>*>(cbptr);
1247  get_argument(theEnv, 1, arg1);
1248  get_argument(theEnv, 2, arg2);
1249  get_argument(theEnv, 3, arg3);
1250  get_argument(theEnv, 4, arg4);
1251  get_argument(theEnv, 5, arg5);
1252  get_argument(theEnv, 6, arg6);
1253  get_argument(theEnv, 7, arg7);
1254  Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1255  set_return_values(theEnv, rv, v);
1256  return;
1257  }
1258  throw;
1259  }
1260 
1261 
1262  // **************************************************************************************
1263 
1264  inline
1265  void Environment::callback_unknown( void* theEnv, void *rv) {
1266  sigc::slot0<Value>* cb;
1267  void * cbptr = get_function_context( theEnv );
1268  if ( cbptr ) {
1269  if ( get_arg_count( theEnv ) != 0 )
1270  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 0" );
1271  cb = static_cast<sigc::slot0<Value>*>( cbptr );
1272  Value v = ( *cb ) ();
1273  set_return_value(theEnv, rv, v);
1274  return;
1275  }
1276  throw;
1277  }
1278 
1279  template <typename T_arg1>
1280  inline
1281  void Environment::callback_unknown( void* theEnv, void *rv) {
1282  sigc::slot1<Value, T_arg1>* cb;
1283  void * cbptr = get_function_context( theEnv );
1284  T_arg1 arg1;
1285  if ( cbptr ) {
1286  if ( get_arg_count( theEnv ) != 1 )
1287  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 1" );
1288  cb = static_cast<sigc::slot1<Value, T_arg1>*>( cbptr );
1289  get_argument(theEnv, 1, arg1);
1290  Value v = ( *cb ) (arg1);
1291  set_return_value(theEnv, rv, v);
1292  return;
1293  }
1294  throw;
1295  }
1296 
1297  template <typename T_arg1, typename T_arg2>
1298  inline
1299  void Environment::callback_unknown( void* theEnv, void *rv) {
1300  sigc::slot2<Value, T_arg1, T_arg2>* cb;
1301  void * cbptr = get_function_context( theEnv );
1302  T_arg1 arg1;
1303  T_arg2 arg2;
1304  if ( cbptr ) {
1305  if ( get_arg_count( theEnv ) != 2 )
1306  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 2" );
1307  cb = static_cast<sigc::slot2<Value, T_arg1, T_arg2>*>( cbptr );
1308  get_argument(theEnv, 1, arg1);
1309  get_argument(theEnv, 2, arg2);
1310  Value v = ( *cb ) (arg1, arg2);
1311  set_return_value(theEnv, rv, v);
1312  return;
1313  }
1314  throw;
1315  }
1316 
1317 
1318  template <typename T_arg1, typename T_arg2, typename T_arg3>
1319  inline
1320  void Environment::callback_unknown( void* theEnv, void *rv) {
1321  sigc::slot3<Value, T_arg1, T_arg2, T_arg3>* cb;
1322  void * cbptr = get_function_context( theEnv );
1323  T_arg1 arg1;
1324  T_arg2 arg2;
1325  T_arg3 arg3;
1326  if ( cbptr ) {
1327  if ( get_arg_count( theEnv ) != 3 )
1328  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 3" );
1329  cb = static_cast<sigc::slot3<Value, T_arg1, T_arg2, T_arg3>*>( cbptr );
1330  get_argument(theEnv, 1, arg1);
1331  get_argument(theEnv, 2, arg2);
1332  get_argument(theEnv, 3, arg3);
1333  Value v = ( *cb ) (arg1, arg2, arg3);
1334  set_return_value(theEnv, rv, v);
1335  return;
1336  }
1337  throw;
1338  }
1339 
1340  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
1341  inline
1342  void Environment::callback_unknown( void* theEnv, void *rv) {
1343  sigc::slot4<Value, T_arg1, T_arg2, T_arg3, T_arg4>* cb;
1344  void * cbptr = get_function_context( theEnv );
1345  T_arg1 arg1;
1346  T_arg2 arg2;
1347  T_arg3 arg3;
1348  T_arg4 arg4;
1349  if ( cbptr ) {
1350  if ( get_arg_count( theEnv ) != 4 )
1351  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 4" );
1352  cb = static_cast<sigc::slot4<Value, T_arg1, T_arg2, T_arg3, T_arg4>*>(cbptr);
1353  get_argument(theEnv, 1, arg1);
1354  get_argument(theEnv, 2, arg2);
1355  get_argument(theEnv, 3, arg3);
1356  get_argument(theEnv, 4, arg4);
1357  Value v = ( *cb ) (arg1, arg2, arg3, arg4);
1358  set_return_value(theEnv, rv, v);
1359  return;
1360  }
1361  throw;
1362  }
1363 
1364  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1365  typename T_arg5>
1366  inline
1367  void Environment::callback_unknown( void* theEnv, void *rv) {
1368  sigc::slot5<Value, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* cb;
1369  void * cbptr = get_function_context( theEnv );
1370  T_arg1 arg1;
1371  T_arg2 arg2;
1372  T_arg3 arg3;
1373  T_arg4 arg4;
1374  T_arg5 arg5;
1375  if ( cbptr ) {
1376  if ( get_arg_count( theEnv ) != 5 )
1377  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 5" );
1378  cb = static_cast<sigc::slot5<Value, T_arg1, T_arg2, T_arg3,
1379  T_arg4, T_arg5>*>(cbptr);
1380  get_argument(theEnv, 1, arg1);
1381  get_argument(theEnv, 2, arg2);
1382  get_argument(theEnv, 3, arg3);
1383  get_argument(theEnv, 4, arg4);
1384  get_argument(theEnv, 5, arg5);
1385  Value v = ( *cb ) (arg1, arg2, arg3, arg4, arg5);
1386  set_return_value(theEnv, rv, v);
1387  return;
1388  }
1389  throw;
1390  }
1391 
1392 
1393  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1394  typename T_arg5, typename T_arg6>
1395  inline
1396  void Environment::callback_unknown( void* theEnv, void *rv) {
1397  sigc::slot6<Value, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* cb;
1398  void * cbptr = get_function_context( theEnv );
1399  T_arg1 arg1;
1400  T_arg2 arg2;
1401  T_arg3 arg3;
1402  T_arg4 arg4;
1403  T_arg5 arg5;
1404  T_arg6 arg6;
1405  if ( cbptr ) {
1406  if ( get_arg_count( theEnv ) != 6 )
1407  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 6" );
1408  cb = static_cast<sigc::slot6<Value, T_arg1, T_arg2, T_arg3,
1409  T_arg4, T_arg5, T_arg6>*>(cbptr);
1410  get_argument(theEnv, 1, arg1);
1411  get_argument(theEnv, 2, arg2);
1412  get_argument(theEnv, 3, arg3);
1413  get_argument(theEnv, 4, arg4);
1414  get_argument(theEnv, 5, arg5);
1415  get_argument(theEnv, 6, arg6);
1416  Value v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6);
1417  set_return_value(theEnv, rv, v);
1418  return;
1419  }
1420  throw;
1421  }
1422 
1423  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1424  typename T_arg5, typename T_arg6, typename T_arg7>
1425  inline
1426  void Environment::callback_unknown( void* theEnv, void *rv) {
1427  sigc::slot7<Value, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* cb;
1428  void * cbptr = get_function_context( theEnv );
1429  T_arg1 arg1;
1430  T_arg2 arg2;
1431  T_arg3 arg3;
1432  T_arg4 arg4;
1433  T_arg5 arg5;
1434  T_arg6 arg6;
1435  T_arg7 arg7;
1436  if ( cbptr ) {
1437  if ( get_arg_count( theEnv ) != 7 )
1438  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 7" );
1439  cb = static_cast<sigc::slot7<Value, T_arg1, T_arg2, T_arg3,
1440  T_arg4, T_arg5, T_arg6, T_arg7>*>(cbptr);
1441  get_argument(theEnv, 1, arg1);
1442  get_argument(theEnv, 2, arg2);
1443  get_argument(theEnv, 3, arg3);
1444  get_argument(theEnv, 4, arg4);
1445  get_argument(theEnv, 5, arg5);
1446  get_argument(theEnv, 6, arg6);
1447  get_argument(theEnv, 7, arg7);
1448  Value v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1449  set_return_value(theEnv, rv, v);
1450  return;
1451  }
1452  throw;
1453  }
1454 
1455  // **************************************************************************************
1456 
1457 
1458  inline
1459  void* Environment::strcallback( void* theEnv ) {
1460  sigc::slot0<std::string>* cb;
1461  void * cbptr = get_function_context( theEnv );
1462  if ( cbptr ) {
1463  if ( get_arg_count( theEnv ) != 0 )
1464  throw std::logic_error( "clipsmm/string: wrong # args on slot callback; expected 0" );
1465  cb = static_cast<sigc::slot0<std::string>*>( cbptr );
1466  return add_symbol( ( ( *cb ) ( )).c_str() );
1467  }
1468  throw;
1469  }
1470 
1471  template < typename T_arg1 >
1472  inline
1473  void* Environment::strcallback( void* theEnv ) {
1474  sigc::slot1<std::string,T_arg1>* cb;
1475  void * cbptr = get_function_context( theEnv );
1476  T_arg1 arg1;
1477  if ( cbptr ) {
1478  if ( get_arg_count( theEnv ) != 1 )
1479  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
1480  get_argument( theEnv, 1, arg1 );
1481  cb = static_cast<sigc::slot1<std::string,T_arg1>*>( cbptr );
1482  return add_symbol( ( ( *cb ) ( arg1 )).c_str() );
1483  }
1484  throw;
1485  }
1486 
1487  template < typename T_arg1, typename T_arg2 >
1488  inline
1489  void* Environment::strcallback( void* theEnv ) {
1490  sigc::slot2<std::string, T_arg1, T_arg2>* cb;
1491  void * cbptr = get_function_context( theEnv );
1492  T_arg1 arg1;
1493  T_arg2 arg2;
1494  if ( cbptr ) {
1495  if ( get_arg_count( theEnv ) != 2 )
1496  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
1497  get_argument( theEnv, 1, arg1 );
1498  get_argument( theEnv, 2, arg2 );
1499  cb = static_cast<sigc::slot2<std::string, T_arg1, T_arg2>*>( cbptr );
1500  return add_symbol( ( ( *cb ) ( arg1, arg2 )).c_str() );
1501  }
1502  throw;
1503  }
1504 
1505  template < typename T_arg1, typename T_arg2, typename T_arg3 >
1506  inline
1507  void* Environment::strcallback( void* theEnv ) {
1508  sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>* cb;
1509  void * cbptr = get_function_context( theEnv );
1510  T_arg1 arg1;
1511  T_arg2 arg2;
1512  T_arg3 arg3;
1513  if ( cbptr ) {
1514  if ( get_arg_count( theEnv ) != 3 )
1515  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
1516  get_argument( theEnv, 1, arg1 );
1517  get_argument( theEnv, 2, arg2 );
1518  get_argument( theEnv, 3, arg3 );
1519  cb = static_cast<sigc::slot3<std::string, T_arg1, T_arg2,T_arg3>*>( cbptr );
1520  return add_symbol( ( ( *cb ) ( arg1, arg2, arg3 )).c_str() );
1521  }
1522  throw;
1523  }
1524 
1525  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
1526  inline
1527  void* Environment::strcallback( void* theEnv ) {
1528  sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
1529  void * cbptr = get_function_context( theEnv );
1530  T_arg1 arg1;
1531  T_arg2 arg2;
1532  T_arg3 arg3;
1533  T_arg4 arg4;
1534  std::string s;
1535  if ( cbptr ) {
1536  if ( get_arg_count( theEnv ) != 4 )
1537  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
1538  get_argument( theEnv, 1, arg1 );
1539  get_argument( theEnv, 2, arg2 );
1540  get_argument( theEnv, 3, arg3 );
1541  get_argument( theEnv, 4, arg4 );
1542  cb = static_cast<sigc::slot4<std::string, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
1543  s = ( *cb ) ( arg1, arg2, arg3, arg4 );
1544  return add_symbol( s.c_str() );
1545  }
1546  throw;
1547  }
1548 
1549  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
1550  inline
1551  void* Environment::strcallback( void* theEnv ) {
1552  sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
1553  void * cbptr = get_function_context( theEnv );
1554  T_arg1 arg1;
1555  T_arg2 arg2;
1556  T_arg3 arg3;
1557  T_arg4 arg4;
1558  T_arg5 arg5;
1559  if ( cbptr ) {
1560  if ( get_arg_count( theEnv ) != 5 )
1561  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
1562  get_argument( theEnv, 1, arg1 );
1563  get_argument( theEnv, 2, arg2 );
1564  get_argument( theEnv, 3, arg3 );
1565  get_argument( theEnv, 4, arg4 );
1566  get_argument( theEnv, 5, arg5 );
1567  cb = static_cast<sigc::slot5<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
1568  return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5 )).c_str() );
1569  }
1570  throw;
1571  }
1572 
1573  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
1574  inline
1575  void* Environment::strcallback( void* theEnv ) {
1576  sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
1577  void * cbptr = get_function_context( theEnv );
1578  T_arg1 arg1;
1579  T_arg2 arg2;
1580  T_arg3 arg3;
1581  T_arg4 arg4;
1582  T_arg5 arg5;
1583  T_arg6 arg6;
1584  if ( cbptr ) {
1585  if ( get_arg_count( theEnv ) != 6 )
1586  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
1587  get_argument( theEnv, 1, arg1 );
1588  get_argument( theEnv, 2, arg2 );
1589  get_argument( theEnv, 3, arg3 );
1590  get_argument( theEnv, 4, arg4 );
1591  get_argument( theEnv, 5, arg5 );
1592  get_argument( theEnv, 6, arg6 );
1593  cb = static_cast<sigc::slot6<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
1594  return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 )).c_str() );
1595  }
1596  throw;
1597  }
1598 
1599  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
1600  inline
1601  void* Environment::strcallback( void* theEnv ) {
1602  sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
1603  void * cbptr = get_function_context( theEnv );
1604  T_arg1 arg1;
1605  T_arg2 arg2;
1606  T_arg3 arg3;
1607  T_arg4 arg4;
1608  T_arg5 arg5;
1609  T_arg6 arg6;
1610  T_arg7 arg7;
1611  if ( cbptr ) {
1612  if ( get_arg_count( theEnv ) != 7 )
1613  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
1614  get_argument( theEnv, 1, arg1 );
1615  get_argument( theEnv, 2, arg2 );
1616  get_argument( theEnv, 3, arg3 );
1617  get_argument( theEnv, 4, arg4 );
1618  get_argument( theEnv, 5, arg5 );
1619  get_argument( theEnv, 6, arg6 );
1620  get_argument( theEnv, 7, arg7 );
1621  cb = static_cast<sigc::slot7<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
1622  return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 )).c_str() );
1623  }
1624  throw;
1625  }
1626 
1627 template < typename T_return >
1628  inline
1629  bool Environment::add_function( std::string name, const sigc::slot0<T_return>& slot) {
1630  char retcode = get_return_code<T_return>( );
1631  char *argstring = get_function_restriction(name);
1632  sigc::slot0<T_return>* scb = new sigc::slot0<T_return>(slot);
1633  any holder = CLIPSPointer<sigc::slot0<T_return> >(scb);
1634  m_slots[name] = holder;
1636  const_cast<char*>( name.c_str() ),
1637  retcode,
1638  get_callback(slot),
1639  const_cast<char*>( name.c_str() ),
1640  argstring,
1641  ( void* ) scb ) );
1642  }
1643 
1644  template < typename T_return, typename T_arg1 >
1645  inline
1646  bool Environment::add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot) {
1647  char retcode = get_return_code<T_return>( );
1648  char *argstring = get_function_restriction<T_arg1>(name);
1649  sigc::slot1<T_return, T_arg1>* scb = new sigc::slot1<T_return, T_arg1>(slot);
1650  any holder = CLIPSPointer<sigc::slot1<T_return, T_arg1> >(scb);
1651  m_slots[name] = holder;
1653  const_cast<char*>( name.c_str() ),
1654  retcode,
1655  get_callback(slot),
1656  const_cast<char*>( name.c_str() ),
1657  argstring,
1658  scb ) );
1659  }
1660 
1661  template < typename T_return, typename T_arg1, typename T_arg2 >
1662  inline
1663  bool Environment::add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot) {
1664  char retcode = get_return_code<T_return>( );
1665  char *argstring = get_function_restriction<T_arg1,T_arg2>(name);
1666  sigc::slot2<T_return, T_arg1, T_arg2>* scb = new sigc::slot2<T_return, T_arg1, T_arg2>(slot);
1667  any holder = CLIPSPointer<sigc::slot2<T_return, T_arg1, T_arg2> >(scb);
1668  m_slots[name] = holder;
1670  const_cast<char*>( name.c_str() ),
1671  retcode,
1672  get_callback(slot),
1673  const_cast<char*>( name.c_str() ),
1674  argstring,
1675  scb ) );
1676  }
1677 
1678  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
1679  inline
1680  bool Environment::add_function( std::string name, const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot) {
1681  char retcode = get_return_code<T_return>( );
1682  char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3>(name);
1683  sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* scb =
1684  new sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>(slot);
1685  any holder = CLIPSPointer<sigc::slot3<T_return,T_arg1,T_arg2,T_arg3> >(scb);
1686  m_slots[name] = holder;
1688  const_cast<char*>( name.c_str() ),
1689  retcode,
1690  get_callback(slot),
1691  const_cast<char*>( name.c_str() ),
1692  argstring,
1693  scb )
1694  );
1695  }
1696 
1697  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
1698  inline
1699  bool Environment::add_function( std::string name, const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot) {
1700  char retcode = get_return_code<T_return>( );
1701  char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4>(name);
1702  sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* scb =
1703  new sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>(slot);
1704  any holder = CLIPSPointer<sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4> >(scb);
1705  m_slots[name] = holder;
1707  const_cast<char*>( name.c_str() ),
1708  retcode,
1709  get_callback(slot),
1710  const_cast<char*>( name.c_str() ),
1711  argstring,
1712  scb )
1713  );
1714  }
1715 
1716  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
1717  inline
1718  bool Environment::add_function( std::string name,
1719  const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot) {
1720  char retcode = get_return_code<T_return>( );
1721  char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(name);
1722  sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* scb =
1723  new sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(slot);
1724  any holder = CLIPSPointer<sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> >(scb);
1725  m_slots[name] = holder;
1727  const_cast<char*>( name.c_str() ),
1728  retcode,
1729  get_callback(slot),
1730  const_cast<char*>( name.c_str() ),
1731  argstring,
1732  scb )
1733  );
1734  }
1735 
1736  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
1737  inline
1738  bool Environment::add_function( std::string name,
1739  const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot) {
1740  char retcode = get_return_code<T_return>( );
1741  char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(name);
1742  sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* scb =
1743  new sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(slot);
1744  any holder = CLIPSPointer<sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> >(scb);
1745  m_slots[name] = holder;
1747  const_cast<char*>( name.c_str() ),
1748  retcode,
1749  get_callback(slot),
1750  const_cast<char*>( name.c_str() ),
1751  argstring,
1752  scb )
1753  );
1754  }
1755 
1756  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 >
1757  inline
1758  bool Environment::add_function( std::string name,
1759  const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot) {
1760  char retcode = get_return_code<T_return>( );
1761  char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(name);
1762  sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* scb =
1763  new sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(slot);
1764  any holder = CLIPSPointer<sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> >(scb);
1765  m_slots[name] = holder;
1767  const_cast<char*>( name.c_str() ),
1768  retcode,
1769  get_callback(slot),
1770  const_cast<char*>( name.c_str() ),
1771  argstring,
1772  scb )
1773  );
1774  }
1775 
1776 }
1777 
1778 
1779 #endif

Generated on Sat Apr 13 2013 10:04:52 for clipsmm by doxygen 1.8.1.1