---

cmdparam.c

Go to the documentation of this file.

#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <ctype.h>
#include <math.h>
#include <string>
using std::string;
#include <stack>
#include <vector>
#include <strstream.h>
#include <fstream>
using std::vector;

/* If enabled, assume POSIX-compliant signal/longjump handling (via sigsetjmp) */
#ifndef NO_SIGNAL_HANDLING
#include <signal.h>
#include <setjmp.h>
#endif

#include "ipc.h"
#include "cmdparam.h"
#include "stringutils.h"
#include "polymorph.h"


#ifdef EXPLICIT_INSTANTIATION_FOR_STATICS
template class PolymorphBase<Tristate>;
template class PolymorphBase<int>;
template class PolymorphBase<double>;
template class PolymorphBase<string>;
template class ParameterDefinition<int>;
#endif 



/******************************************************************************/
/* Defines and typedefs                                                       */
/******************************************************************************/

/* Determine which PE is in charge of file handling */
#define PARENTPE (0)
#define AMPARENTPE (ipc_my_process()==PARENTPE)


/* Command definitions */

#define CMDDEF_MAX_NUM         64   
#define CMDDEF_MAX_NAME_LENGTH 64   
#define CMDDEF_MAX_PREREQS      2   
/* Holds a single command definition. */
struct CommandDefinition {
  char name[CMDDEF_MAX_NAME_LENGTH+1]; 
  CmdWrapper* function;             
  int minargs;                      
  int catchup;                      
  int num_prereqs;                  
  int prereqs[CMDDEF_MAX_PREREQS];  
  int callstatus;                   
  const char *usage;                
  const char *doc;                  
  BlackboardType* params;
  BlackboardType& parameters() {  assert(params);  return *params;  }
  ~CommandDefinition()         {  delete params;  }
};

/* Holds all the command definitions. */
typedef struct{                     
  int num;
  CommandDefinition list[CMDDEF_MAX_NUM];
}CommandDefinitionBlackboard;

/* Holds a single command instance. */
typedef struct{
  int  argc;                            
  const char *argv[CMD_MAX_ARGUMENTS];  
  CommandDefinition* def;               
}Command;

#define CMD_CALL(cmd) (*((cmd).def->function))((cmd).argc, (cmd).argv)


/* Counter hook definitions */

/* Holds a command to be executed at a specified counter value. */
typedef struct
{
  int  start;     
  int  end;       
  int  step;      
  int  order;     
  char *argstofree[CMD_MAX_ARGUMENTS+1];  
  Command cmd;    
} CounterHookDefinition;

#define HOOKLIST_MAX_NUM      128  
#define HOOKLIST_MAX_NAME_LENGTH  32

/* Holds a sorted list of the specified counter hooks of a given type. */
typedef struct
{
  char name[HOOKLIST_MAX_NAME_LENGTH]; 
  char countername[HOOKLIST_MAX_NAME_LENGTH]; 
  int current;                         
  int num;                             
  CounterHookDefinition defs[HOOKLIST_MAX_NUM]; 
} CounterHooklist;

#define HOOKLISTS_MAX_NUM 4

#define HAS_CURRENT_HOOK(hooklist) ((hooklist).current < (hooklist).num)
#define CURRENT_HOOK(hooklist)     ((hooklist).defs[(hooklist).current])

/* Holds all the counter Hooklists. */
typedef struct
{
  int num;        
  CounterHooklist lists[HOOKLISTS_MAX_NUM]; 
} CounterHooklists;


/* Temporary list of command names and corresponding prerequisites,
   to store the info until the commands have all been defined.
*/
typedef struct
{
  int num;        
  const char* names[CMDDEF_MAX_NUM*CMDDEF_MAX_PREREQS];
  const char* prereqs[CMDDEF_MAX_NUM*CMDDEF_MAX_PREREQS];
} PrereqList;



/******************************************************************************/
/* Global variables                                                           */
/******************************************************************************/

CounterHooklists hooklists;

BlackboardType  global_blackboard;                
BlackboardType* blackboard_ptr=&global_blackboard;
BlackboardType blackboard_for_commands(&blackboard,"cmd"); 
CommandDefinitionBlackboard command_definitions;  
int commands_succeeded = 0;                       /* So far                 */
int commands_failed    = 0;                       /* So far                 */
int command_num_called = 0;                       /* unique global counter  */

int hook_definition_counter=0;                    /* unique global counter  */
int cmdparam_warn_unknown=true;
double command_msg_time=1.0;


FILE *cmddefs_file=NULL;
string commandpath = "../command/ ../../command/ ../samples/ ../ /usr/local/lissom/command/";


std::stack<StringParser::arglist> cmddefs_exec_file_arglists;  
char cmddefs_line_buffer[CMD_MAX_LINE_LENGTH+1+sizeof(int)];

PrereqList prereq_storage;


#ifndef NO_SIGNAL_HANDLING
typedef void (*signal_handler_type)(int);
sigjmp_buf jmp_env;
#endif



/******************************************************************************/
/* Prototypes for private functions                                           */
/******************************************************************************/

CMD_DECLARE(call);
CMD_DECLARE(clear_hooks);
CMD_DECLARE(define_param);
CMD_DECLARE(define_param_set);
CMD_DECLARE(select_param_set);
CMD_DECLARE(param_default);
CMD_DECLARE(dotimes);
CMD_DECLARE(exec);
CMD_DECLARE(exec_catchup);
CMD_DECLARE(exec_file);
CMD_DECLARE(for);
CMD_DECLARE(hook);
CMD_DECLARE(if);
CMD_DECLARE(echo);
CMD_DECLARE(print);
CMD_DECLARE(quit);
CMD_DECLARE(read_args);
CMD_DECLARE(set);
CMD_DECLARE(system);

size_t  cmdparam_identifier_length(const char* str);
void    ipc_init_hook( void );

int     cmddef_compare(const void* hook1, const void* hook2);
void    cmddefs_sort(void);
int     cmddefs_get_line_from_file( void );

int     command_check_usage(Command* command);
cmdstat command_exec(Command *cmd);
CommandDefinition* cmddefs_lookup(const char *name);
int     command_parse_line(Command *command, char *string);
const char* command_parse_token(char** remaining);
void    command_print_to_str( const Command *cmd, char *str, size_t nchars);
void    cmddef_print_usage(FILE *fp, const CommandDefinition* cmddef);
void    cmddef_print_usage_to_str(const CommandDefinition* cmddef, char *str, size_t nchars);
void    cmddefs_activate_prereqs( void );
void    cmddefs_activate_command_prereq( const char* name, const char *prereq );

int     hook_compare(const void* hook1, const void* hook2);
void    hook_copy( CounterHookDefinition *source, CounterHookDefinition *dest);
void    hooklists_log(void);
int     hook_parse_specifier( CounterHookDefinition *hook, Parse& parser );
void    hook_print_to_str( CounterHookDefinition *hook, char *hooklistname, char *str, size_t nchars);
void    hooklists_sort(HooklistNum hooklist);



#ifndef NO_SIGNAL_HANDLING
void command_exec_sigint_handler( int sig );
#endif



/******************************************************************************/
/* Initialization hook                                                        */
/******************************************************************************/

