---

cmdparam.h

Go to the documentation of this file.

#ifndef ___CMDPARAM_H___
#define ___CMDPARAM_H___

#include <stdio.h>
#include <string>
using std::string;

#include "ipc.h"
#include "stringparser.h"
#include "parameter.h"
#include "parametermap.h"
#include "expressionparser.h"


/***********************************************************************************/
/***********************************************************************************/
/* Legacy code support                                                             */
/* This should all be removed eventually                                           */
/* Do not use these definitions in new code.                                       */
   
typedef ParameterDefinition<>        ParamType;
typedef ParameterMap<ParamType>      BlackboardType;
typedef ExpressionParser<>           Parse;
typedef ParamStringParser<>          CmdParamStringParser;

/* The variable 'blackboard' was at one point a global variable, but
   it is now a dereferenced pointer to the global_blackboard so that
   the default blackboard may be set dynamically */
extern BlackboardType  global_blackboard;
extern BlackboardType* blackboard_ptr;
#define blackboard (*blackboard_ptr)
 
#define params_add_lower_bound_int(name,val)        blackboard.lookup(name).add_lower_bound(val)
#define params_add_upper_bound_int(name,val)        blackboard.lookup(name).add_upper_bound(val)
#define params_check_all()                          blackboard.check_all()
#define params_define_default_expr(name,val)        blackboard.lookup(name).add_default_expr(val)
#define params_define_doc(name,val)                 blackboard.lookup(name).add_doc(val)
#define params_define_param(name,type,constant,ptr) blackboard.define_param(ParamType(name,type,constant,ptr))
#define params_print_constants(fp)                  blackboard.print_constants(fp)
#define params_print_constants_doc(fp)              blackboard.print_constants_doc(fp)
#define params_print_parameters(fp)                 blackboard.print_parameters(fp)
#define params_print_parameters_doc(fp)             blackboard.print_parameters_doc(fp)
#define params_update_all_default_values()          blackboard.update_all_default_values(CmdParamStringParser(blackboard))
#define cmdparam_set(name,expr)                     blackboard.lookup(name).set(CmdParamStringParser(blackboard),expr)


#define cmdparam_changes_verbose ParameterDefinition<>::changes_verbose
 
/* Shortcuts to the parser.  For new code use a StringParser and/or StringArgs instead. */
#define PARSE_I(x) Parse(blackboard,x).cmdi()
#define PARSE_F(x) Parse(blackboard,x).cmdf()
#define PARSE_C(x) Parse(blackboard,x).cmds()