void  cmdparam_init_hook( void )
{
  ipc_init_hook();

  /* Commands provided by this file */
  
  CMD_DOC(clear_hooks,NULL,0,"%s [<hook_list>]*",
          "Delete all the currently-defined hooks in the given list(s), or delete\n"
          "all hooks in all lists if no lists are specified.");

  CMD_DOC(define_param,NULL,2,"%s [<path>::]<name> <type> [<lowbound> [<highbound> [<helpstring>] [<initialvalue>]]]",
          "Define a new parameter of the given type.  Space for the parameter is\n"
          "immediately allocated from the heap, but it is not initialized until\n"
          "the parameter is set unless an initial value is supplied.  Available <types>\n"
          "include Integer, Float, Boolean, and String.  The <highbound> is ignored if\n"
          "it is lower than the <lowbound>.  Calling this command multiple times for\n"
          "the same <name> is not an error unless the type differs, but the bounds,\n"
          "<helpstring>, and <initialvalue> are only installed on the first call.\n"
          "Note: The <lowbound> and <highbound> are currently truncated to integers,\n"
          "but for Float parameters this restriction may be relaxed in future");

  CMD_DOC(define_param_set,NULL,1,"%s [<path>::]<name>",
          "Define a new set of parameters rooted at the given path, which defaults to\n"
          "the global set of parameters.  Useful in e.g. scripts to avoid conflicts\n"
          "with any global parameters that may be defined.  Calling this command\n"
          "multiple times with the same arguments> is not an error, but has no effect.");

  CMD_DOC(select_param_set,NULL,0,"%s [<path>::]",
          "Make the specified set of parameters (previously defined with\n"
          "define_param_set) be the default for all operations.  With no arguments makes\n"
          "the previous parameter set (or root if none) be the default.");

  CMD_DOC(param_default,NULL,2,"%s <name> <expression>",
          "For a existing parameter <name>, declare that if the user has not explicitly\n"
          "set this parameter (using the set command) by the time init_network\n"
          "is called, the program should then evaluate the given expression (i.e.\n"
          "anything accepted by the set command) to determine the value for that\n"
          "parameter.\n\n"
          
          "The global order of evaluation of default expressions is undefined, and thus\n"
          "no expression should refer to any other parameter that also has a default\n"
          "expression defined. (In that case the resulting values would depend on the\n"
          "order of evaluation of the default expressions, and would be undefined.)");

  CMD_DOC(dotimes,NULL,2,"%s <expr> <command> [<argument>]*",
          "Execute the given command with the given arguments, the number of times\n"
          "specified by the given numeric expression.");

  CMD_DOC(for,NULL,3,"%s <param>=<initvalue> <test-expr> <param>=<incrementvalue> [<command> [<argument>]*]",
          "Execute the given command with the given arguments a number of times.\n"
          "First, the first param-value pair is passed to the set command, then as\n"
          "long as the numeric <test-expr> evaluates to a true value, the given command\n"
          "is executed and the second param-value pair is passed to the set command.\n"
          "Example: `define_param angle Param_Integer', then\n"
          "`for angle=0 angle<180 angle=angle+10 print angle'.");

  CMD_DOC(if,NULL,2,"%s <expr> <command> [<argument>]*",
          "If the given numeric expression evaluates to a non-zero value, execute\n"
          "the given command with the given arguments.");

  CMD_DOC(call,NULL,1,"%s <filename> [<param>=<value>]*",
          "Same as exec_file, but suppresses verbose parameter change and other\n"
          "messages.  This is intended for calling a file as a procedure, where only\n"
          "error reporting is usually desired.  The output would otherwise be very\n"
          "verbose if the file contains a long loop or calls other files repeatedly.");

  CMD_DOC(exec_file,NULL,1,"%s <filename> [<param>=<value>]*",
          "Execute the given command file.  The parameter settings included on the\n"
          "command line will be saved but not evaluated until a read_args command\n"
          "is called within the command file.  Also see the help for read_args.");

  CMD_DOC(exec,NULL,1,"%s [<command-string>]*",
          "Execute the commands specified by the given strings, in order.  Before being\n"
          "executed, each string is interpreted for string substitutions as for the set\n"
          "command for string parameters, so it's possible to use constructions like\n"
          "`exec \"${command}\" \"set x=y\"'.");

  CMD_DEFINE_CATCHUP(1,exec_catchup,"%s [<command-string>]*",
          "Same as exec, but never skipped when catching up to a new iteration.  Useful\n"
          "to force execution of a hook which would otherwise be skipped.");

  CMD_DOC(echo,NULL,1,"%s <string>*",
          "Displays the given strings, each on a new line, after string substitution.");

  CMD_DOC(print,NULL,1,"%s <expression>*",
          "Displays the value of the given expression(s), which can either be the name of\n"
          "any parameter (preceded by a dollar sign (`$') if desired), or an arbitrary\n"
          "numeric expression allowed as a <value> by the set command.  Examples: \n"
          "`print filename', `print 2*radius-1'.");

  CMD_DOC(read_args,NULL,0,"%s [<parent>]",
          "If called within a file executed using the exec_file or call commands,\n"
          "evaluates the arguments supplied when the file was originally called (if any).\n"
          "The evaluation is done using the set command, called within the <parent>'s\n"
          "set of parameters.  This command provides a rudimentary form of argument\n"
          "passing to allow command files to be used like procedures.  Trivial example\n"
          "(e.g. in a file named `countup.command'):\n\n"
          
          "  define_param n Param_Integer # Declare argument(s)\n"
          "  set n=10                     # Default value\n"
          "  read_args                    # Read argument(s)\n\n"

          "  define_param i Param_Integer # Declare global variable to be used as a local\n"
          "  for i=0 i<n i=i+1 print i    # Actually do something\n\n"

          "If this file is called as `exec_file countup.command n=5', it will print\n"
          "out the numbers less than 5 (amidst various \"helpful\" debugging messages).\n"
          "Of course, since all parameters are currently globals, be careful\n"
          "not to assume the procedures act like safer ones offered by a more powerful\n"
          "language.");
  // Actually, it wouldn't be particularly difficult to fix this problem --
  // a new parameter set could just be created within the current parameter set, then
  // deleted on exit from exec_file.  That would act as an environment for local
  // variables to be defined in.  However, it would mean fixing all currently extant
  // scripts to put what they intend to be globals in :: instead of assuming that
  // variable accesses will always access globals.
  

  CMD_DEFINE_CATCHUP(1,set,"[%s] [[[::]<path>::]<name>=<value>]+",
                     "Allows any parameter to be set to an arbitrary value, within the type\n"
                     "and range of that parameter.  The keyword 'set' can be omitted.  \n"
                     "Multiple pairs of names and values are acceptable as long as the\n"
                     "CMD_MAX_ARGUMENTS limit is not reached.  Values may not contain spaces\n"
                     "unless the entire triple ('x=y') or the value (x='y') are enclosed in\n"
                     "quotes.  The path may contain the name of a particular set of parameters\n"
                     "to use; it is often omitted, in which case the global set is used.\n"
                     "Parameter set names in the path may start and/or end with a wildcard\n"
                     "('*'), in which case all sets of parameters matching at that level\n"
                     "are searched for parameters to set.  If the path starts with :: the\n"
                     "value is searched from the toplevel (root) parameter set.\n\n"

                     "If the <value> is surrounded by backquotes (`...`), it is evaluated for\n"
                     "string substitution and then passed to the system shell as a command, and\n"
                     "the output of that command is used as the <value> instead.  This evaluation\n"
                     "requires a temporary file, and is not truly multi-processor or multi-process\n"
                     "safe because the file names from different processes may (in rare cases)\n"
                     "conflict.\n\n"
                     
                     "The <value> for a parameter of String type may contain references to\n"
                     "other parameters if preceded by a dollar sign (`$') and (optionally)\n"
                     "enclosed in braces.  Non-string parameter values are printed to a\n"
                     "simple string representation.  Example: `set filename=\n"
                     "${filename}_${angle}_A' might set it to `oldname_76.5_A'.\n\n"
                     
                     "If you wish to control the printing format used, you may supply\n"
                     "flags in approximately the format accepted by the C printf command\n"
                     "for the appropriate datatype, just before the parameter name.  Example:\n"
                     "`set filename=${filename}_${06.2angle}_A' might set it to\n"
                     "`oldname_076.50_A', if angle is 76.5.\n\n"
                     
                     "As an extension to the C printf-style formatting, conditional text\n"
                     "expansion is supported.  Given a value like `${?param,text}', the\n"
                     "expansion will be `text' unless `param' is numeric and zero, or\n"
                     "non-numeric and expanding to the empty string.  If `,text' is omitted,\n"
                     "the expansion will be the parameter value itself. Example:\n"
                     "`set filename=${filename}${?plotname,_}${plotname}' might set the\n"
                     "filename to `oldname_Plot', if plotname is Plot, or `oldname' if\n"
                     "plotname is "". Or `set filename=${filename}${?angle,_}${?06.2angle}_A'\n"
                     "might set filename to `oldname_076.50_A', if angle is 76.5, or `oldname_A'\n"
                     "if angle is zero.\n\n"
                     
                     "The <value> for numeric types (Integer, Float, and Boolean) may be an\n"
                     "expression matching the following (recursive) grammar:\n\n"
                     
                     "   <term>  == <number>|<paramname>|(<value>)\n"
                     "   <value> == <term>[<binop><value>]\n"
                     "   <binop> == +|-|*|/|%|<|>|==|!=|<=|>=|<?|>?|@;|@:\n\n"

                     "Thus a literal numeric value will suffice, or else an infix arithmetic\n"
                     "expression like `RN' or `i/2' or `RN/2.5*(N-1)' or `RN%8' can be used,\n"
                     "where i, RN, and N are parameters whose current value will be substituted\n"
                     "before evaluation.\n\n"

                     "The operators <binop> are as defined in ANSI C, except as noted here and\n"
                     "below.  The >? and <? operators are borrowed from GNU C++; they take the\n"
                     "maximum and the minimum of their arguments, respectively.  The @; and @:\n"
                     "operators were invented as a bizarre but useful hack; they multiply the\n"
                     "left argument by the sine or cosine of the right argument, respectively.\n\n"

                     "The `*', `/', and `%%' operators are equal in precedence and are greater\n"
                     "in precedence than all the others; otherwise evaluation occurs from left\n"
                     "to right.  Thus simple arithmetic expressions will have the same\n"
                     "interpretation as in C, but parentheses should be used liberally on\n"
                     "anything complicated (particularly for comparisons) to ensure that they\n"
                     "are calculated correctly.\n\n"
                     
                     "All intermediate numeric results are of type double (or long double,\n"
                     "if available), which is then rounded (not truncated) to an integer.\n"
                     "Thus expression values involving e.g. integer division may differ from\n"
                     "their C equivalents, but this is usually an improvement.\n\n"

                     "Boolean variables have numeric types, but the symbolic values True,\n"
                     "False, Yes, No, and Uninitialized are accepted as standing for 1,0,1,0,\n"
                     "and -1, respectively.  Boolean expressions like ((x<0)||(x>N))&&C can be\n"
                     "computed by writing their arithmetic equivalent, e.g. `((x<0)+(x>N))*C',\n"
                     "as long as none of the Boolean variables are Uninitialized.");

  CMD_DOC(system,NULL,1,"%s <shell-command> [<shell-command-arg>]*",
                     "Execute the given system shell command (e.g. `ls -l file').  Arguments\n"
                     "which require quoting should be enclosed in single quotes surrounded by\n"
                     "double quotes, e.g. `ls -l \"'file with spaces'\"', or vice versa.\n"
                     "Parameter values may be used in arguments if preceded by a dollar sign, as\n"
                     "for string parameters in the `set' command.  Consequently, shell variables\n"
                     "cannot be used in arguments; if this were to present a problem, \n"
                     "the system command (or cmdi) could be rewritten to suppress variable\n"
                     "substitution if it detects embedded single quotes.");

  CMD_DOC(quit,NULL,0,"%s [<exit-message>]",
                     "Exit from the program with no error condition.");

  CMD_DEFINE_CATCHUP(3,hook,"%s <hook_list> <counter_specifier> <command> [<argument>]*",
                     "This command allows you to specify that the given command should be\n"
                     "executed at location <hook_list> when a counter reaches the value\n"
                     "specified by the <counter_specifier>, where the <counter_specifier>\n"
                     "is of the (recursive) form:\n\n"

                     "   <counter_start>[-<counter_end>[%<step>]][,<counter_specifier>]\n\n"

                     "For example, the <counter_specifier> can be\n"
                     "a single value ((e.g.  1000), a range of values (e.g.  1-1000), a\n"
                     "range with a stepsize (e.g.  1-1000%%10), or a list of any of these\n"
                     "(e.g. 1,10,100-200%%20,7,50-60).\n\n"

                     "For a given hook_list and counter value, all the hooks that apply\n"
                     "are executed in the order of their counter_start and (if those\n"
                     "match) the order in which they were defined.");


  PARAM_N(PARAM_USTRING,commandpath,
          "Space-separated list of paths to search for command files.  The current\n"
          "directory is always searched first.");

  PARAM_N(PARAM_DOUBLE,command_msg_time,
          "If a command takes longer than this time (in seconds) to execute, the time\n"
          "taken will be displayed when the command completes.");

  PARAM_L(PARAM_INT, command_num_called,0,
          "Read-only parameter returning the number of commands called so far this\n"
          "run; is incremented whenever a command is executed.  Primarily useful for\n"
          "constructing the command prompt.");

  PARAM_A(blackboard,"squote",string("'"),,
          "Read-only parameter holding a single quote mark ('); used for hairy string\n"
          "substitution tricks.");
  
  PARAM_A(blackboard,"dquote",string("\""),,
          "Read-only parameter holding a double quote mark (\"); used for hairy string\n"
          "substitution tricks.");
  
  blackboard.init_hook();
  ipc_init_hook();

  /* For pretty */
  Polymorph<Tristate>::set_typestring("Boolean");
  Polymorph<int>::set_typestring("Integer");
  Polymorph<double>::set_typestring("Float");
  Polymorph<string>::set_typestring("String");

  /* Old comment: any parameters defined after this point must be
     defined using cmd_define_param.  No longer clear why that would
     have to be true, except for niceties like sorting lists of
     parameters.  */

  cmddefs_sort(); /* For pretty */
  cmddefs_activate_prereqs(); /* No more cmddefs sorting allowed after this,
                                 since each command keeps the index of others as prereqs. */

  /* Any parameters defined after this point must be defined using cmd_define_param (Why?) */
}



void  ipc_init_hook( void )
{
  PARAM_I(PARAM_INT, ipc_msg_level,          IPC_NONE,IPC_OVERWHELM,          ipc_msg_level_docstring);
  PARAM_I(PARAM_INT, ipc_msg_forceall_level, IPC_NONE,IPC_OVERWHELM, ipc_msg_forceall_level_docstring);
  PARAM_I(PARAM_INT, ipc_msg_synch_level,    IPC_NONE,IPC_OVERWHELM,    ipc_msg_synch_level_docstring);
  PARAM_L(PARAM_INT, ipc_exit_on_error_num,0,                         ipc_exit_on_error_num_docstring);
  PARAM_L(PARAM_INT, ipc_max_warnings,0,                                   ipc_max_warnings_docstring);
  PARAM_L(PARAM_INT, ipc_max_errors,0,                                       ipc_max_errors_docstring);

  CONST_I(IPC_None,      IPC_NONE,     False,
          "Symbol representing `no message'.  Ordinarily, no message should be declared\n"
          "with a level this high, and then this level may be used to turn off all\n"
          "messages.");

  CONST_I(IPC_Error,     IPC_ERROR,    False,
          "Symbol representing `error message'.  It should be used for a fairly serious\n"
          "problem, e.g. one which causes the current computation to be aborted.");

  CONST_I(IPC_Warning,   IPC_WARNING,  False,
          "Symbol representing `warning message'.  It should be used for a condition\n"
          "that is clearly bad but which won't stop computation from proceeding, e.g.\n"
          "if a meaningful default value can be used in place of an out-of-range\n"
          "parameter.");

  CONST_I(IPC_Caution,   IPC_CAUTION,  False,
          "Symbol representing `caution message'.  It should be used for a condition that\n"
          "is probably bad but which is common enough not to be worth tabulating in total\n"
          "warning counts.");
  
  CONST_I(IPC_Alert,     IPC_ALERT,    False,
          "Symbol representing `alert message'.  It is primarily a placeholder, marking\n"
          "all higher message levels as being in the `alert' category instead of merely\n"
          "informational.  It may also be used for any particularly important message\n"
          "which should almost never be suppressed.");

  CONST_I(IPC_Requested, IPC_REQUESTED,False,
          "Symbol representing `user-requested message'.  It should be used for messages\n"
          "that a user has requested specifically, and thus which should not ordinarily\n"
          "be turned off.");

  CONST_I(IPC_Summary,   IPC_SUMMARY,  False,
          "Symbol representing `summary message'.  It should be used for messages that\n"
          "are particularly important but which do not report an anomalous condition.");

  CONST_I(IPC_Std,       IPC_STD,      False,
          "Symbol representing `standard message'.  It should be used for messages that\n"
          "a user will probably want to see for every run.");

  CONST_I(IPC_Verbose,   IPC_VERBOSE,  False,
          "Symbol representing `verbose message'.  It should be used for messages which\n"
          "a user will probably want to see only when requested.");

  CONST_I(IPC_Overwhelm, IPC_OVERWHELM,False,
          "Symbol representing `overwhelming amount of messages'.  It should be used\n"
          "for debugging messages and similar trivia that may generate a lot of output.");
}



/******************************************************************************/
/* Parameter-handling routines                                                */
/******************************************************************************/

/******************************************************************************/
/* Command-file processing                                                    */
/******************************************************************************/


void cmddefs_define_command( const char* name, CmdWrapper* function, int minargs, int exec_for_catchups )
{
  if (command_definitions.num >= CMDDEF_MAX_NUM)
    ipc_notify(IPC_ONE,IPC_WARNING,"Command blackboard is full; can't add entry for %s",name);
  else if (strlen(name)!=cmdparam_identifier_length(name))
    ipc_notify(IPC_ALL,IPC_WARNING,"Invalid characters in command name; can't define it");
  else if (minargs > CMD_MAX_ARGUMENTS) 
    ipc_notify(IPC_ONE,IPC_ERROR,"Command %s expects too many arguments (%d > %d); can't define it",
               name, minargs,(int)CMD_MAX_ARGUMENTS);
  else {
    CommandDefinition& newcmd = command_definitions.list[command_definitions.num];
    strncpy(newcmd.name, name,CMDDEF_MAX_NAME_LENGTH);
    newcmd.function    = function;
    newcmd.minargs     = minargs;
    newcmd.catchup     = exec_for_catchups;
    newcmd.usage       = NULL;
    newcmd.doc         = NULL;
    newcmd.num_prereqs = 0;
    newcmd.callstatus  = CMD_NEVER_CALLED;
    newcmd.params      = new BlackboardType(&blackboard_for_commands,name);
    command_definitions.num++;
  }
}



void cmddefs_define_command_doc( const char* name, const char *usage, const char *doc )
{
  int idx = 0;
  int changed = False;

  /* Counts backward, which is very quick if this command was just added */
  for (idx=command_definitions.num-1; !changed && idx >= 0; idx--)
    if (strncmp(name,command_definitions.list[idx].name,CMDDEF_MAX_NAME_LENGTH) == 0) {
      command_definitions.list[idx].usage = usage;
      command_definitions.list[idx].doc = doc;
      changed = True;
    }
  
  if (!changed) 
    ipc_notify(IPC_ONE,IPC_ERROR,"Failed to add documentation to command %s",name);
}



void cmddefs_define_command_prereq( const char* name, const char *prereq )
{
  if (!prereq)
    return;
  
  if (prereq_storage.num >= CMDDEF_MAX_NUM*CMDDEF_MAX_PREREQS) {
    ipc_notify(IPC_ONE,IPC_ERROR,"Prerequisite storage area full; can't add prerequisite %s for command %s",
              prereq,name);
    return;
  }

  prereq_storage.names[prereq_storage.num]=name;
  prereq_storage.prereqs[prereq_storage.num]=prereq;
  prereq_storage.num++;
}



void cmddefs_declare_prereq_status( const char * name, cmdstat status )
{
  CommandDefinition* def=cmddefs_lookup(name);
  if (def) def->callstatus = status;
}



void cmddefs_activate_prereqs( void )
{
  int i;

  for (i=0; i< prereq_storage.num; i++)
    cmddefs_activate_command_prereq(prereq_storage.names[i],prereq_storage.prereqs[i]);
}



void cmddefs_activate_command_prereq( const char* name, const char *prereq )
{
  int idx,pidx;
  int changed = False;
  int found = False;

  if (!prereq)
    return;

  /* Counts backward, which is very quick if this command was just added */
  for (idx=command_definitions.num-1; !changed && idx >= 0; idx--)
    if (strncmp(name,command_definitions.list[idx].name,CMDDEF_MAX_NAME_LENGTH) == 0) {
      CommandDefinition* cmddef = &(command_definitions.list[idx]);
        
      for (pidx=command_definitions.num-1; !found && pidx >= 0; pidx--)
        if (strncmp(prereq,command_definitions.list[pidx].name,CMDDEF_MAX_NAME_LENGTH) == 0) {
          found=True;
          if (cmddef->num_prereqs >= CMDDEF_MAX_PREREQS)
            ipc_notify(IPC_ONE,IPC_ERROR,"Maximum limit on command prerequisites (%d) reached; can't add another",
                      CMDDEF_MAX_PREREQS);
          else {
            cmddef->prereqs[cmddef->num_prereqs++]=pidx;
            /* ipc_notify(IPC_ONE,IPC_STD,"Added prerequisite %s (%d) for command %s (%d)",prereq,pidx,name,idx); */
          }
        }
      changed = True;
    }
  
  if (!changed) 
    ipc_notify(IPC_ONE,IPC_ERROR,"Failed to add prerequisite to command %s",name);
}