#define SETFNOBJ_DEFINE2(cargs,paramname,fnname) \
blackboard.lookup(#paramname).add_setfn(new setfnobj2_ ## fnname(cargs))
  
#define SETFN_DEFINE2(paramname,fnname)                     \
SETFNOBJ_DEFINE2(,paramname,fnname)


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


/* Current recommended way to define a parameter.  Bounds can go as C
   code in options.  The parameter is allocated internally, and does
   not refer to an external value.  */ 
#define DECLARE_A(name_str,is_constant,initial_value) \
BlackboardType::ParamType(allocating_Polymorph(initial_value),name_str,is_constant)

#define PARAM_A(bboard,name_str,initial_value,options,doc) \
bboard.define_param(DECLARE_A(name_str,false,initial_value).add_doc(doc)options)



/*    Typical ways to declare parameters for external values

  To use these macros, first define a type "BlackboardType" compatible
  with ParameterMap<> and a variable "blackboard" of this type.
  The blackboard need not be the global one above; a local variable
  with the same name will also work.
*/

#define DECLARE_PARAM(type,name_str,is_constant,location) \
BlackboardType::ParamType(make_Polymorph(location),name_str,is_constant)
//BlackboardType::ParamType(name_str,type,is_constant,(void*)location)

#define PARAM(type,name,location) \
DECLARE_PARAM(type,#name,false,location)

#define PARAM_NN(type,name,location,doc) \
blackboard.define_param(PARAM(type,name,location).add_doc(doc))

#define PARAM_LL(type,name,location,lower,doc) \
blackboard.define_param(PARAM(type,name,location).add_doc(doc).add_lower_bound(lower))

#define PARAM_II(type,name,location,lower,upper,doc) \
blackboard.define_param(PARAM(type,name,location).add_doc(doc).add_lower_bound(lower).add_upper_bound(upper))


/* Deprecated versions: Same as above but assumes C variable name same as param */
#define PARAM_N(type,name,doc) \
blackboard.define_param(PARAM(type,name,&name).add_doc(doc))
#define PARAM_L(type,name,lower,doc) \
blackboard.define_param(PARAM(type,name,&name).add_doc(doc).add_lower_bound(lower))
#define PARAM_I(type,name,lower,upper,doc) \
blackboard.define_param(PARAM(type,name,&name).add_doc(doc).add_lower_bound(lower).add_upper_bound(upper))


/*
  Typical ways to declare symbolic constants, allocating local storage
  for them.  Unless is_param is true, the value of the constant is not
  saved when params are saved to a file.
*/
     
#define CONST_I(name,value,is_param,doc)                                                 \
{ static int paramstorage=value;       \
  blackboard.define_param(DECLARE_PARAM(PARAM_INT,#name,!is_param,&paramstorage).add_doc(doc).add_lower_bound(value).add_upper_bound(value)); }


#define CONST_B(name,value,is_param,doc)   \
{ static Tristate paramstorage=value;       \
  blackboard.define_param(DECLARE_PARAM(PARAM_3BOOL,#name,!is_param,&paramstorage).add_doc(doc).add_lower_bound(value).add_upper_bound(value)); }


#define CONST_F(name,value,is_param,doc) \
{ static double paramstorage=value;       \
  blackboard.define_param(DECLARE_PARAM(PARAM_DOUBLE,#name,!is_param,&paramstorage).add_doc(doc).add_lower_bound(value).add_upper_bound(value)); }


#define CONST_S(name,is_param,doc) \
{ static string paramstorage=#name; \
  blackboard.define_param(DECLARE_PARAM(PARAM_USTRING,#name,!is_param,&paramstorage).add_doc(doc)); }




#define CMD_MAX_ARGUMENTS     512

#define CMD_MAX_LINE_LENGTH  16384


/*
  Command return codes 

  If successful, the command may return any non-negative integer
*/
typedef int cmdstat; 
#define CMD_NO_ERROR              0
#define CMD_FATAL_ERROR      -20000
#define CMD_MISC_ERROR       -20001
#define CMD_FILE_ERROR       -20002
#define CMD_PARAMETER_ERROR  -20003
#define CMD_MEMORY_ERROR     -20004
#define CMD_PREREQ_ERROR     -20005
#define CMD_EMPTY            -20006  
#define CMD_PARSE_ERROR      -20007  
#define CMD_NEVER_CALLED     -20008  
#define CMD_SIGINT_ERROR     -20009  
#define CMD_SHELL_ERROR      -20010  
/* Standard interface to commands */
#define CMD_ARGS        int argc, const char *argv[]
#define CMD_ARGS_DECL   int argc=0, const char *argv[]=0
#define CMD_UNUSED_ARGS int, const char *[]
#define CMD_CALL_ARGS    argc,argv
typedef cmdstat (*commandfunptr)( CMD_ARGS );


class CmdWrapper {
public:
  CmdWrapper() { }
  virtual ~CmdWrapper() { }
  virtual cmdstat operator() ( CMD_ARGS_DECL )=0;
};


#define CMD_HEADER(name) \
cmdstat cmd_ ## name ( CMD_ARGS_DECL )


#define CMD_DECLARE(name)                                 \
cmdstat cmd_ ## name ( CMD_ARGS );                         \
struct cmdobj_ ## name : public CmdWrapper {                \
  cmdstat operator() ( CMD_ARGS_DECL ) {                     \
    return cmd_ ## name(CMD_CALL_ARGS);                       \
  }                                                            \
}


#define CMDOBJ_DOC(name,prereq,cargs,numargs,usage,doc)                \
cmddefs_define_command(#name,new cmdobj_ ## name(cargs),numargs,False); \
cmddefs_define_command_doc(#name,usage,doc);                             \
cmddefs_define_command_prereq(#name,prereq)


#define CMD_DOC(name,prereq,numargs,usage,doc) \
CMDOBJ_DOC(name,prereq,,numargs,usage,doc)


#define CMDOBJ_DEFINE_CATCHUP(cargs,numargs,name,usage,doc)          \
cmddefs_define_command(#name,new cmdobj_ ## name(cargs),numargs,True); \
cmddefs_define_command_doc(#name,usage,doc)


#define CMD_DEFINE_CATCHUP(numargs,name,usage,doc) \
CMDOBJ_DEFINE_CATCHUP(,numargs,name,usage,doc)


#define CMDOBJ_DECLARE(Owner,name)                        \
cmdstat cmd_ ## name ( CMD_ARGS_DECL );                    \
class cmdobj_ ## name : public CmdWrapper {                 \
  Owner* owner;                                              \
public:                                                       \
  cmdobj_ ## name (Owner* owner_i) : owner(owner_i) { };       \
  cmdstat operator() ( CMD_ARGS_DECL ) {                        \
    return owner->cmd_ ## name (CMD_CALL_ARGS);                  \
  }                                                               \
};                                                                 \
friend class cmdobj_ ## name



typedef int (*CmdDefs_LineGenerator)( void );
extern char cmddefs_line_buffer[CMD_MAX_LINE_LENGTH+1+sizeof(int)];
     
typedef int HooklistNum; 

/* Global variables */
extern int command_num_called;



/* Commands */
CMD_HEADER(set);
CMD_HEADER(hook);



/* Misc public functions */
char*  cmdparams_completion_generator(char *text, int state);
void   cmdparam_init_hook(void);
int    cmdparams_print_doc(FILE *fp, const char* name);
int    cmdparam_save_current_state(const char * filename);
char*  cmdparam_dupstr (const char *str);
bool   cmdparams_set_single( BlackboardType& params, const string& arg,
                             bool& seterror, bool mark=true,
                             bool verbose=ParamType::changes_verbose,
                             bool copysetfn=true);
cmdstat cmdparams_set(       BlackboardType& params, StringArgs& arglist,
                             bool mark=true, bool warn=false,
                             bool verbose=ParamType::changes_verbose,
                             bool copysetfn=true);

char*  params_completion_generator (char *text, int state);

char*  cmddefs_completion_generator (char *text, int state);
void   cmddefs_declare_prereq_status(   const char * name, cmdstat status );
void   cmddefs_define_command( const char* name, CmdWrapper* function, int minargs, int exec_for_catchups );
void   cmddefs_define_command_doc( const char* name, const char *usage, const char *doc );
void   cmddefs_define_command_prereq( const char* name, const char *prereq );
int    cmddefs_exec_batch(CmdDefs_LineGenerator fn, const char * description);
int    cmddefs_exec_file(const char *filename);
cmdstat cmddefs_exec_by_name(const char* name, CMD_ARGS);
cmdstat cmddefs_exec_str(const char* cmdtxt);
inline cmdstat cmddefs_exec_str(const string& cmdtxt) {  return cmddefs_exec_str(cmdtxt.c_str());  }
int    cmddefs_num_total(void);
void   cmddefs_print_all(FILE *fp);
void   cmddefs_print_all_doc(FILE *file);
void   cmddefs_print_doc(FILE *fp, const char* name);
void   cmddefs_print_doc_for_index(FILE *fp, int idx);

void   hooklists_empty_list(HooklistNum hooklistnum);
void   hooklists_reset_list(HooklistNum hooklist);
void   hooklists_run_list(HooklistNum hooklist, int counter, int catchuponly);
int    hooklists_define_list( const char * listname, const char *countername );


/*
  Temporary glue between older argc,argv style of command invocation
  and cleaner vector<string> style. Use like:
  <pre>
    cmdstat cmd_commandname( CMD_ARGS )
    {
      CMD_ARG_LIST;
      const string name = arglist.next(string(""));
      // Body of command      
    }
  </pre>
*/
#define CMD_ARG_LIST \
  StringParser::arglist argl(&argv[0],&argv[argc]);\
  const CmdParamStringParser p(blackboard);\
  StringArgs arglist(p, argl.begin(), argl.end())


/* Call if the argument list should be entirely empty */
#define CMD_ARG_ASSERT_UNUSED \
  {  (void)argv; if (argc) ipc_notify(IPC_ONE,IPC_WARNING,"All arguments are ignored");  }



#define CMD_ARG_PARAMS(name) \
  CMD_ARG_LIST;\
  BlackboardType argparams(&blackboard.lookup_map("::cmd::" #name),"arguments");\
  cmdparams_set( argparams,arglist,true,false,false,false)


#define CMD_ARG_ASSERT_EMPTY {\
  if (!arglist.empty()) {\
    const string rep = arglist.stringrep();\
    ipc_notify(IPC_ONE,IPC_WARNING,"Unused arguments: %s",rep.c_str());}}


#endif /* ___CMDPARAM_H___ */

---