CommandDefinition* cmddefs_lookup(const char *name)
{
  int  command_def=0;
  
  /* Iterate through commands array looking for this command */
  while ((command_def < command_definitions.num) &&
         (strncmp(name,command_definitions.list[command_def].name,CMDDEF_MAX_NAME_LENGTH) != 0))
    command_def++;

  /* If found, return a pointer to its definition */
  if (command_def < command_definitions.num)
    return &(command_definitions.list[command_def]);
  else {
    if (cmdparam_warn_unknown)
      ipc_notify(IPC_ONE,IPC_ERROR,"Unknown command: %s",name);
    return NULL;
  }
}



cmdstat cmddefs_exec_by_name(const char* name, CMD_ARGS)
{
  CommandDefinition* def = cmddefs_lookup(name);
  
  if (!def)
    return CMD_PARAMETER_ERROR;

  else {
    Command cmd;
    int i;
    
    cmd.def=def;
    cmd.argc=argc;
    for (i=0; i<argc; i++)
      cmd.argv[i]=argv[i];
    
    return command_exec(&cmd);
  }
}


/* Given a pointer to an opening quote mark (a single character,
   assumed non-null), returns a pointer to the matching closing quote
   (or eos, if none), leaving *remaining pointing to the character
   after the quote, if any.
*/
char* consume_quote(char** remaining)
{
  const char* quotepos=*remaining;
  while (*(++(*remaining)) && (**remaining!=*quotepos));
  char* end=*remaining;
  if (!**remaining) ipc_notify(IPC_ONE,IPC_ERROR,"Unmatched %c",*quotepos);
  else (*remaining)++;
  return end;
}


inline bool isquote(char character)
{  return (character=='"' || character=='\'' || character=='`');  }

  
const char* command_parse_token(char** remaining)
{
  char* start;
  char* end;

  while (isspace(**remaining)) (*remaining)++;
  start=*remaining;
  end=*remaining;
  
  switch (**remaining) {

  case '\0':
    break;

  case  '#':
    while (*(++(*remaining)));
    start=end=(*remaining);
    break;
    
  case '\"':
    start++;
    end=consume_quote(remaining);
    break;
    
  case '`':
    start++;
    end=consume_quote(remaining);
    break;
    
  case '\'':
    start++;
    end=consume_quote(remaining);
    break;
    
  default:
    while (*(++(*remaining))  && !isspace(**remaining) && !isquote(**remaining) && **remaining!='#');
    if (isquote(**remaining))
      consume_quote(remaining);
    end=*remaining;
    break;
  }

  /* Swallow trailing garbage until we're sure there's something interesting left */
  while (isspace(**remaining)) (*remaining)++;
  if (**remaining=='#') while (*(++(*remaining)));

  /* Return pointer to token */
  if (end) *end='\0';  /* Overwrites delimiter */
  return start;
}



int command_parse_line(Command *command, char* const cmdtxt)
{
  bool seterror=false;
  bool paramsset=false;
  char* remaining=cmdtxt;
  
  /* First token is name of command */
  const char* name = command_parse_token(&remaining);
  
  /* First, consume parameter setting in the form x=y */
  while (cmdparams_set_single(blackboard,name,seterror)) {
    paramsset=true;
    name = command_parse_token(&remaining);
  }
  if (seterror) {
    commands_failed++;
    return 0;
  }
  
  /* Continue with regular processing */
  if (!*name) {
    if (paramsset) commands_succeeded++;
    return 0; /* Must be blank line, comment, or completed set */
  }
  
  /* Look up command definition and link it in */
  command->def = cmddefs_lookup(name);
  if (!command->def) {
    commands_failed++;
    return 0;
  }
  
  /* Read the command's arguments, if any */
  command->argc=0;
  while ( (command->argc < CMD_MAX_ARGUMENTS) && *remaining )
    command->argv[(command->argc)++]=command_parse_token(&remaining);

  
  if (!command_check_usage(command)) {
    commands_failed++;
    return 0;
  }

  return 1;
}



int command_check_usage(Command* command)
{
  /* Make sure right number of arguments were supplied */
  if (command->argc >= CMD_MAX_ARGUMENTS)
    ipc_notify(IPC_ONE,IPC_WARNING,"Argument list may be truncated (limit is %d)",CMD_MAX_ARGUMENTS);
  if (command->argc < command->def->minargs) {
    char buf[CMD_MAX_LINE_LENGTH];
    cmddef_print_usage_to_str(command->def, buf, CMD_MAX_LINE_LENGTH);
    ipc_notify(IPC_ONE,IPC_ERROR,"Command %s requires %d arguments but %d supplied",
               command->def->name,command->def->minargs,command->argc);
    ipc_notify(IPC_ONE,IPC_STD,"Usage: %s",buf);
    return 0;
  }

  return 1;
}



#ifndef NO_SIGNAL_HANDLING
void command_exec_sigint_handler( int sig)
{
  (void)sig; /* Unused */
  
  ipc_notify(IPC_ALL,IPC_ERROR,
             "Aborting command due to SIGINT; program may now be in an undefined state");
  longjmp(jmp_env,CMD_SIGINT_ERROR); /* Return to command_exec */
}
#endif



cmdstat command_exec(Command *cmd)
{
  time_t end_of_command;
  time_t start_of_command;
  double elapsed_time;
  int command_number=command_num_called++; /* local copy for recursive calls */
  char str[CMD_MAX_LINE_LENGTH];
  int i;
  int status = CMD_NO_ERROR;  /* Any non-negative integer also accepted */
  
  if (ipc_msg_level >= IPC_VERBOSE) {
    command_print_to_str( cmd, str, CMD_MAX_LINE_LENGTH);
    ipc_notify(IPC_ONE,IPC_VERBOSE,"Command %2d (%s) executing",
               command_number,str);
  }

  /* Call any prerequisites this command defines */
  for (i=0; i< cmd->def->num_prereqs && status >= CMD_NO_ERROR; i++)
    if (command_definitions.list[cmd->def->prereqs[i]].callstatus == CMD_NEVER_CALLED) {
      Command temp;
      temp.def=cmddefs_lookup(command_definitions.list[cmd->def->prereqs[i]].name);
      temp.argc=0;
      status = command_exec(&temp);
    }
    else status = command_definitions.list[cmd->def->prereqs[i]].callstatus;
  

  /* Call command unless already in an error state */
  start_of_command = time(NULL);
  if (status >= CMD_NO_ERROR) {

#ifdef NO_SIGNAL_HANDLING
    status = CMD_CALL(*cmd);
#else
    /* Set up interrupt handler */
    signal_handler_type original_handler = 
      signal(SIGINT,command_exec_sigint_handler);

    /* Save state in case of interrupt */
    if (sigsetjmp(jmp_env,True)==0)
      /* Enter region that might have an interrupt */
      status = CMD_CALL(*cmd);
    else
      /* Continue from interrupt, if there was one */
      status = CMD_SIGINT_ERROR; 

    /* Restore original interrupt handler */
    signal(SIGINT,original_handler);
#endif
    
    ipc_notify(IPC_ONE,IPC_VERBOSE,"Command %2d exited with return code %d",
               command_number,status);
    cmd->def->callstatus = status;
  }
  else {
    ipc_notify(IPC_ONE,IPC_WARNING,"Command %2d not being called due to unsatisfiable prerequisite: %s",
             command_number,command_definitions.list[cmd->def->prereqs[i-1]].name);
    status = CMD_PREREQ_ERROR;
  }

  
  if (status >= CMD_NO_ERROR) { 
    commands_succeeded++;
  }
  else
    commands_failed++;

  ipc_barrier(); /* Sync after each command ; should add bcast of error status here */
  
  end_of_command = time(NULL);
  elapsed_time = difftime(end_of_command, start_of_command);
  
  if (elapsed_time > command_msg_time || ipc_msg_level >= IPC_OVERWHELM) {
    int elapsed_sec=int(fmod(elapsed_time,      60));
    int elapsed_min=int(fmod(elapsed_time/60,   60));
    int elapsed_hours=int(   elapsed_time/60/60);
    if (ipc_msg_level >= IPC_VERBOSE) {
      command_print_to_str( &(*cmd), str, CMD_MAX_LINE_LENGTH);
      ipc_notify(IPC_ONE,IPC_VERBOSE,"Command %2d (%s) took %g seconds (%d:%02d:%02d), completing %.24s",
                 command_number, str, (double)elapsed_time,
                 elapsed_hours,elapsed_min,elapsed_sec,
                 ctime(&end_of_command));
    }
    else
      ipc_notify(IPC_ONE,IPC_STD,"Command %2d (%s) took %g seconds (%d:%02d:%02d), completing %.24s",
                 command_number, cmd->def->name, (double)elapsed_time,
                 elapsed_hours,elapsed_min,elapsed_sec,
                 ctime(&end_of_command));
  }
  
  return status;
}



cmdstat cmddefs_exec_str(const char* cmdtxt)
{
  Command cmd;
  char buf[CMD_MAX_LINE_LENGTH];

  /* Checks that last two characters are filled with nulls; if not string must be near the limit */
  buf[CMD_MAX_LINE_LENGTH-2]=0; /* In case strncpy doesn't fill with nulls on this system */
  strncpy(buf,cmdtxt,CMD_MAX_LINE_LENGTH);
  if (buf[CMD_MAX_LINE_LENGTH-2]!=0)
    ipc_notify(IPC_ONE,IPC_ERROR,"Line length exceeded hard-coded limit of %d",int(CMD_MAX_LINE_LENGTH));

  if (!command_parse_line(&cmd, buf))
    return CMD_EMPTY;

  return command_exec(&cmd);
}



int cmddefs_exec_batch(CmdDefs_LineGenerator fn, const char * description)
{
  int command_count;
  int orig_commands_succeeded=commands_succeeded;
  int orig_commands_failed=commands_failed;
  static int done;
  static unsigned linelength;
  time_t current_time;

  command_count=0;
  done=False;

  if (cmdparam_changes_verbose){ 
    current_time = time(NULL);
    ipc_notify(IPC_ONE,IPC_SUMMARY,"Command %s execution started %.24s",
               description,ctime(&current_time));
  }

  
  /* Read a line, broadcast it to all PEs, execute it on all PEs,
     and repeat until the commands have all been read.
  */
  while (!done) {

    /* One PE gets the next line */
    if (AMPARENTPE){
      linelength=0;
      cmddefs_line_buffer[0]='\0';
      done=(*fn)();
      
      if (!done && *cmddefs_line_buffer) {
        linelength=strlen(cmddefs_line_buffer);
        
        /* Strip trailing newline, if any */
        if (cmddefs_line_buffer[linelength-1] == '\n') {
          cmddefs_line_buffer[linelength-1]='\0';
          linelength--;
        }
        
        if (linelength >= CMD_MAX_LINE_LENGTH)
          ipc_notify(IPC_ALL,IPC_WARNING,"Command line may be truncated (limit is %d)",CMD_MAX_LINE_LENGTH);
      }
    }

    /* Synchronize and copy flags (and cmd line, if any) */
    ipc_barrier(); 
    ipc_get(&done,       IPC_INT,      1, PARENTPE);
    ipc_get(&linelength, IPC_UNSIGNED, 1, PARENTPE);
    if (!done && linelength>0)
      ipc_get((int *)(&cmddefs_line_buffer[0]), IPC_INT, (linelength+1)/sizeof(int)+1, PARENTPE);

    /* Make sure every PE has a local copy of the cmd line */
    ipc_barrier(); 

    /* If there's a command line present, parse and execute it (on all PEs) */
    if (!done && linelength>0) {
      ipc_notify(IPC_ONE,IPC_OVERWHELM,"Parsing command string `%s'",cmddefs_line_buffer);
      if (cmddefs_exec_str(cmddefs_line_buffer) != CMD_EMPTY)
        command_count++;
    }
  }
  /* To allow multiply-nested calls to this function */
  done=False;

  current_time = time(NULL);
  const bool haderrors = (commands_failed-orig_commands_failed > 0);
  if (cmdparam_changes_verbose || haderrors)
    ipc_notify(IPC_ONE,(haderrors? IPC_ALERT : IPC_SUMMARY),
               "Command %s execution completed %.24s; %d succeeded, %d failed",
               description,ctime(&current_time),
               commands_succeeded-orig_commands_succeeded,
               commands_failed-orig_commands_failed);

  return commands_failed-orig_commands_failed;
}



int cmddefs_get_line_from_file( void )
{
  if (!cmddefs_file)
    return true;
  
  bool done=false;
  char* lastchar=cmddefs_line_buffer;
  *lastchar='\\';

  while (!done && *lastchar=='\\') {
    done = (fgets(lastchar,CMD_MAX_LINE_LENGTH+1,cmddefs_file) == NULL);
    lastchar += strlen(lastchar)-2;
    if (lastchar < cmddefs_line_buffer) lastchar = cmddefs_line_buffer;
  }
  return done;
}



int cmddefs_exec_file(const char *filename)
{
  char description[255];
  int status,nofile=False;
  FILE *orig_cmddefs_file=cmddefs_file;
  
  cmddefs_file=0;

  
  /* 25 January 2002  This code seems to fail silently if the requested
     file is a directory.  It would be better to either ignore directories
     or to fail verbosely, but I don't know of a portable method for
     deciding if a file is a directory. */

  /* Only one PE opens the file */
  if (AMPARENTPE){
    /* First try the current directory */
    cmddefs_file=fopen(filename,"r");
    
    /* Then try all the possible paths */
    if (!cmddefs_file){
      StringParser p; /* Parse commandpath to get list of paths */
      StringParser::arglist words;
      p.parse(commandpath,words);
      StringParser::argptr i=words.begin();
      while (i!=words.end() && !cmddefs_file) {
        const string name = (*i)+filename;
        cmddefs_file=fopen(name.c_str(),"r");
        i++;
      }
    }
    if (!cmddefs_file){ 
      ipc_notify(IPC_ALL,IPC_ERROR,"Couldn't open command file %s",filename);
      nofile=True;
    }
  }
  
  SNPRINTF(description,255,"file %s",filename);
  status = cmddefs_exec_batch(&cmddefs_get_line_from_file,description);
  
  if (cmddefs_file)
    fclose(cmddefs_file);
  
  cmddefs_file=orig_cmddefs_file;
  
  return (nofile? CMD_FILE_ERROR : status);
}



int cmddefs_num_total(void)
{  return command_definitions.num;  }



void command_print_to_str( const Command *cmd, char *str, size_t nchars)
{
  int i;
  char *str_ptr=str;
  size_t charsleft=nchars-1;

  /* Print command name */
  SNPRINTF(str_ptr,charsleft,"%s",cmd->def->name);
  charsleft -= strlen(str_ptr);
  str_ptr   += strlen(str_ptr);

  /* Print arguments */
  for(i=0; i < cmd->argc; i++){
    SNPRINTF(str_ptr,charsleft," %s",cmd->argv[i]);
    charsleft -= strlen(str_ptr);
    str_ptr   += strlen(str_ptr);
  }
}



void cmddefs_sort(void)
{
  qsort(command_definitions.list, command_definitions.num,
        sizeof(CommandDefinition), cmddef_compare);
}


int my_strncasecmp(const char *str1, const char *str2, size_t n)
{
  for (; n>0 ; n--, str1++, str2++) {
    if (toupper(*str1) != toupper(*str2))
      return (toupper(*str1) - toupper(*str2));
    if (*str1 == '\0')  return 0;
  }
  return 0;
}


int cmddef_compare(const void* def1, const void* def2)
{
  return( my_strncasecmp(((const CommandDefinition*)def1)->name,
                         ((const CommandDefinition*)def2)->name,
                         CMDDEF_MAX_NAME_LENGTH) );
}


void cmddef_print_usage(FILE *fp, const CommandDefinition* cmddef)
{
  if (cmddef->usage) 
    fprintf(fp,cmddef->usage,cmddef->name);
  else {
    int i;
    fprintf(fp,"%s",cmddef->name);
    for (i=0; i< cmddef->minargs; i++)
        fprintf(fp," <arg>");
    fprintf(fp," [<optional-args>]");
  }
}


void cmddef_print_usage_to_str(const CommandDefinition* cmddef, char *str, size_t nchars)
{
  if (cmddef->usage)
    SNPRINTF(str,nchars,cmddef->usage,cmddef->name);
  else {
    char *str_ptr=str;
    size_t charsleft=nchars-1;
    int i;
    
    /* Print command name */
    SNPRINTF(str_ptr,charsleft,"%s",cmddef->name);
    charsleft -= strlen(str_ptr);
    str_ptr   += strlen(str_ptr);
    
    /* Print arguments */
    for (i=0; i< cmddef->minargs; i++) {
      SNPRINTF(str_ptr,charsleft," <arg%d>",i+1);
      charsleft -= strlen(str_ptr);
      str_ptr   += strlen(str_ptr);
    }
    SNPRINTF(str_ptr,charsleft," [<optional-args>]");
    charsleft -= strlen(str_ptr);
    str_ptr   += strlen(str_ptr);
  }
}



void cmddefs_print_all(FILE *fp)
{
  int i;
  
  for(i=0; i< command_definitions.num; i++) {
    cmddef_print_usage(fp,&(command_definitions.list[i]));
    fprintf(fp,"\n");
  }
}



void cmddefs_print_doc_for_index(FILE *fp, int idx)
{
  cmddef_print_usage(fp,&(command_definitions.list[idx]));
  fprintf(fp,"\n\n");
  
  if (command_definitions.list[idx].doc) {
    fprintf(fp,command_definitions.list[idx].doc,
            command_definitions.list[idx].name);
    fprintf(fp,"\n");
  }
  else
    fprintf(fp,"No further help available.\n");
}



void cmddefs_print_doc(FILE *fp, const char* name)
{
  int idx = 0;
  int found = False;

  for (idx=command_definitions.num-1; !found && idx >= 0; idx--)
    if (strncmp(name,command_definitions.list[idx].name,CMDDEF_MAX_NAME_LENGTH) == 0) {
      cmddefs_print_doc_for_index(fp,idx);
      found = True;
    }
  
  if (!found) 
    ipc_notify(IPC_ONE,IPC_ERROR,"Don't know anything about command %s",name);
}



void cmddefs_print_all_doc(FILE *file)
{
  int i;
  fprintf(file,"%s\n",BlackboardType::help_separator);
  for (i=0; i< cmddefs_num_total(); i++) {
    cmddefs_print_doc_for_index(file,i);
    fprintf(file,BlackboardType::help_separator);
    fprintf(file,"\n");
  }
}



char* cmddefs_completion_generator (char *text, int state)
{
  static int idx, len;
  char *name;

  /*
    If this is a new word to complete, initialize the index counters
    to the beginning and save the length of text for efficiency
  */
  if (!state) {
    idx = 0;
    len = strlen(text);
  }
  
  /* Return the next command which partially matches, if any. */
  while (idx < command_definitions.num) {
    name = command_definitions.list[idx++].name;
    if (strncmp (name, text, len) == 0)
      return (cmdparam_dupstr(name));
  }
  
  return ((char *)NULL); /* No more matches */
}



/******************************************************************************/
/* Counter hook handling                                                    */
/******************************************************************************/


int hooklists_define_list( const char * listname, const char * countername )
{
  if (hooklists.num >= HOOKLISTS_MAX_NUM) {
    ipc_notify(IPC_ONE,IPC_ERROR,"Maximum number of hook lists reached");
    return CMD_PARAMETER_ERROR;
  }
  
  strncpy(hooklists.lists[hooklists.num].name,listname,HOOKLIST_MAX_NAME_LENGTH);
  strncpy(hooklists.lists[hooklists.num].countername,countername,HOOKLIST_MAX_NAME_LENGTH);
  hooklists.lists[hooklists.num].current=0;
  hooklists.num++;
  
  return hooklists.num - 1; /* Returns the HooklistNum for the new list */
}



/*
  Define a command to execute at a specfied counter.

  First argument is the name of the Hooklist, the second is the
  counter number or range to which it applies, second is the command
  name, and rest are arguments to be given to the command.  A counter
  range may be of the form "b" (a single counter value, b), "b-e" (a
  range of counter values b through e, inclusive), or "b-e%s", an
  inclusive range where the command is executed only when the counter
  is evenly divisible by the given step s.

  Examples:

     hook before_input        5 set exc_rad 1
      (Sets the param "exc_rad" to 1.0 at counter value 5)

     hook after_learning    6-9 plot
      (Calls command "plot" at counter values 6, 7, 8 and 9)

     hook after_learning  6-9%3 plot
      (Calls command "plot" at counter values 6 and 9)

  Hooks with the same start counter are executed in the order
  defined.  If desired, could add a way to set the "order" struct 
  elem explicitly to allow full user control over the order of
  execution, but it's probably not necessary.
*/
#define nexthooknum (hooklists.lists[hooklist].num)
cmdstat cmd_hook( CMD_ARGS )
{
  int i;
  HooklistNum hooklist=Uninitialized;
  CounterHookDefinition* hook = NULL;
  const char *specifier=argv[1];
  
  /* Look up hook list index */
  for (i=0; i<hooklists.num; i++)
    if (!strncmp(hooklists.lists[i].name,argv[0],HOOKLIST_MAX_NAME_LENGTH))
      hooklist=i;
  
  if (hooklist==Uninitialized) {
    ipc_notify(IPC_ONE,IPC_ERROR,"Hook list is not defined: %s",argv[0]);
    return CMD_PARAMETER_ERROR;
  }

  if (nexthooknum >= HOOKLIST_MAX_NUM) {
    ipc_notify(IPC_ONE,IPC_ERROR,"Reached limit for number of counter hooks");
    return CMD_PARAMETER_ERROR;
  }

  hook = &(hooklists.lists[hooklist].defs[nexthooknum]);
  hook->order=hook_definition_counter++;
  
  /* Look up the command and link in its definition */
  {
    CommandDefinition* def = cmddefs_lookup(argv[2]);
    if (!def) return CMD_PARAMETER_ERROR;
    hook->cmd.def = def;
  }
  
  /*  Copy arguments to this hook's command slot  */
  hook->cmd.argc = argc-3;
  for (i=0; i< argc-3; i++) {
    hook->argstofree[i] = cmdparam_dupstr(argv[i+3]);
    hook->cmd.argv[i] = hook->argstofree[i];
  }
  hook->argstofree[i]=NULL;
  
  if (!command_check_usage(&(hook->cmd)))
    return CMD_PARAMETER_ERROR;
  
  if (hook->cmd.def->minargs > argc-3)
    ipc_notify(IPC_ONE,IPC_WARNING,"Command %s in hook requires %d args but only %d supplied");
  
  /* Create one or more hooks, as appropriate for the counter specifier */
  Parse parser(blackboard, specifier);
  while (!parser.empty()) {
    
    /* Parse counter specifier */
    if (!hook_parse_specifier( hook, parser)) {
      ipc_notify(IPC_ONE,IPC_ERROR,"Could not parse counter specifier");
      return CMD_PARAMETER_ERROR;
    }
    nexthooknum++;
    
    /* Display result of parsing, if desired */
    if (ipc_msg_level >= IPC_VERBOSE) {
      char str[CMD_MAX_LINE_LENGTH];
      command_print_to_str(&(hook->cmd),str,CMD_MAX_LINE_LENGTH);
      ipc_notify(IPC_ONE,IPC_VERBOSE,"Defined counter_hook %d-%d%%%d %s",
                 hook->start,hook->end,hook->step,str);
    }
      
    /* Define another hook with same parameters, if requested */
    if (*specifier) {
      if (nexthooknum >= HOOKLIST_MAX_NUM) {
        ipc_notify(IPC_ONE,IPC_ERROR,"Reached limit for number of counter hooks");
        return CMD_PARAMETER_ERROR;
      }
      
      hook_copy( hook, &(hooklists.lists[hooklist].defs[nexthooknum]));
      hook =           &(hooklists.lists[hooklist].defs[nexthooknum]);
    }
  }


  /* Keep the list sorted */
  hooklists_sort(hooklist);

  return CMD_NO_ERROR;
}



int hook_parse_specifier( CounterHookDefinition *hook, Parse& parser )
{
  hook->step = 1; /* standard default */
  
  /* First token is required -- the counter start value */
  hook->start = hook->end = (int)ROUND(parser.getnumericval());
  if (hook->start < 0) return False;
  if (parser.empty()) return True;
  
  /* Next token, if any, is the counter end value */
  if (parser.consumeifpresent("-")) {
    if (parser.empty()) return False;
    hook->end = (int)ROUND(parser.getnumericval());
    if (hook->end < 0) return False;
  }
  if (parser.empty()) return True;
  
  /* Next token, if any, is the counter step specifier */
  if (parser.consumeifpresent("%")) {
    if (parser.empty()) return False;
    int num = (int)ROUND(parser.getnumericval());
    if (num < 1) return False;
    hook->step = num;
  }
  if (parser.empty()) return True;

  /* String should either be empty now, or have a comma followed by more specs */
  if (parser.consumeifpresent(",")) {
    if (parser.empty()) return False;
  }
  else
    if (!parser.empty())
      return False;
    
  return True;
}


    
void hook_copy( CounterHookDefinition *source, CounterHookDefinition *dest)
{
  int i;
  
  /* Command */
  dest->cmd.def = source->cmd.def; 

  /* Arguments (pointers copied only, not the strings) */
  dest->cmd.argc = source->cmd.argc;
  for (i=0; i< source->cmd.argc; i++)
    dest->cmd.argv[i] = source->cmd.argv[i];
  dest->argstofree[0]=NULL;
  
  /* Counter specifier */
  dest->start = source->start;
  dest->end   = source->end;
  dest->step  = source->step;

  /* Execution order */
  dest->order = source->order;
}



void hooklists_sort(HooklistNum hooklist)
{
  qsort(&(CURRENT_HOOK(hooklists.lists[hooklist])),
        hooklists.lists[hooklist].num - hooklists.lists[hooklist].current,
        sizeof(CounterHookDefinition),
        hook_compare);
}



int hook_compare(const void* hook1, const void* hook2)
{
  const CounterHookDefinition* h1=(const CounterHookDefinition*)hook1;
  const CounterHookDefinition* h2=(const CounterHookDefinition*)hook2;

  return ( h1->start == h2->start ?
           h1->order - h2->order :
           h1->start - h2->start );
}



void hooklists_run_list(HooklistNum hooklist, int counter, int catchuponly)
{
  int i;

  /* Abort early if no more hooks available */
  if (!HAS_CURRENT_HOOK(hooklists.lists[hooklist]))
    return;
  
  /* Abort early if next valid hook not yet reached */
  if (counter < CURRENT_HOOK(hooklists.lists[hooklist]).start)
    return;
  
  /*
    Clear out expired hooks, calling only the ones that specify to do so,
    and those at most once.  No command should ever end up being called
    here if this procedure is called once for every counter value, since
    commands expiring on the previous counter value are not called.  Note
    that the latter policy may open up a potential odd bug in some weird
    situations; since the behavior differs when a counter is called every
    other time compared to being called every time.  It might be better
    to totally dispense with the automatic calls of catchup commands,
    using a separate call (for each missing iteration, with catchuponly
    true) to force catchup.
  */
  for (; (HAS_CURRENT_HOOK(hooklists.lists[hooklist])) && 
         (counter > CURRENT_HOOK(hooklists.lists[hooklist]).end);
       hooklists.lists[hooklist].current++)
    if ( ( CURRENT_HOOK(hooklists.lists[hooklist]).end != counter-1) && 
         ( CURRENT_HOOK(hooklists.lists[hooklist]).cmd.def->catchup ) )
      command_exec(&(CURRENT_HOOK(hooklists.lists[hooklist]).cmd));

  /* Check every hook starting at before this counter value */
  for (i=hooklists.lists[hooklist].current;
       (i<hooklists.lists[hooklist].num) &&
         (counter >= hooklists.lists[hooklist].defs[i].start);
       i++) {
    CounterHookDefinition* hookdef= &(hooklists.lists[hooklist].defs[i]);
  
    /* If counter is in specified range and is at the appropriate step, call the command */
    if ( (counter <= hookdef->end) &&
         ((counter % hookdef->step) == 0) &&
         (!catchuponly || hookdef->cmd.def->catchup ) ) {
      /* For continuous hooks, only notify user when started */
      if (hookdef->step !=1 || counter == hookdef->start)
        ipc_notify(IPC_ONE,IPC_STD,"Running hook `%s' %s at %s %d",
                   hookdef->cmd.def->name,
                   hooklists.lists[hooklist].name,
                   hooklists.lists[hooklist].countername,
                   counter);
      if (hookdef->step==1 && counter==hookdef->start && hookdef->end > hookdef->start)
        ipc_notify(IPC_ONE,IPC_STD,"(Hook `%s' will run at every %s until %s %d)",
                   hookdef->cmd.def->name,
                   hooklists.lists[hooklist].countername,
                   hooklists.lists[hooklist].countername,
                   hookdef->end);
      command_exec(&(hookdef->cmd));
    }
  }
}   



void hooklists_reset_list(HooklistNum hooklist)
{
  hooklists.lists[hooklist].current=0;
  hooklists_sort(hooklist);
  
  return;
}   



void hooklists_empty_list(HooklistNum hooklistnum)
{
  int i;
  CounterHooklist* hooklist = &(hooklists.lists[hooklistnum]);

  /* Free allocated items */
  for (i=0; i<hooklist->num; i++) {
    int arg=0;
    while (hooklist->defs[i].argstofree[arg])
      free(hooklist->defs[i].argstofree[arg++]);
  }
  
  hooklist->num=0;
  hooklist->current=0;
  
  return;
}   



void hook_print_to_str( CounterHookDefinition *hook, char *hooklistname, char *str, size_t nchars)
{
  char *str_ptr=str;
  size_t charsleft=nchars-1;

  SNPRINTF(str_ptr,charsleft,"hook %-15s %6d", hooklistname, hook->start);
  charsleft -= strlen(str_ptr); str_ptr += strlen(str_ptr);

  /* Only print counter end if different */
  if (hook->end != hook->start) {
    SNPRINTF(str_ptr,charsleft,"-%d",hook->end);
    charsleft -= strlen(str_ptr); str_ptr += strlen(str_ptr);
  }
  
  /* Only print non-single steps */
  if (hook->step != 1) {
    SNPRINTF(str_ptr,charsleft,"%%%d", hook->step);
    charsleft -= strlen(str_ptr); str_ptr += strlen(str_ptr);
  }

  /* Print command text */
  SNPRINTF(str_ptr,charsleft,"  ");
  charsleft -= strlen(str_ptr); str_ptr += strlen(str_ptr);
  command_print_to_str(&(hook->cmd), str_ptr,charsleft);
  charsleft -= strlen(str_ptr); str_ptr += strlen(str_ptr);
}



void hooklists_log(void) 
{
  int i,hooklist;
  char str[CMD_MAX_LINE_LENGTH];
  
  for (hooklist=0; hooklist<hooklists.num; hooklist++)
    for (i=0; i<hooklists.lists[hooklist].num; i++) {
      hook_print_to_str( &(hooklists.lists[hooklist].defs[i]),
                         hooklists.lists[hooklist].name,
                         str, CMD_MAX_LINE_LENGTH);
      ipc_log(IPC_ONE,"%s\n",str);
    }
              
  ipc_log(IPC_ONE,"\n");
}



/******************************************************************************/
/* Routines that work with parameters and commands both                       */
/******************************************************************************/


size_t  cmdparam_identifier_length(const char* str)
{
  const char * rem;

  /* 1st char must be alphabetical */
  if (!str || !isalpha(*str))  return 0;

  /* Rest must be alphanumeric or an underscore */
  for (rem=str; isalnum(*rem) || *rem == '_'; rem++);
  
  return rem-str;
}



char* cmdparam_dupstr (const char *str)
{
  char *newstr = (char *)malloc(strlen(str)+1);
  if (!newstr)
    ipc_abort(IPC_EXIT_OUT_OF_MEMORY,"Cannot allocate string");
  strcpy (newstr, str);
  return (newstr);
}



int cmdparams_print_doc(FILE *fp, const char* name)
{
  int idx = 0;
  int found = False;

  const ParamType& param=blackboard.lookup_with_path(name,false);
  if (param.is_valid()) {
    fprintf(fp,param.doc_string().c_str());
    found = True;
  }
  else 
    for (idx=command_definitions.num-1; !found && idx >= 0; idx--)
      if (strncmp(name,command_definitions.list[idx].name,CMDDEF_MAX_NAME_LENGTH) == 0) {
        cmddefs_print_doc_for_index(fp,idx);
        found = True;
      }
  
  return found;
}


char* params_completion_generator (char *text, int state)
{  return blackboard.completion_generator (text,state);  }


char* cmdparams_completion_generator (char *text, int state)
{
  char *name = cmddefs_completion_generator (text, state);
  if (name) return name;
  return blackboard.completion_generator (text, state);
}


int cmdparam_save_current_state(const char * filename)
{
  int i,hooklist;
  FILE *file;
  char str[CMD_MAX_LINE_LENGTH];

  file=fopen(filename,"w+");
  if(file==NULL) {
    ipc_notify(IPC_ALL,IPC_ERROR,"Can't open %s file", filename);
    return CMD_FILE_ERROR;
  }
  
  fprintf(file,"# Parameters:\n\n");
  blackboard.root().save_parameters(file);

  fprintf(file,"\n# Hooks:\n\n");
  for (hooklist=0; hooklist<hooklists.num; hooklist++)
    for (i=0; i<hooklists.lists[hooklist].num; i++) {
      hook_print_to_str( &(hooklists.lists[hooklist].defs[i]),
                         hooklists.lists[hooklist].name,
                         str, CMD_MAX_LINE_LENGTH);
      fprintf(file,"%s\n",str);
    }

  fprintf(file,"\n");
  fclose(file);

  return CMD_NO_ERROR;
}



string trim_quotes(const string& s)
{
  if (s.empty()) return s;
  unsigned front = 0;
  unsigned back  = s.length()-1;
  if (s[front] == '"' || s[front] == '\'') {
    front++;
    if (s[back] == s[0])
      back--;
  }
  return string(s,front,back-front+1);
}


/*
  If the given string is a backquoted shell command, evaluate it;
  otherwise return it unchanged.

  Implementation: Yuck.

  This capability is not truly multi-process or multi-processor safe,
  since the temporary file may clash between two processors or two
  processes.  It would be safer to use mkstemp, yet "system" doesn't
  appear to have any way to pass an existing open file.  Instead shell
  redirection is used to save the output to a file, which is highly
  undesirable.
*/
string filter_backquotes(const string arg)
{
  if (arg.empty() || arg[0]!='`' || arg[arg.length()-1]!='`')
    return arg;

  /* Do string substitution */
  const string noquotes(arg,1,arg.length()-2);
  string parsed;
  parsed = CmdParamStringParser(blackboard).parse(noquotes,parsed);
  
  const string tempname = TEMPNAME(NULL,"backq");
  const string shellcmd = parsed+" > "+tempname;
  system(shellcmd.c_str());
  std::ifstream s(tempname.c_str());

  /* Uses a fixed-size buffer because getline for strings is not
     implemented for egcs 1.1.2 */
  const int buffsize=1024;
  char buffer[buffsize];
  s.getline(buffer,buffsize,EOF);

  /* Remove trailing newline, if present */
  string str=buffer;
  if (!str.empty() && str[str.length()-1]=='\n')
    str.replace(str.length()-1,1,"");

  remove(tempname.c_str());
  
  return str;
}



bool cmdparams_set_single( BlackboardType& params, const string& arg,
                           bool& seterror, bool mark, bool verbose,
                           bool copysetfn)
{
  /* Abort if no equals sign found */
  unsigned pos = arg.find("=");
  if (pos>=arg.length())
    return false;

  /* Space before equals sign: either an error to be detected later
     or a sign that the item is not something for us to handle. */
  unsigned spacepos = arg.find(" ");
  if (spacepos<pos)
    return false;  
  
  const string pathstr = string(arg,0,pos);
  const string valstr  = filter_backquotes(trim_quotes(string(arg,pos+1,arg.length())));

  if (!params.set_matching(CmdParamStringParser(params),
                           pathstr,valstr,mark,verbose,false,copysetfn))
    seterror=true;
  
  return true;
}

/* Implementation of cmd_set for multiple arguments in a StringArgs */
cmdstat cmdparams_set( BlackboardType& params, StringArgs& arglist,
                       bool mark, bool warn, bool verbose, bool copysetfns)
{
  bool seterror = false;
  
  while (!arglist.empty()) {
    if (!cmdparams_set_single(params, arglist.top(string("")),
                              seterror,mark,verbose,copysetfns)) {
      if (warn) {
        const string rest = arglist.stringrep();
        ipc_notify(IPC_ONE,IPC_ERROR,"Syntax error in set arguments ('%s' is not of the form 'x=y')",
                   rest.c_str());
        return CMD_PARAMETER_ERROR;
      }
      return CMD_NO_ERROR;
    }

    /* Consume the argument */
    arglist.skip();
  }
  
  return (seterror? CMD_PARAMETER_ERROR : CMD_NO_ERROR);
}



/******************************************************************************/
/* Commands                                                                   */
/******************************************************************************/


cmdstat cmd_set( CMD_ARGS )
{
  CMD_ARG_LIST;
  return cmdparams_set(blackboard,arglist,true,true);
}



cmdstat cmd_quit( CMD_ARGS )
{
  time_t current_time = time(NULL);
  ipc_notify(IPC_ONE,IPC_SUMMARY,"Exiting at %.24s", ctime(&current_time));
  
  if (argc>0)
    ipc_exit(IPC_EXIT_NORMAL,argv[0]);
  else
    ipc_exit(IPC_EXIT_NORMAL,"Exited via quit command");

  return CMD_NO_ERROR;
}



cmdstat cmd_clear_hooks( CMD_ARGS )
{
  int status=CMD_NO_ERROR;
  HooklistNum hooklist;
  
  if (argc<1) /* Clear all lists by default */
    for (hooklist=0; hooklist<hooklists.num; hooklist++) {
      if (hooklists.lists[hooklist].num) {
        hooklists_empty_list(hooklist);
        ipc_notify(IPC_ONE,IPC_STD,"Emptied hooklist %s",hooklists.lists[hooklist].name);
      }
    }
  else {
    int i,arg;

    for (arg=0; arg<argc; arg++) {
      hooklist = Uninitialized;
      
      /* Look up hook list index */
      for (i=0; i<hooklists.num; i++)
        if (!strncmp(hooklists.lists[i].name,argv[arg],HOOKLIST_MAX_NAME_LENGTH))
          hooklist=i;
  
      if (hooklist==Uninitialized) {
        ipc_notify(IPC_ONE,IPC_ERROR,"Hook list is not defined: %s",argv[0]);
        status= CMD_PARAMETER_ERROR;
      }
      else if (hooklists.lists[hooklist].num) {
        hooklists_empty_list(hooklist);
        ipc_notify(IPC_ONE,IPC_STD,"Emptied hooklist %s",hooklists.lists[hooklist].name);
      }
    }
  }
  
  return status;
}



cmdstat cmd_exec( CMD_ARGS )
{
  int status=0;
  
  for (int i=0; i<argc; i++) {
    int newstatus = cmddefs_exec_str(PARSE_C(argv[i]));
    if (newstatus>=0) status=newstatus;
  }

  return status;
}



cmdstat cmd_exec_catchup( CMD_ARGS )
{
  int status=0;
  
  for (int i=0; i<argc; i++) {
    int newstatus = cmddefs_exec_str(PARSE_C(argv[i]));
    if (newstatus>=0) status=newstatus;
  }

  return status;
}



cmdstat cmd_exec_file( CMD_ARGS )
{
  CMD_ARG_LIST;
  int status;

  cmddefs_exec_file_arglists.push(argl);
  status=cmddefs_exec_file(PARSE_C(argv[0]));
  cmddefs_exec_file_arglists.pop();
  
  return (status? CMD_FILE_ERROR : CMD_NO_ERROR);
}



cmdstat cmd_call( CMD_ARGS )
{
  CMD_ARG_LIST;

  int status;
  const int oldipcverbosity = ipc_msg_level;
  const int newipcverbosity = IPC_REQUESTED;

  if (ipc_msg_level > newipcverbosity)
    ipc_msg_level = newipcverbosity;
  
  cmddefs_exec_file_arglists.push(argl);
  status=cmddefs_exec_file(PARSE_C(argv[0]));
  cmddefs_exec_file_arglists.pop();
  if (ipc_msg_level==newipcverbosity) /* If unchanged by file */
    ipc_msg_level=oldipcverbosity;
    
  return (status? CMD_FILE_ERROR : CMD_NO_ERROR);
}



cmdstat cmd_read_args( CMD_ARGS )
{
  CMD_ARG_LIST;
  StringArgs sargs(p, cmddefs_exec_file_arglists.top().begin(), cmddefs_exec_file_arglists.top().end());
  sargs.skip();
  
  const string    parentstr = arglist.next(string(""));
  BlackboardType& parent = blackboard.lookup_map(parentstr);  
  return cmdparams_set(parent,sargs,true,true);
}



cmdstat cmd_define_param( CMD_ARGS )
{
  CMD_ARG_PARAMS(define_param);
  
  const string pathstr     = arglist.next(string(""));
  PathSpecification path(pathstr);
  const string name        = path.last();

  // 10/2002 Why are the lower and upper bounds truncated to integers,
  // even for Float parameters?  Presumably that's a historical anomaly?
  const string type        = arglist.next(string());
  const bool   has_lbound  =!arglist.empty();
  const int    lower_bound = arglist.next(int(Uninitialized));
  const bool   has_ubound  =!arglist.empty();
  const int    upper_bound = arglist.next(int(Uninitialized));
  const string helpstr     = arglist.next(string());
  const bool   has_initval =!arglist.empty();
  const string initval     = arglist.next(string());

  /* Add support for newlines */
  const string helpstring = String::replace_all(string(helpstr),string("\\n"),string("\n")); 
  
  BlackboardType& parent = blackboard.lookup_map(path.allbutlast(),true,path.isrooted());
  if (parent.defined_locally(name)) /* Already defined */
    return CMD_NO_ERROR;
  
  BlackboardType::ParamType newparam;
  if      (type == "Param_String"  || type == "String" ) newparam = DECLARE_A(name.c_str(),false,string());
  else if (type == "Param_Boolean" || type == "Boolean") newparam = DECLARE_A(name.c_str(),false,False);
  else if (type == "Param_Integer" || type == "Integer") newparam = DECLARE_A(name.c_str(),false,0);
  else if (type == "Param_Float"   || type == "Float"  ) newparam = DECLARE_A(name.c_str(),false,0.0);
  else {
    ipc_notify(IPC_ONE,IPC_ERROR,"Couldn't define parameter of type %s",type.c_str());
    return CMD_PARAMETER_ERROR;
  }

  if (has_lbound && type != "Param_String")  newparam.add_lower_bound(lower_bound);
  if (has_ubound && type != "Param_String" && !(upper_bound < lower_bound))
    newparam.add_upper_bound(upper_bound);
  if (helpstring!="")  newparam.add_doc(cmdparam_dupstr(helpstring.c_str()));
  if (has_initval) newparam.set(CmdParamStringParser(parent),initval);
  
  if (parent.define_param(newparam) == 1 && cmdparam_changes_verbose)
    ipc_notify(IPC_ONE,IPC_STD,"Defined parameter %s",pathstr.c_str());
  
  return CMD_NO_ERROR;
}



cmdstat cmd_define_param_set( CMD_ARGS )
{
  CMD_ARG_PARAMS(define_param_set);

  const string pathstr = arglist.next(string(""));
  PathSpecification path(pathstr);

  if (path.all().empty()) {
    ipc_notify(IPC_ONE,IPC_ERROR,"A parameter set must have a non-empty name");
    return CMD_PARAMETER_ERROR;
  }

  BlackboardType& parent = blackboard.lookup_map(path.allbutlast(),true,path.isrooted());

  /* Adds a new map if there isn't one by that name already */
  if (&parent == &(parent.lookup_map(path.last(),false)))
    parent.new_child(path.last(),true);
  
  return CMD_NO_ERROR;
}



cmdstat cmd_select_param_set( CMD_ARGS )
{
  CMD_ARG_PARAMS(select_param_set);
  static std::vector<BlackboardType*> blackboardstack;
    
  const string pathstr = arglist.next(string(""));
  PathSpecification path(pathstr);

  /* Pop top of stack */
  if (!path.isrooted() && path.all().empty()) {
    if (blackboardstack.empty())
      ipc_notify(IPC_ONE,IPC_ERROR,"At the root level; cannot pop back to another parameter set");
    else {
      blackboard_ptr=blackboardstack.back();
      blackboardstack.pop_back();
    }
  }

  /* Push current param_set on stack and go to a new one */
  else {
    blackboardstack.push_back(blackboard_ptr);

    blackboard_ptr = &(blackboard.lookup_map(path.all(),true,path.isrooted()));
  }

  return CMD_NO_ERROR;
}



cmdstat cmd_param_default( CMD_ARGS )
{
  (void)argc;

  blackboard.lookup(argv[0]).add_default_expr(argv[1]);
  
  return CMD_NO_ERROR;
}



cmdstat cmd_if( CMD_ARGS )
{
  if (PARSE_I(argv[0]))
    return cmddefs_exec_by_name(argv[1],argc-2,&(argv[2]));
  
  return CMD_NO_ERROR;
}



cmdstat cmd_dotimes( CMD_ARGS )
{
  int i;
  int status = CMD_NO_ERROR;
  
  for (i=0; i<PARSE_I(argv[0]); i++) {
    status = cmddefs_exec_by_name(argv[1],argc-2,&(argv[2]));
    if (status) return status;
  }
  
  return CMD_NO_ERROR;
}



cmdstat cmd_for( CMD_ARGS )
{
  int status = CMD_NO_ERROR;

  for (cmd_set(1,&(argv[0])); PARSE_I(argv[1]); cmd_set(1,&(argv[2]))) {
    status = cmddefs_exec_by_name(argv[3],argc-4,&(argv[4]));
    if (status) return status;
  }
  
  return CMD_NO_ERROR;
}



cmdstat cmd_print( CMD_ARGS )
{
  int i;
  
  for (i=0; i<argc; i++) {
    const string squeezed = String::replace_all(string(argv[i]),string("::"),string(""));

    /* Parameter name -- anything with all chars valid in a C identifier plus '::' */
    if (String::C_identifier_length(squeezed) == squeezed.length()) {
      const ParamType& param = blackboard.lookup_with_path(argv[i]);
      if (param.is_valid())
        ipc_notify(IPC_ONE,IPC_REQUESTED,"%s == %s",argv[i],param.stringrep().c_str());
    }
    /* String substitution */
    else if (*argv[i] == '$')
      ipc_notify(IPC_ONE,IPC_REQUESTED,"%s == %s",argv[i],PARSE_C(argv[i]));
    /* Numeric expression */
    else {
      double value = PARSE_F(argv[i]);
      ipc_notify(IPC_ONE,IPC_REQUESTED,"%s == %g",argv[i],value);
    }
  }

  return CMD_NO_ERROR;
}



cmdstat cmd_echo( CMD_ARGS )
{
  for (int i=0; i<argc; i++) {
    const string str = String::replace_all(string(PARSE_C(argv[i])),string("\\n"),string("\n")); 
    ipc_notify(IPC_ONE,IPC_REQUESTED,"%s",str.c_str());
  }
  
  return CMD_NO_ERROR;
}



cmdstat cmd_system( CMD_ARGS )
{
  char str[CMD_MAX_LINE_LENGTH];
  char *str_ptr=str;
  size_t charsleft=CMD_MAX_LINE_LENGTH-1;
  int i;
  int status=0;
  
  /* Print arguments as a command */
  for(i=0; i < argc; i++){
    SNPRINTF(str_ptr,charsleft,"%s%s",(i==0? "" : " "),PARSE_C(argv[i]));
    charsleft -= strlen(str_ptr);
    str_ptr   += strlen(str_ptr);
  }

  ipc_notify(IPC_ONE,IPC_VERBOSE,"Executing shell command `%s'",str);
  if (AMPARENTPE)
    status=system(str);

  return (status? CMD_MISC_ERROR : CMD_NO_ERROR);
}

---