ippCommandParser.cpp

Go to the documentation of this file.

// 
// DISCLAIMER: 
//  This software was produced by the National Institute of Standards 
//  and Technology (NIST), an agency of the U.S. government, and by statute is 
//  not subject to copyright in the United States.  Recipients of this 
//  software assume all responsibility associated with its operation,
//  modification,maintenance, and subsequent redistribution. 
//
//  See NIST Administration Manual 4.09.07 b and Appendix I. 
//
#include "stdafx.h"
 
#include "ippdme/Parser/ippCommandParser.h"
#include "ippdme/Command/commands.h"

#include "ippdme/ippOtherKeyType.h"
#include "ippdme/ippErrorNameType.h"
#include "ippPatternChecker.h"
#include "ippdme/misc/ippPropDefinition.h"
#include "ippdme/assert.h"

#include <map>
class ippCommandHashTable
{
  typedef std::map<std::string,ippCommandNameType>   Map;
  typedef std::map<std::string,ippCommandNameType>::const_iterator  _Iter;
  typedef std::pair <std::string, ippCommandNameType> _Pair;
  Map _map;
public:
  ippCommandHashTable();
  ippCommandNameType find(const std::string& string);
} g_command_hash;



#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

bool IsInteger(double value)
{
  return (value -(int)value) ==0;
}
bool IsBoolean(double value)
{
  return ( value == 0 || value == 1);
}
bool AsBoolean(double value)
{
  IPP_ASSERT(IsBoolean(value));
  return value != 0.0 ; 
}
int AsInteger(double value)
{
  IPP_ASSERT(IsInteger(value));
  return (int)value; 
}

/* ippCommandParser.cc

This is a command parser for version 1.40 of the I++ DME Spec.

This defines functions in the ippCommandParser class and defines a main
function outside the ippCommandParser class.

Functions named makeXXX (where XXX is a command name) are used to
check the arguments to each type of command and to return an instance
of the command. The documentation for each of these gives the rules
that it is enforcing and gives one or more references to pages of
version 1.40 of the spec. The error code generated if a rule is
broken is given after each rule.

The rules concern allowable arguments only. Context rules are not
handled by the ippCommandParser.

The reference pages reference both text and examples. Text references
are given in parentheses. Example references are given in brackets.
Other references are not enclosed.

Example: Reference pages: 23 26 (39) [40] 85
This means there is relevant text on page 39 and an example on page 40.

Page 17 is not referenced because the print is too small. Page 25 is not
referenced since everything on it appears identically elsewhere.

*/





ippCommandParser::ippCommandParser()
{
  _argCount = 0;
  _argSize = INITARGS;
  _argDoubles.resize(_argSize);
  _argKeywords.resize(_argSize);
  _argStrings.resize(_argSize); // might set all to 0
  _argTypes.resize(_argSize);
  _arrayIndex = 0;
}

ippCommandParser::~ippCommandParser()
{
}



void ippCommandParser::setInput(const char * input)
{
  strcpy(_inputArray, input); 

  // add the terminiation if missing ....
  int length = strlen(_inputArray);
  if (length>2 && _inputArray[length-1]!='\n' && _inputArray[length-2]!='\r') {
    _inputArray[length+0]='\r';
    _inputArray[length+1]='\n';
    _inputArray[length+2]=0;
   
  }
}


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

/* ippCommandParser::getErrorMessageString

Returned Value : char *
  If there is a problem with providing a string, this returns NULL.
  Otherwise, it returns the buffer argument.

Called By:
   external functions
   main (in stand-alone command parser and stand-alone command checker)

This copies an error message into the buffer. If the error was found
after a command name was recognized (i.e. the error occurred while
parsing the argument list of a valid command), the name of the command
is written into the buffer just before the error message.  For example,
if the command is 05502 GoTo(X(#)), which is OK up to the #, the error
message in the buffer will be "GoTo: BAD COMMAND ARGUMENTS".  If the
command is A2345 GoTo(X(3.1)), which has an error that is detected
before the command name is read, the error message in the buffer will
be "BAD TAG CHARACTER"

The symbol for each error code is the same as the text of the error
message, except that the symbol has underscores. The symbol serves as
an index into the array of strings defined here. The symbols are
defined in ippCommandParser.h.

*/
#define PARSER_ERROR_ENUMERATION\
  ENUM(OK ,"OK")\
  ENUM(ARGUMENT_FIRST_PART_MUST_BE_TOOL_OR_FOUNDTOOL,       "ARGUMENT FIRST PART MUST BE TOOL OR FOUNDTOOL")\
  ENUM(ARGUMENT_FOURTH_PART_MUST_BE_ACT,                    "ARGUMENT FOURTH PART MUST BE ACT")\
  ENUM(ARGUMENT_FOURTH_PART_BAD,                            "ARGUMENT FOURTH PART BAD")\
  ENUM(ARGUMENT_MUST_BE_A_NUMBER,                           "ARGUMENT MUST BE A NUMBER")\
  ENUM(ARGUMENT_MUST_BE_EVENT_TAG,                          "ARGUMENT MUST BE EVENT TAG")\
  ENUM(ARGUMENT_MUST_BE_INTEGER,                            "ARGUMENT MUST BE INTEGER")\
  ENUM(ARGUMENT_MUST_BE_POSITIVE,                           "ARGUMENT MUST BE POSITIVE")\
  ENUM(ARGUMENT_MUST_BE_STRING,                             "ARGUMENT MUST BE STRING")\
  ENUM(ARGUMENT_MUST_END_WITH_EMPTY_PARENTHESES,            "ARGUMENT MUST END WITH EMPTY PARENTHESES")\
  ENUM(ARGUMENT_MUST_END_WITH_NUMBER_IN_PARENTHESES,        "ARGUMENT MUST END WITH NUMBER IN PARENTHESES")\
  ENUM(ARGUMENT_SECOND_PART_BAD,                            "ARGUMENT SECOND PART BAD")\
  ENUM(ARGUMENT_SECOND_PART_MUST_BE_GOTOPAR_OR_PTMEASPAR,   "ARGUMENT SECOND PART MUST BE GOTOPAR OR PTMEASPAR")\
  ENUM(ARGUMENT_THIRD_PART_BAD,                             "ARGUMENT THIRD PART BAD")\
  ENUM(BAD_ARGUMENTS,                                       "BAD ARGUMENTS")\
  ENUM(BAD_CHARACTER_AFTER_COMMAND_END,                     "BAD CHARACTER AFTER COMMAND END")\
  ENUM(BAD_CHARACTER_AFTER_KEYWORD,                         "BAD CHARACTER AFTER KEYWORD")\
  ENUM(BAD_COMMAND_ARGUMENTS,                               "BAD COMMAND ARGUMENTS")\
  ENUM(BAD_COMMAND_NAME,                                    "BAD COMMAND NAME")\
  ENUM(BAD_DOTS,                                            "BAD DOTS")\
  ENUM(BAD_E_NUMBER_EXPONENT_MUST_HAVE_ONE_TWO_OR_THREE_DIGITS,"BAD E NUMBER EXPONENT MUST HAVE ONE TWO OR THREE DIGITS")\
  ENUM(BAD_FIRST_ARGUMENT,                                  "BAD FIRST ARGUMENT")\
  ENUM(BAD_IJK_NUMBERS,                                     "BAD IJK NUMBERS")\
  ENUM(BAD_KEYWORD,                                         "BAD KEYWORD")\
  ENUM(BAD_NUMBER_MORE_THAN_16_DIGITS,                      "BAD NUMBER MORE THAN 16 DIGITS")\
  ENUM(BAD_NUMBER_NO_DIGITS,                                "BAD NUMBER NO DIGITS")\
  ENUM(BAD_NUMBER_OF_THROUGHS,                              "BAD NUMBER OF THROUGHS")\
  ENUM(BAD_NUMBER_TWO_DECIMAL_POINTS,                       "BAD NUMBER TWO DECIMAL POINTS")\
  ENUM(BAD_STRING,                                          "BAD STRING")\
  ENUM(BAD_TAG_CHARACTER,                                   "BAD TAG CHARACTER")\
  ENUM(C_ARGUMENT_USED_TWICE,                               "C ARGUMENT USED TWICE")\
  ENUM(DIAMETER_MUST_BE_POSITIVE,                           "DIAMETER MUST BE POSITIVE")\
  ENUM(DIS_ARGUMENT_USED_TWICE,                             "DIS ARGUMENT USED TWICE")\
  ENUM(DIS_MUST_BE_FOLLOWED_BY_NUMBER_IN_PARENS,            "DIS MUST BE FOLLOWED BY NUMBER IN PARENS")\
  ENUM(ER_ARGUMENT_USED_TWICE,                              "ER ARGUMENT USED TWICE")\
  ENUM(EVENT_COMMAND_MUST_HAVE_EVENT_TAG,                   "EVENT COMMAND MUST HAVE EVENT TAG")\
  ENUM(IJK_ARGUMENT_USED_TWICE,                             "IJK ARGUMENT USED TWICE")\
  ENUM(IJK_NOT_FOLLOWED_BY_ARGIJK,                          "IJK NOT FOLLOWED BY ARGIJK")\
  ENUM(LMN_ARGUMENT_USED_TWICE,                             "LMN ARGUMENT USED TWICE")\
  ENUM(LMN_NOT_FOLLOWED_BY_ARGIJK,                          "LMN NOT FOLLOWED BY ARGIJK")\
  ENUM(ILLEGAL_SPACE,                                       "ILLEGAL SPACE")\
  ENUM(MUST_HAVE_NO_ARGUMENTS,                              "MUST HAVE NO ARGUMENTS")\
  ENUM(MUST_HAVE_ONE_ARGUMENT,                              "MUST HAVE ONE ARGUMENT")\
  ENUM(MUST_HAVE_4_ARGUMENTS,                               "MUST HAVE 4 ARGUMENTS")\
  ENUM(MUST_HAVE_4_OR_8_ARGUMENTS,                          "MUST HAVE 4 OR 8 ARGUMENTS")\
  ENUM(MUST_HAVE_7_ARGUMENTS,                               "MUST HAVE 7 ARGUMENTS")\
  ENUM(MUST_HAVE_7_OR_14_ARGUMENTS,                         "MUST HAVE 7 OR 14 ARGUMENTS")\
  ENUM(NON_EVENT_COMMAND_MUST_NOT_HAVE_EVENT_TAG,           "NON EVENT COMMAND MUST NOT HAVE EVENT TAG")\
  ENUM(NUMBER_THROUGH_MUST_BE_INTEGER,                      "NUMBER THROUGH MUST BE INTEGER")\
  ENUM(NUMBER_THROUGH_MUST_BE_POSITIVE,                     "NUMBER THROUGH MUST BE POSITIVE")\
  ENUM(PHI_ARGUMENT_USED_TWICE,                             "PHI ARGUMENT USED TWICE")\
  ENUM(Q_ARGUMENT_USED_TWICE,                               "Q ARGUMENT USED TWICE")\
  ENUM(R_ARGUMENT_USED_TWICE,                               "R ARGUMENT USED TWICE")\
  ENUM(SPACE_MISSING_AFTER_TAG,                             "SPACE MISSING AFTER TAG")\
  ENUM(STEPW_MUST_BE_POSITIVE,                              "STEPW MUST BE POSITIVE")\
  ENUM(TAG_NUMBER_OUT_OF_RANGE_FOR_EVENT_TAG,               "TAG NUMBER OUT OF RANGE FOR EVENT TAG")\
  ENUM(TAG_NUMBER_OUT_OF_RANGE_FOR_COMMAND_TAG,             "TAG NUMBER OUT OF RANGE FOR COMMAND TAG")\
  ENUM(THETA_OUT_OF_RANGE,                                  "THETA OUT OF RANGE")\
  ENUM(TIME_ARGUMENT_USED_TWICE,                            "TIME ARGUMENT USED TWICE")\
  ENUM(TIME_MUST_BE_FOLLOWED_BY_NUMBER_IN_PARENS,           "TIME MUST BE FOLLOWED BY NUMBER IN PARENS")\
  ENUM(TOOL_A_ARGUMENT_USED_TWICE,                          "TOOL A ARGUMENT USED TWICE")\
  ENUM(TOOL_B_ARGUMENT_USED_TWICE,                          "TOOL B ARGUMENT USED TWICE")\
  ENUM(TOOL_C_ARGUMENT_USED_TWICE,                          "TOOL C ARGUMENT USED TWICE")\
  ENUM(X_ARGUMENT_USED_TWICE,                               "X ARGUMENT USED TWICE")\
  ENUM(X_NOT_FOLLOWED_BY_NUMBER_IN_PARENS,                  "X NOT FOLLOWED BY NUMBER IN PARENS")\
  ENUM(X_Y_Z_ALL_MISSING,                                   "X Y Z ALL MISSING")\
  ENUM(Y_ARGUMENT_USED_TWICE,                               "Y ARGUMENT USED TWICE")\
  ENUM(Y_NOT_FOLLOWED_BY_NUMBER_IN_PARENS,                  "Y NOT FOLLOWED BY NUMBER IN PARENS")\
  ENUM(Z_ARGUMENT_USED_TWICE,                               "Z ARGUMENT USED TWICE")\
  ENUM(Z_NOT_FOLLOWED_BY_NUMBER_IN_PARENS,                  "Z NOT FOLLOWED BY NUMBER IN PARENS")\
  ENUM(TOOL_A_NOT_FOLLOWED_BY_NUMBER_IN_PARENS,             "TOOL.A NOT FOLLOWED BY NUMBER IN_PARENS")\
  ENUM(TOOL_B_NOT_FOLLOWED_BY_NUMBER_IN_PARENS,             "TOOL.B NOT FOLLOWED BY NUMBER IN_PARENS")\
  ENUM(TOOL_C_NOT_FOLLOWED_BY_NUMBER_IN_PARENS,             "TOOL.C NOT FOLLOWED BY NUMBER IN_PARENS")\
  ENUM(IJKACT_ARGUMENT_USED_TWICE,                          "IJKACT ARGUMENT USED TWICE")\
  ENUM(DENSITY_MUST_BE_POSITIVE,                            "DENSITY MUST BE POSITIVE")\
  ENUM(MINIMUM_RADIUS_OF_CURVATURE_MUST_BE_POSITIVE,        "MINIMUM RADIUS OF CURVATURE MUST BE POSITIVE")\
  ENUM(ANGLE_ARGUMENT_USED_TWICE,                           "ANGLE ARGUMENT USED TWICE")\
  ENUM(ATNOMINALS_ARGUMENT_USED_TWICE,                      "ATNOMINALS ARGUMENT USED TWICE")\
  ENUM(ANGLE_MUST_BE_FOLLOWED_BY_NUMBER_IN_PARENS,          "ANGLE MUST BE FOLLOWED BY NUMBER IN PARENS")\
  ENUM(ATNOMINALS_NOT_FOLLOWED_BY_BOOLEAN_IN_PARENS,        "ATNOMINALS NOT FOLLOWED BY BOOLEAN IN PARENS")\
  ENUM(BAD_SYNTAX_FOR_FORMAT_IN_SCANONCURVE,                "BAD SYNTAX FOR FORMAT IN SCANONCURVE")\
  ENUM(BAD_NUMBER_OF_ARGUMENT_FOR_DATA_IN_SCANONCURVE,      "BAD NUMBER OF ARGUMENT FOR DATA IN SCANONCURVE")\
  ENUM(NOT_IMPLEMENTED_YET,                                 "NOT_IMPLEMENTED_YET")
                                                            
                                                            
                                                            
std::string  ippCommandParser::getErrorMessageString() const
{                                                           
  std::string errorString ;
  switch(_errorCode) {
#define ENUM(a,b) case a: errorString=b; break;
    PARSER_ERROR_ENUMERATION
#undef ENUM
  }

  std::string retval;

  if ((_commandName > -1) && (_commandName < ippCOMMANDNAMETYPE_MAXIMUM)) {
    retval.append(getCommandNameString(_commandName));
    retval.append(" : ");
  } 
  
  retval.append(errorString);
  return retval;
}

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

/* ippCommandParser::makeArraysBigger

Returned Value: None.

Called By: ippCommandParser::parseArguments

Rules: None.

This doubles the sizes of the four arrays in which arguments are stored.
It also doubles argSize.

This makes new arrays twice the size of its original size, this 
preserve the content of existing data.

*/

void ippCommandParser::makeArraysBigger()
{
  _argSize = (2 * _argSize);
  _argDoubles.resize(_argSize);
  _argKeywords.resize(_argSize);
  _argStrings.resize(_argSize); 
  _argTypes.resize(_argSize);
}


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

/* ippCommandParser::makeAbortE

Returned Value: A ippCommand of commandNameType AbortE as described by the
  command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 9 24 26 (42) [43] 99

*/

ippCommandPtr ippCommandParser::makeAbortE()
{
  if (_argCount != 0) {
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  }
  return ((_errorCode != OK) ? 0 : new ippCommand(_tag, AbortE));
}

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

/* ippCommandParser::makeAlignPart

Returned Value: An AlignPartCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be 7 or 14 arguments.
   MUST_HAVE_7_OR_14_ARGUMENTS
2. The arguments must all be numbers.
   BAD_ARGUMENTS
3. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 28 63 (95) 105

*/

ippCommandPtr ippCommandParser::makeAlignPart()
{
  if (_argCount == 13 ) { 
    if (!match(_argTypes,"#,#,#,#,#,#,#")) {
      _errorCode = BAD_ARGUMENTS;
    }
  } else if ( _argCount == 27 ) {   
    if (!match(_argTypes,"#,#,#,#,#,#,#,#,#,#,#,#,#,#")) {
      _errorCode = BAD_ARGUMENTS;
    }
  } else {
    _errorCode = MUST_HAVE_7_OR_14_ARGUMENTS;
  }
   
  return ((_errorCode != OK) ? NULL:
      (_argCount == 13) ?
      new ippAlignPartCommand(_tag, 
               getValue(0), getValue(2), getValue(4),
               getValue(6), getValue(8), getValue(10),
               getValue(12)) :
      new ippAlignPartCommand(_tag, 
               getValue(0),  getValue(2),  getValue(4),
               getValue(6),  getValue(8),  getValue(10),
               getValue(12), getValue(14), getValue(16),
               getValue(18), getValue(20), getValue(22),
               getValue(24), getValue(26)));
}

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

/* ippCommandParser::makeAlignTool

Returned Value: An AlignToolCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be 4 or 8 arguments.
   MUST_HAVE_4_OR_8_ARGUMENTS
2. The arguments must all be numbers.
   BAD_ARGUMENTS
3. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 27 29 (55) 66 70 102 107

*/

ippCommandPtr ippCommandParser::makeAlignTool()
{

  if (_argCount == 7 ) { 
    if (!match(_argTypes,"#,#,#,#")) {
      _errorCode = BAD_ARGUMENTS;
    }
  } else if ( _argCount == 15 ) {   
    if (!match(_argTypes,"#,#,#,#,#,#,#,#")) {
      _errorCode = BAD_ARGUMENTS;
    }
  } else {
    _errorCode = MUST_HAVE_4_OR_8_ARGUMENTS;
  }
  return ((_errorCode != OK) ? NULL:
    (_argCount == 7) ?
    new ippAlignToolCommand(_tag,  getValue(0), getValue(2),
             getValue(4), getValue(6)) :
    new ippAlignToolCommand(_tag, getValue(0), getValue(2),
             getValue(4), getValue(6),
             getValue(8), getValue(10),
             getValue(12), getValue(14)));
}

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

/* ippCommandParser::makeCenterPart

Returned Value: A CenterPartCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be 4 arguments.
   MUST_HAVE_4_ARGUMENTS
2. The arguments must all be numbers.
   BAD_ARGUMENTS
3. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 27 (96) 102

*/

ippCommandPtr ippCommandParser::makeCenterPart()
{
  if (_argCount != 7) {
    _errorCode = MUST_HAVE_4_ARGUMENTS;
  }
  if (!match(_argTypes,"#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
  }
  return ((_errorCode != OK) ? NULL:
    new ippCenterPartCommand(_tag, getValue(0), getValue(2),
        getValue(4), getValue(6)));
}

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

/* ippCommandParser::makeChangeTool

Returned Value: A ChangeToolCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one argument.
   MUST_HAVE_ONE_ARGUMENT
2. The argument must be a string.
   ARGUMENT_MUST_BE_STRING

Reference pages: 24 27 29 (54) (57) (58) (78) 98 102 106

*/

ippCommandPtr ippCommandParser::makeChangeTool()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if (_argTypes[0] != ARGSTRING)
    _errorCode = ARGUMENT_MUST_BE_STRING;
  return ((_errorCode != OK) ? NULL :
    (new ippChangeToolCommand(_tag, _argStrings[0].c_str())));
}

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

/* ippCommandParser::makeClearAllErrors

Returned Value: A ippCommand of commandNameType ClearAllErrors as described
  by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 26 [38] (40) (41) (42) (43) [44] (47) (75) 76 99

*/

ippCommandPtr ippCommandParser::makeClearAllErrors()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, ClearAllErrors)));
}

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

/* ippCommandParser::makeDisableUser

Returned Value: A ippCommand of commandNameType DisableUser as described
  by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 27 (48) (51) (53) 102

*/

ippCommandPtr ippCommandParser::makeDisableUser()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, DisableUser)));
}

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

/* ippCommandParser::makeEnableUser

Returned Value: A ippCommand of commandNameType EnableUser as described by
  the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 27 [39] (48) (51) 102

*/

ippCommandPtr ippCommandParser::makeEnableUser()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, EnableUser)));
}

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

/* ippCommandParser::makeEndSession

Returned Value: A ippCommand of commandNameType EndSession as described by
  the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 18 20 24 26 (41) (77) 99

*/

ippCommandPtr ippCommandParser::makeEndSession()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, EndSession)));
}

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

/* ippCommandParser::makeEnumAllProp

Returned Value: An EnumAllPropCommand as described by the command text,
  or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one argument.
   BAD_ARGUMENTS
2. The argument must have one of the following patterns.
   key1()
   key1.key2()
   key1.key2.key3()
   key1.key2.key3.key4()
3. key1 must be FoundTool or Tool 
   ARGUMENT_FIRST_PART_MUST_BE_TOOL_OR_FOUNDTOOL
4. key2 must be GoToPar or PtMeasPar.
   ARGUMENT_SECOND_PART_MUST_BE_GOTOPAR_OR_PTMEASPAR
5. If key2 is GoToPar, key3 must be Speed or Accel.
   If key2 is PtMeasPar, key3 must be one of
   Speed, Accel, Approach, Retract, or Search.
   ARGUMENT_THIRD_PART_BAD
6. If there is a key4, it must be Act, Def, Max, or Min.
   ARGUMENT_FOURTH_PART_BAD
7. The dots must be placed as shown in rule 2.
   BAD_DOTS
8. The empty parentheses must be placed as shown in rule 2.
   ARGUMENT_MUST_END_WITH_EMPTY_PARENTHESES

Reference pages: 24 26 45 (46) [74] 99

See the documentation of ippCommandParser::makeGetProp.

This is not allowing Alignment, CollisionVolume, Name, or Id, since
the spec allows them only with GetProp.

*/

ippCommandPtr ippCommandParser::makeEnumAllProp()
{

  ippOtherKeyType key1 = EmptyKey;
  ippOtherKeyType key2 = EmptyKey;
  ippOtherKeyType key3 = EmptyKey;
  ippOtherKeyType key4 = EmptyKey;

  if (_argCount == 2 && match(_argTypes,"kE")) {
    key1 = _argKeywords[0];
  } else if (_argCount == 4 && match(_argTypes,"k.kE")) { 
    key1 = _argKeywords[0];
    key2 = _argKeywords[2];
  } else if (_argCount == 6 && match(_argTypes,"k.k.kE")) { 
    key1 = _argKeywords[0];
    key2 = _argKeywords[2];
    key3 = _argKeywords[4];
  } else if (_argCount == 8 && match(_argTypes,"k.k.k.kE")) { 
    key1 = _argKeywords[0];
    key2 = _argKeywords[2];
    key3 = _argKeywords[4];
    key4 = _argKeywords[6];
  } else {
    _errorCode =  BAD_ARGUMENTS;
    return 0;

  }
  ippProp prop(key1,key2,key3,key4);
  if (!IsObjectOrProperty(prop)) {
    _errorCode =  BAD_ARGUMENTS;
    return 0;
  }

  ippEnumAllPropCommandPtr command = new ippEnumAllPropCommand(_tag,prop);

  return command;
}

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

/* ippCommandParser::makeEnumProp

Returned Value: An EnumPropCommand as described by the command text,
  or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one argument.
   BAD_ARGUMENTS
2. The argument must have one of the following patterns.
   key1()
   key1.key2()
   key1.key2.key3()
   key1.key2.key3.key4()
3. key1 must be FoundTool or Tool.
   ARGUMENT_FIRST_PART_MUST_BE_TOOL_OR_FOUNDTOOL
4. If there is a key2, it must be GoToPar or PtMeasPar.
   ARGUMENT_SECOND_PART_MUST_BE_GOTOPAR_OR_PTMEASPAR
5. If key2 is GoToPar and there is a key3, key3 must be Speed or MaxAccel.
   If key2 is PtMeasPar and there is a key3, key3 must be one of
   Speed, Accel, Approach, Retract, or Search.
   ARGUMENT_THIRD_PART_BAD
6. If there is a key4, it must be Act, Def, Max, or Min.
   ARGUMENT_FOURTH_PART_BAD
7. The dots must be placed as shown in rule 1.
   BAD_DOTS
8. The empty parentheses must be placed as shown in rule 1.
   ARGUMENT_MUST_END_WITH_EMPTY_PARENTHESES

Reference pages: 24 26 29 (45) [73] 99 108 109 110 111 

See the documentation of ippCommandParser::makeGetProp.

This is not allowing Alignment, CollisionVolume, Name, or Id, since
the spec allows them only with GetProp.

*/

ippCommandPtr ippCommandParser::makeEnumProp()
{

  ippOtherKeyType key1 = EmptyKey;
  ippOtherKeyType key2 = EmptyKey;
  ippOtherKeyType key3 = EmptyKey;
  ippOtherKeyType key4 = EmptyKey;

  if (_argCount == 2 && match(_argTypes,"kE")) {
    key1 = _argKeywords[0];
  } else if (_argCount == 4 && match(_argTypes,"k.kE")) { 
    key1 = _argKeywords[0];
    key2 = _argKeywords[2];
  } else if (_argCount == 6 && match(_argTypes,"k.k.kE")) { 
    key1 = _argKeywords[0];
    key2 = _argKeywords[2];
    key3 = _argKeywords[4];
  } else if (_argCount == 8 && match(_argTypes,"k.k.k.kE")) { 
    key1 = _argKeywords[0];
    key2 = _argKeywords[2];
    key3 = _argKeywords[4];
    key4 = _argKeywords[6];
  } else {
    _errorCode =  BAD_ARGUMENTS;
    return 0;

  }
  ippProp prop(key1,key2,key3,key4);
  if (!IsObjectOrProperty(prop)) {
    _errorCode =  BAD_ARGUMENTS;
    return 0;
  }
  ippEnumPropCommandPtr command = new ippEnumPropCommand(_tag,prop);
  return command;

}

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

/* ippCommandParser::makeEnumTools

Returned Value: A ippCommand of commandNameType EnumTools as described by
  the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 29 (53) (54) (56) 106

*/

ippCommandPtr ippCommandParser::makeEnumTools()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippEnumToolsCommand(_tag)));
}

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

/* ippCommandParser::makeFindTool

Returned Value: A FindToolCommand as described by the command text,
  or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one argument.
   MUST_HAVE_ONE_ARGUMENT
2. The argument must be a string.
   ARGUMENT_MUST_BE_STRING

Reference pages: 24 27 29 (54) [74] 102 106

*/

ippCommandPtr ippCommandParser::makeFindTool()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if (_argTypes[0] != ARGSTRING)
    _errorCode = ARGUMENT_MUST_BE_STRING;
  return((_errorCode != OK) ? NULL: (new ippFindToolCommand(_tag, _argStrings[0].c_str())));
}

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

/* ippCommandParser::makeGet

Returned Value: A GetCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one to seven arguments.
   BAD_ARGUMENTS
2. Each argument must be R(), X(), Y(), Z(), Tool.A(), Tool.B() or Tool.C(),
   which may appear in any order.
   BAD_ARGUMENTS
3. Each allowed argument must appear at most once.
   R_ARGUMENT_USED_TWICE
   X_ARGUMENT_USED_TWICE
   Y_ARGUMENT_USED_TWICE
   Z_ARGUMENT_USED_TWICE
   TOOL_A_ARGUMENT_USED_TWICE
   TOOL_B_ARGUMENT_USED_TWICE
   TOOL_C_ARGUMENT_USED_TWICE
4. Commas must separate the arguments if there are two or more.
   BAD_ARGUMENTS

Reference pages: 24 27 [38] [44] (49) (51) 57 (61) (63) (66) (81) 102

Tool properties that can be set directly are intended to be obtained
by GetProp, not by Get.

This function is similar to makeGoTo.

This function is messy because it takes a variable number of arguments
and the arguments may have different numbers of components, e.g., "X()"
has 2 components while "Tool.A()" has 4.

The check (((n + 2) < _argCount) && ((n + 3) == _argCount)) is to detect
the case of a comma at the end of the argument list, which will otherwise
slip by. The (((n + 4) < _argCount) && ((n + 5) == _argCount)) does the
same thing.

*/

ippCommandPtr ippCommandParser::makeGet()
{
  bool hasR = false;
  bool hasX = false;
  bool hasY = false;
  bool hasZ = false;
  bool hasToolA = false;
  bool hasToolB = false;
  bool hasToolC = false;

  if (_argCount < 2) {
    _errorCode = BAD_ARGUMENTS;
  }
  int n =0;

  while (n < _argCount && _errorCode == OK) {
    int old_n=n;
    CheckOptionalArgument(n,hasR    ,_R   ,       R_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasX    ,_X   ,       X_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasY    ,_Y   ,       Y_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasZ    ,_Z   ,       Z_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasToolA,Tool,_A,TOOL_A_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasToolB,Tool,_B,TOOL_B_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasToolC,Tool,_C,TOOL_C_ARGUMENT_USED_TWICE);    
    if (old_n == n) { 
      // the argument has not been recognized:
      _errorCode = BAD_ARGUMENTS;
    } 
  }
  return ((_errorCode != OK) ? NULL:
    (new ippGetCommand(_tag, hasR, hasX, hasY, hasZ,
        hasToolA, hasToolB, hasToolC)));
}

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

/* ippCommandParser::makeGetChangeToolAction

Returned Value: A GetChangeToolActionCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one argument.
   MUST_HAVE_ONE_ARGUMENT
2. The argument must be a string.
   ARGUMENT_MUST_BE_STRING

Reference pages: 24 27 29 (57-58) 102 106

*/

ippCommandPtr ippCommandParser::makeGetChangeToolAction()
{
  if (_argCount != 1) {
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  } else if (_argTypes[0] != ARGSTRING) {
    _errorCode = ARGUMENT_MUST_BE_STRING;
  }
  return ((_errorCode != OK) ? NULL :
    (new ippGetChangeToolActionCommand(_tag, _argStrings[0].c_str())));
}

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

/* ippCommandParser::makeGetCoordSystem

Returned Value: A ippCommand of commandNameType GetCoordSystem as described by
  the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 28 (59) 103

*/

ippCommandPtr ippCommandParser::makeGetCoordSystem()
{
  if (_argCount != 0)  {
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  }
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, GetCoordSystem)));
}

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

/* ippCommandParser::makeGetCsyTransformation

Returned Value: A GetCsyTransformationCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one argument.
   MUST_HAVE_ONE_ARGUMENT
2. The argument must be one of: JogDisplayCsy, JogMoveCsy, MoveableMachineCsy,
   MultipleArmCsy, PartCsy, SensorCsy.
   BAD_ARGUMENTS

Reference pages: 24 28 (60) (80) 103

*/

ippCommandPtr ippCommandParser::makeGetCsyTransformation()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if ((_argTypes[0] != ARGKEYWORD) ||
     ((_argKeywords[0] != JogDisplayCsy) &&
      (_argKeywords[0] != JogMoveCsy) &&
      (_argKeywords[0] != MoveableMachineCsy) &&
      (_argKeywords[0] != MultipleArmCsy) &&
      (_argKeywords[0] != PartCsy) &&
      (_argKeywords[0] != SensorCsy)))
    _errorCode = BAD_ARGUMENTS;
  return ((_errorCode != OK) ? NULL :
    (new ippGetCsyTransformationCommand(_tag, (ippCoordSysType)_argKeywords[0])));
}

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

/* ippCommandParser::makeGetDMEVersion

Returned Value: A ippCommand of commandNameType GetDMEVersion as
described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 26 (46) [47] 99

*/

ippCommandPtr ippCommandParser::makeGetDMEVersion()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, GetDMEVersion)));
}

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

/* ippCommandParser::makeGetErrorInfo

Returned Value: A GetErrorInfoCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one argument.
   MUST_HAVE_ONE_ARGUMENT
2. The argument must be an integer.
   ARGUMENT_MUST_BE_INTEGER

Reference pages: 19 24 26 (43) 76 99
Page 76 does not mention the command but gives allowable error numbers.

For GetErrorInfo, the value of the argument is stored as a double
even though it must be an integer. This is so that argument reading
does not require the context of knowing the command. Here it is
checked that the double has an integer value.

*/

ippCommandPtr ippCommandParser::makeGetErrorInfo()
{
  if (_argCount != 1){
    _errorCode =  MUST_HAVE_ONE_ARGUMENT;      
  } else if ((_argTypes[0] != ARGDOUBLE) || !IsInteger(getValue(0))){
    _errorCode = ARGUMENT_MUST_BE_INTEGER; 
  }
  return ((_errorCode != OK) ? NULL :
    (new  ippGetErrorInfoCommand(_tag, Convert2ippErrorNameType(getValue(0)))));
}

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

/* ippCommandParser::makeGetErrStatusE

Returned Value: A ippCommand of commandNameType GetErrStatusE as described by
  the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 27 (50) 102

*/

ippCommandPtr ippCommandParser::makeGetErrStatusE()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, GetErrStatusE)));
}

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

/* ippCommandParser::makeGetMachineClass

Returned Value: A ippCommand of commandNameType GetMachineClass as described by
  the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 18 24 27 (50) 102

*/

ippCommandPtr ippCommandParser::makeGetMachineClass()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, GetMachineClass)));
}

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

/* ippCommandParser::makeGetProp

Returned Value: A GetPropCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be at least one argument, and each argument must have one of
   the three patterns:
   key1.key2() -- four components in _argCount
   key1.key2.key3() -- six components in _argCount
   key1.key2.key3.key4() -- eight components in _argCount
   and all arguments except the last must be followed by a comma.
   BAD_ARGUMENTS
   ARGUMENT_SECOND_PART_BAD
2. key1 must be FoundTool or Tool.
   ARGUMENT_FIRST_PART_MUST_BE_TOOL_OR_FOUNDTOOL
3. If the pattern is key1.key2():
   If key1 is Tool, key2 must be Alignment, CollisionVolume, Name, or Id.
   If key1 is FoundTool, key2 must be Name, or Id.
   ARGUMENT_SECOND_PART_BAD
4. If key2 is GoToPar, key3 must be Speed or Accel.
   If key2 is PtMeasPar, key3 must be one of
   Speed, Accel, Approach, Retract, or Search.
   ARGUMENT_THIRD_PART_BAD
5. If there is a key4, it must be Act, Def, Max, or Min.
   ARGUMENT_FOURTH_PART_BAD
6. The dots must be placed where shown in rule 1.
   BAD_DOTS
7. The empty parentheses must be placed where shown in rule 1.
   ARGUMENT_MUST_END_WITH_EMPTY_PARENTHESES

Reference pages: 24 26 29 (45) 66 67 [68] [69] 70 [73] [74] 77 79 99 108

The spec is not clear about what should be allowed as arguments.  Here
we assume that only primitive types (string, bool, number) can be
obtained, so the arguments must refer to something whose type is
primitive. For example, GetProp(Tool.PtMeasPar.Speed()) is OK, but
GetProp(Tool.PtMeasPar()) is not OK since the value of PtMeasPar is an
object, not a primitive type.

The spec implies, without being explicit, that key3() and key3.Act()
are both allowed and mean the same thing.

The spec states that GetProp may be used to query settable properties.
It says explicitly that Speed.Max cannot be queried using GetProp.
NIST has raised an issue against only allowing settable properties.
This function allows querying Speed.Max.

The spec is also not clear about whether CanChange, CanChangeSpeed, and
CanChangeAccel are allowable keywords. These are included on pages 29,
109, and 110 for GoToPars, PtMeasPars, and Param. None of the examples
of GetProp uses either of them. We are assuming they are not allowed.

We are assuming here that the properties (other than CanChange) of
"param" objects defined on pages 29, 109 and 110 are intended to be
accessible. These properties are not mentioned in section 6 and are
not included in any examples of GetProp. In a telephone conversation
with Josef Resch, however, he said Speed.Max should be used rather
than MaxSpeed.

The forms MaxSpeed, MinSpeed, MaxAccel, and MinAccel appear on pages
9, 29, 109, and 110, but not in section 6. They are not allowed here.

The spec on page 66 does not allow FoundTool.Name() or FoundTool.Id(),
but this appears to be an oversight and NIST has submitted a comment
suggesting FoundTool should be allowed. This function allows FoundTool.

The _argCount is a count of components of arguments, not a count of
arguments.

The [(_argCount + 1) / 5] size for the keys arrays is used because this
is the smallest number that is sure to be at least as large as the
number of arguments. Each argument must have at least four components,
and the arguments are separated by commas (which are added into _argCount).

*/


ippCommandPtr ippCommandParser::makeGetProp()
{
  // syntax analysis
  ippGetPropCommandPtr command;
  if ( _commandName == GetProp ) { 
    command = new ippGetPropCommand(_tag);
  } else if(_commandName == GetPropE ) { 
    command = new ippGetPropECommand(_tag);
  }


  for (int n = 0; ((n < _argCount) && (_errorCode == OK));n++)  {
  
    ippOtherKeyType key1 = ippOtherKeyType_INVALID;
    ippOtherKeyType key2 = EmptyKey;
    ippOtherKeyType key3 = EmptyKey;
    ippOtherKeyType key4 = EmptyKey;

    if (match(_argTypes,"k.k.k.kE",n))  {
      key1 = _argKeywords[n];
      key2 = _argKeywords[n+2];
      key3 = _argKeywords[n+4];
      key4 = _argKeywords[n+6];
      n += 8;

    } else if (match(_argTypes,"k.k.kE",n)) { 
      key1 = _argKeywords[n];
      key2 = _argKeywords[n+2];
      key3 = _argKeywords[n+4];
      n += 6;
    } else if (match(_argTypes,"k.kE",n)) { 
      key1 = _argKeywords[n];
      key2 = _argKeywords[n+2];
      n += 4;
    } else if (match(_argTypes,"kE",n)) { 
      key1 = _argKeywords[n];
      n += 2;
    } else {
      _errorCode = BAD_ARGUMENTS;
    }
    if (n < _argCount && _argTypes[n] != ARGCOMMA) {
      _errorCode = BAD_ARGUMENTS;
    }
    if(_errorCode == OK ) { 
      ippProp prop(key1,key2,key3,key4);
      if (PropertyIsAllowed(prop)) { 
        command->addProp(prop);
      } else {
       _errorCode = BAD_ARGUMENTS;
     }
    }
  }
  if (_errorCode != OK) {
    return 0;
  }
  return command;
}


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

/* ippCommandParser::makeGetPropE

Returned Value: A GetPropECommand as described by the command text, or NULL.

This is identical to ippCommandParser::makeGetProp except that GetProp is changed
to GetPropE (and GETPROP to GETPROPE).
See the documentation there.

*/
ippCommandPtr ippCommandParser::makeGetPropE()
{
  // same as GetProp : so delegate !
  return makeGetProp();
}



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

/* ippCommandParser::makeGetXtdErrStatus

Returned Value: A ippCommand of commandNameType GetXtdErrStatus as described by
  the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 27 (50) 102

*/

ippCommandPtr ippCommandParser::makeGetXtdErrStatus()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, GetXtdErrStatus)));
}

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

/* ippCommandParser::makeGoTo

Returned Value: A GoToCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one to six arguments.
   BAD_ARGUMENTS
2. Each argument must be X(<number>), Y(<number>), Z(<number>),
   Tool.A(<number>), Tool.B(<number>) or Tool.C(<number>),
   which may appear in any order.
   BAD_ARGUMENTS
3. Each allowed argument must appear at most once.
   X_ARGUMENT_USED_TWICE
   Y_ARGUMENT_USED_TWICE
   Z_ARGUMENT_USED_TWICE
   TOOL_A_ARGUMENT_USED_TWICE
   TOOL_B_ARGUMENT_USED_TWICE
   TOOL_C_ARGUMENT_USED_TWICE
4. Commas must separate the arguments if there are two or more.
   BAD_ARGUMENTS

Reference pages: 24 27 [38] [43] (51 - 53) (58) (62) [71] [72] (78) (98) 102

This function is similar to makeGet.

*/

ippCommandPtr ippCommandParser::makeGoTo()
{

  bool hasX = false;
  bool hasY = false;
  bool hasZ = false;
  double x = 0;
  double y = 0;
  double z = 0;
  bool hasToolA = false;
  bool hasToolB = false;
  bool hasToolC = false;
  double toolA = 0;
  double toolB = 0;
  double toolC = 0;

  if (_argCount < 2) {
    _errorCode = BAD_ARGUMENTS;
  }
  int n =0;

  while (n < _argCount && _errorCode == OK) {
    int old_n=n;
    CheckOptionalArgumentValue(n,hasX    ,_X   ,       X_ARGUMENT_USED_TWICE, X_NOT_FOLLOWED_BY_NUMBER_IN_PARENS, x);
    CheckOptionalArgumentValue(n,hasY    ,_Y   ,       Y_ARGUMENT_USED_TWICE, Y_NOT_FOLLOWED_BY_NUMBER_IN_PARENS, y);
    CheckOptionalArgumentValue(n,hasZ    ,_Z   ,       Z_ARGUMENT_USED_TWICE, Z_NOT_FOLLOWED_BY_NUMBER_IN_PARENS, z);
    CheckOptionalArgumentValue(n,hasToolA,Tool,_A,TOOL_A_ARGUMENT_USED_TWICE, TOOL_A_NOT_FOLLOWED_BY_NUMBER_IN_PARENS, toolA);
    CheckOptionalArgumentValue(n,hasToolB,Tool,_B,TOOL_B_ARGUMENT_USED_TWICE, TOOL_B_NOT_FOLLOWED_BY_NUMBER_IN_PARENS, toolB);
    CheckOptionalArgumentValue(n,hasToolC,Tool,_C,TOOL_C_ARGUMENT_USED_TWICE, TOOL_C_NOT_FOLLOWED_BY_NUMBER_IN_PARENS, toolC);    
    if (old_n == n) { 
      // the argument has not been recognized:
      _errorCode = BAD_ARGUMENTS;
    } 
  }

  return ((_errorCode != OK) ? NULL:
    (new ippGoToCommand(_tag, hasX, hasY, hasZ, x, y, z, hasToolA,
         hasToolB, hasToolC, toolA, toolB, toolC)));
}

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

/* ippCommandParser::makeHome

Returned Value: A ippCommand of commandNameType Home as described by
  the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 27 [38] (48) 102

*/

ippCommandPtr ippCommandParser::makeHome()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, Home)));
}

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

/* ippCommandParser::makeIsHomed

Returned Value: A ippCommand of commandNameType IsHomed as described by
  the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 27 (48) 102 111

*/

ippCommandPtr ippCommandParser::makeIsHomed()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, IsHomed)));
}

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

/* ippCommandParser::makeIsUserEnabled

Returned Value: A ippCommand of commandNameType IsUserEnabled as described by
  the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 27 (49) 102

*/

ippCommandPtr ippCommandParser::makeIsUserEnabled()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, IsUserEnabled)));
}

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

/* ippCommandParser::makeLockAxis

Returned Value: A LockAxisCommand as described by the command text,
  or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one to nine arguments.
   BAD_ARGUMENTS
2. Each argument must be C(), Phi(), R(), X(), Y(), Z(),
   which may appear in any order.
   BAD_ARGUMENTS
3. Each allowed argument must appear at most once.
   C_ARGUMENT_USED_TWICE
   PHI_ARGUMENT_USED_TWICE
   R_ARGUMENT_USED_TWICE
   X_ARGUMENT_USED_TWICE
   Y_ARGUMENT_USED_TWICE
   Z_ARGUMENT_USED_TWICE
4. Commas must separate the arguments if there are two or more.
   BAD_ARGUMENTS

Reference pages: 24 (97-98)

The spec does not forbid having no arguments, but here there must be
at least one argument.

It is not necessary to check for too many arguments, because if there
were too many, at least one would be duplicated, and a check for
duplicates is made.

*/

ippCommandPtr ippCommandParser::makeLockAxis()
{
  bool hasC = false;
  bool hasPhi = false;
  bool hasR = false;
  bool hasX = false;
  bool hasY = false;
  bool hasZ = false;

  if (_argCount < 2) {
    _errorCode = BAD_ARGUMENTS;
  }
  int n =0; // index for components of command arguments
  while (n < _argCount && _errorCode == OK) {
    int old_n=n;
    CheckOptionalArgument(n,hasC    ,_C   ,  C_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasPhi  ,Phi  ,PHI_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasR    ,_R   ,  R_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasX    ,_X   ,  X_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasY    ,_Y   ,  Y_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasZ    ,_Z   ,  Z_ARGUMENT_USED_TWICE);
    if (old_n == n) { 
      // the argument has not been recognized:
      _errorCode = BAD_ARGUMENTS;
    } 
  }
  return ((_errorCode != OK) ? NULL :
    (new ippLockAxisCommand(_tag, hasC, hasPhi, hasR, hasX, hasY, hasZ)));
}

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

/* ippCommandParser::makeOnMoveReportE

Returned Value: An OnMoveReportECommand as described by the command text,
  or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be zero to nine arguments.
   BAD_ARGUMENTS
2. Each argument must be one of R(), X(), Y(), Z(), Tool.A(), Tool.B(),
   Tool.C(), Dis(<number>), or Time(<number>), which may appear in any order.
   DIS_MUST_BE_FOLLOWED_BY_NUMBER_IN_PARENS
   TIME_MUST_BE_FOLLOWED_BY_NUMBER_IN_PARENS
3. Each allowed argument must appear at most once.
   R_ARGUMENT_USED_TWICE
   X_ARGUMENT_USED_TWICE
   Y_ARGUMENT_USED_TWICE
   Z_ARGUMENT_USED_TWICE
   TOOL_A_ARGUMENT_USED_TWICE
   TOOL_B_ARGUMENT_USED_TWICE
   TOOL_C_ARGUMENT_USED_TWICE
   DIS_ARGUMENT_USED_TWICE
   TIME_ARGUMENT_USED_TWICE
4. Commas must separate the arguments if there are two or more.
   BAD_ARGUMENTS

Reference pages: 19 24 27 [39] (49 - 50) 102
This is referenced as "OnReport" on pages 56, 57, 61, 63, and 66.

Much of this function is identical to the makeGet function. The differences
are that in this function it is OK to have no arguments, and in this
function Dis(<number>) and Time(<number>) are allowed as arguments.

It is not necessary to check for too many arguments, because if there
were too many, at least one would be duplicated, and a check for
duplicates is made.

*/

ippCommandPtr ippCommandParser::makeOnMoveReportE()
{
  int n;
  bool hasR = false;
  bool hasX = false;
  bool hasY = false;
  bool hasZ = false;
  bool hasToolA = false;
  bool hasToolB = false;
  bool hasToolC = false;
  bool hasDis = false;
  bool hasTime = false;
  double theDis = 100.0;
  double theTime = 100.0;
  
  n = 0;
  while (n < _argCount && _errorCode == OK) {
    int old_n=n;
    CheckOptionalArgument(n,hasR    ,_R   ,       R_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasX    ,_X   ,       X_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasY    ,_Y   ,       Y_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasZ    ,_Z   ,       Z_ARGUMENT_USED_TWICE);

    CheckOptionalArgument(n,hasToolA,Tool,_A,TOOL_A_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasToolB,Tool,_B,TOOL_B_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasToolC,Tool,_C,TOOL_C_ARGUMENT_USED_TWICE);

    CheckOptionalArgumentValue(n,hasTime,Time,TIME_ARGUMENT_USED_TWICE,TIME_MUST_BE_FOLLOWED_BY_NUMBER_IN_PARENS,theTime);
    CheckOptionalArgumentValue(n,hasDis ,Dis , DIS_ARGUMENT_USED_TWICE, DIS_MUST_BE_FOLLOWED_BY_NUMBER_IN_PARENS,theDis);
    if (old_n == n) { 
      // the argument has not been recognized:
      _errorCode = BAD_ARGUMENTS;
    }
  }

  return ((_errorCode != OK) ? NULL:
    (new ippOnMoveReportECommand(_tag, hasR, hasX, hasY, hasZ, hasToolA,
           hasToolB, hasToolC, hasDis, hasTime, theDis, theTime)));
}

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

/* ippCommandParser::makeOnPtMeasReport

Returned Value: An OnPtMeasReportCommand as described by the command text,
  or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one to nine arguments.
   BAD_ARGUMENTS
2. Each argument must be ER(), IJK(), R(), X(), Y(), Z(), Tool.A(),
   Tool.B() or Tool.C(), which may appear in any order.
   BAD_ARGUMENTS
3. Each allowed argument must appear at most once.
   ER_ARGUMENT_USED_TWICE
   IJK_ARGUMENT_USED_TWICE
   R_ARGUMENT_USED_TWICE
   X_ARGUMENT_USED_TWICE
   Y_ARGUMENT_USED_TWICE
   Z_ARGUMENT_USED_TWICE
   TOOL_A_ARGUMENT_USED_TWICE
   TOOL_B_ARGUMENT_USED_TWICE
   TOOL_C_ARGUMENT_USED_TWICE
4. Commas must separate the arguments if there are two or more.
   BAD_ARGUMENTS

Reference pages: 24 27 (41) (49) (52) (53) 61 [71] [72] (78) 102
This is referenced as "OnReport" on pages 56, 57, 61, 63, and 66.

The body of the function is similar to the body of makeGet.
See documentation of makeGet.

The spec forbids having no arguments.

It is not necessary to check for too many arguments, because if there
were too many, at least one would be duplicated, and a check for
duplicates is made.

*/

/*
 * check if the next argument is of the specified type
 * if the argument has not been found yet ( hasArgument = false in entry ) 
 * and if the argument is found the method returns true.
 * 
 */
bool ippCommandParser::CheckOptionalArgument(
  int& n,
  bool& hasArgument,
  ippOtherKeyType type,
  ippParserCmdErrorId errorIfDuplicated
  )
{
  if (_errorCode != OK) return false;
  if (_argCount < n+2)  return false;

  if (_argTypes[n] != ARGKEYWORD ) { 
    return false;
  }

  if (_argKeywords[n] != type) { 
    return false; // ignore ,not for us
  } else {
    if (hasArgument ) { 
      _errorCode = errorIfDuplicated;      
    } else {
      hasArgument = true;
      if (_argTypes[n+1] != ARGPARENEMPTY) { 
        _errorCode = BAD_ARGUMENTS;
        return false;
      }
      if ( n+2 < _argCount && _argTypes[n+2] != ARGCOMMA ) { 
        _errorCode = BAD_ARGUMENTS;
        return false;
      }
    }
    n +=3;
  }
  if (_errorCode == OK ) {
    return true;
  } 
  return false;
}
bool ippCommandParser::CheckOptionalArgument(
  int& n,
  bool& hasArgument,
  ippOtherKeyType type1,
  ippOtherKeyType type2,
  ippParserCmdErrorId errorIfDuplicated
  )
{
  if (_errorCode != OK)  {  return false; }
  if (_argCount < n+3) { return false;}

  if (_argTypes[n] != ARGKEYWORD ||_argTypes[n+1]!=ARGDOT ||_argTypes[n+2] != ARGKEYWORD) {
    return false;
  }

  if (_argKeywords[n] != type1 || _argKeywords[n+2] != type2) { 
    return false; // ignore ,not for us
  } else {
    if (hasArgument ) { 
      _errorCode = errorIfDuplicated;      
    } else {
      hasArgument = true;
    }
    if (_argTypes[n+3] != ARGPARENEMPTY ) { 
      _errorCode = BAD_ARGUMENTS;
      return false;
    }
    if ( n+4 < _argCount && _argTypes[n+4] != ARGCOMMA ) { 
      _errorCode = BAD_ARGUMENTS;
      return false;
    }
    n +=5;
  }
  if (_errorCode == OK ) {
    return true;
  } 
  return false;
}




ippCommandPtr ippCommandParser::makeOnPtMeasReport()
{
  int n; // index for components of command arguments
  bool hasER = false;
  bool hasIJK = false;
  bool hasIJKAct = false;
  bool hasQ = false;
  bool hasR = false;
  bool hasX = false;
  bool hasY = false;
  bool hasZ = false;
  bool hasToolA = false;
  bool hasToolB = false;
  bool hasToolC = false;

  if (_argCount <2  ) { 
    _errorCode = BAD_ARGUMENTS;
  }
  n = 0;
  while (n < _argCount && _errorCode == OK) {
    int old_n=n;
    CheckOptionalArgument(n,hasER   ,ER  ,      ER_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasIJK  ,_IJK ,     IJK_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasIJKAct,_IJKAct,  IJKACT_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasQ    ,Q   ,       Q_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasR    ,_R   ,       R_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasX    ,_X   ,       X_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasY    ,_Y   ,       Y_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasZ    ,_Z   ,       Z_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasToolA,Tool,_A,TOOL_A_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasToolB,Tool,_B,TOOL_B_ARGUMENT_USED_TWICE);
    CheckOptionalArgument(n,hasToolC,Tool,_C,TOOL_C_ARGUMENT_USED_TWICE);

    if (old_n == n) { 
      // the argument has not been recognized:
      _errorCode = BAD_ARGUMENTS;
    }
  }
  return ((_errorCode != OK) ? NULL :
    (new ippOnPtMeasReportCommand(_tag, hasER, hasIJK,hasQ, hasR, hasX, hasY,
             hasZ,hasToolA, hasToolB, hasToolC,hasIJKAct)));
}




/*
 *! ippCommandParser::makeOnScanReport
 * Returned Value: An OnScanReportCommand as described by the command text or NULL.
 * Called By: ippCommandParser::makeCommand

Rules:
1. There must be one to eight arguments.
   BAD_ARGUMENTS

2. Each argument must be Q(), R(), X(), Y(), or Z(), Tool.A(), Tool.B(),
   or Tool.C(), which may appear in any order.
   ipp 1.5: can also  IJK(),IJKAct(),ER() are also possible
   
   BAD_ARGUMENTS
3. Each allowed argument must appear at most once.
   ER_ARGUMENT_USED_TWICE
   IJK_ARGUMENT_USED_TWICE
   Q_ARGUMENT_USED_TWICE
   R_ARGUMENT_USED_TWICE
   X_ARGUMENT_USED_TWICE
   Y_ARGUMENT_USED_TWICE
   Z_ARGUMENT_USED_TWICE
   TOOL_A_ARGUMENT_USED_TWICE
   TOOL_B_ARGUMENT_USED_TWICE
   TOOL_C_ARGUMENT_USED_TWICE
4. Commas must separate the arguments if there are two or more.
   BAD_ARGUMENTS

Reference pages: 24 27 (41) (81) 82 83 84 86 87 88 90 91 [93] 103

The body of the function is similar to the body of makeOnPtMeasReport,
except that Q is added and the names of the error codes are
different.

It is not necessary to check for too many arguments, because if there
were too many, at least one would be duplicated, and a check for
duplicates is made.

Although the spec is not specific, this does not allow no arguments.

*/

ippCommandPtr ippCommandParser::makeOnScanReport()
{
  int n; // index for components of command arguments
  bool hasER = false;
  bool hasIJK = false;
  bool hasIJKAct = false;
  bool hasQ = false;
  bool hasR = false;
  bool hasX = false;
  bool hasY = false;
  bool hasZ = false;
  bool hasToolA = false;
  bool hasToolB = false;
  bool hasToolC = false;

  /*
    These record the order of the reported items
  */

  if (_argCount <2  ) { 
    _errorCode = BAD_ARGUMENTS;
  }
  n = 0;

  ippOnScanReportCommandPtr cmd  = new ippOnScanReportCommand(_tag);

  while (n < _argCount && _errorCode == OK) {
    int old_n=n;

    if (CheckOptionalArgument(n,hasER   ,ER  ,      ER_ARGUMENT_USED_TWICE)) {
      cmd->append(ippOnScanReportCommand::ER);
    }
    
    if(CheckOptionalArgument(n,hasIJK  ,_IJK ,     IJK_ARGUMENT_USED_TWICE)) {
      cmd->append(ippOnScanReportCommand::IJK);
    }
    
    if (CheckOptionalArgument(n,hasQ    ,Q   ,       Q_ARGUMENT_USED_TWICE)) {
      cmd->append(ippOnScanReportCommand::Q);
    }
    
    if (CheckOptionalArgument(n,hasR    ,_R   ,       R_ARGUMENT_USED_TWICE)) {
      cmd->append(ippOnScanReportCommand::R);
    }
    
    if (CheckOptionalArgument(n,hasX    ,_X   ,       X_ARGUMENT_USED_TWICE)) {
      cmd->append(ippOnScanReportCommand::X);
    }
    
    if (CheckOptionalArgument(n,hasY    ,_Y   ,       Y_ARGUMENT_USED_TWICE)) {
      cmd->append(ippOnScanReportCommand::Y);
    }
    
    if (CheckOptionalArgument(n,hasZ    ,_Z   ,       Z_ARGUMENT_USED_TWICE)) {
      cmd->append(ippOnScanReportCommand::Z);
    }
    
    if (CheckOptionalArgument(n,hasToolA,Tool,_A,TOOL_A_ARGUMENT_USED_TWICE)) {
      cmd->append(ippOnScanReportCommand::ToolA);
    }
    
    if (CheckOptionalArgument(n,hasToolB,Tool,_B,TOOL_B_ARGUMENT_USED_TWICE)) {
      cmd->append(ippOnScanReportCommand::ToolB);
    }
    
    if (CheckOptionalArgument(n,hasToolC,Tool,_C,TOOL_C_ARGUMENT_USED_TWICE)) {
      cmd->append(ippOnScanReportCommand::ToolC);
    }
    
    if(CheckOptionalArgument(n,hasIJKAct,_IJKAct,  IJKACT_ARGUMENT_USED_TWICE)) {
      cmd->append(ippOnScanReportCommand::IJKAct);
    }

    if (old_n == n) { 
      // the argument has not been recognized:
      _errorCode = BAD_ARGUMENTS;
    } 
  }
  return (_errorCode != OK) ? NULL :cmd;
}



bool ippCommandParser::CheckOptionalArgumentValue(
  int& n,
  bool& hasArgument,
  ippOtherKeyType type,
  ippParserCmdErrorId errorIfDuplicated,
  ippParserCmdErrorId errorIfNotFollowedByNumberInParens,
  double& value
  )
{
  if (_errorCode != OK) return false;
  if (_argCount < n+2)  return false;

  if (_argTypes[n] != ARGKEYWORD ) { 
    return false;
  }

  if (_argKeywords[n] != type) { 
    return false; // ignore ,not for us
  } else {
    if (hasArgument ) { 
      _errorCode = errorIfDuplicated;      
    } else {
      hasArgument = true;
      if (_argTypes[n+1] != ARGPARENDOUBLE) { 
        _errorCode = errorIfNotFollowedByNumberInParens;
        return false;
      }
      if ( n+2 < _argCount && _argTypes[n+2] != ARGCOMMA ) { 
        _errorCode = BAD_ARGUMENTS;
        return false;
      }
      value = getValue(n+1);
    }
    n +=3;
  }
  if (_errorCode == OK ) {
    return true;
  } 
  return false;
}

bool ippCommandParser::CheckOptionalArgumentValue(
  int& n,
  bool& hasArgument,
  ippOtherKeyType type1,
  ippOtherKeyType type2,
  ippParserCmdErrorId errorIfDuplicated,
  ippParserCmdErrorId errorIfNotFollowedByNumberInParens,
  double& value
  )
{
  if (_errorCode != OK) return false;
  if (_argCount < n+4)  return false;

  if (_argTypes[n] != ARGKEYWORD ) { 
    return false;
  }
  if (_argTypes[n+1] != ARGDOT ) { 
    return false;
  }
  if (_argTypes[n+2] != ARGKEYWORD ) { 
    return false;
  }

  if (_argKeywords[n] != type1 ||_argKeywords[n+2] != type2) { 
    return false; // ignore ,not for us
  } else {
    if (hasArgument ) { 
      _errorCode = errorIfDuplicated;      
    } else {
      hasArgument = true;
      if (_argTypes[n+3] != ARGPARENDOUBLE) { 
        _errorCode = errorIfNotFollowedByNumberInParens;
        return false;
      }
      if ( n+4 < _argCount && _argTypes[n+4] != ARGCOMMA ) { 
        _errorCode = BAD_ARGUMENTS;
        return false;
      }
      value = getValue(n+3);
    }
    n +=5;
  }
  if (_errorCode == OK ) {
    return true;
  } 
  return false;
}
bool ippCommandParser::CheckOptionalArgumentValue(
  int& n,
  bool& hasArgument,
  ippOtherKeyType type,
  ippParserCmdErrorId errorIfDuplicated,
  ippParserCmdErrorId errorIfNotFollowedByBooleanInParens,
  bool& value
  )
{
  if (_errorCode != OK) return false;
  if (_argCount < n+2)  return false;

  if (_argTypes[n] != ARGKEYWORD ) { 
    return false;
  }
  if (_argKeywords[n] != type ) { 
    return false; // ignore ,not for us
  } else {
    if (hasArgument ) { 
      _errorCode = errorIfDuplicated;      
    } else {
      hasArgument = true;
      if (_argTypes[n+1] != ARGPARENDOUBLE) { 
        _errorCode = errorIfNotFollowedByBooleanInParens;
        return false;
      }
      if ( n+2 < _argCount && _argTypes[n+2] != ARGCOMMA ) { 
        _errorCode = BAD_ARGUMENTS;
        return false;
      }
      if (getValue(n+1) != 0 && getValue(n+1) !=1 ){ 
        _errorCode =errorIfNotFollowedByBooleanInParens;
        return false;
      }
      value = (getValue(n+1) == 1.0)?true:false ;
    }
    n +=3;
  }
  if (_errorCode == OK ) {
    return true;
  } 
  return false;
}

bool ippCommandParser::CheckOptionalArgumentValue(
  int& n,
  bool& hasArgument,
  ippOtherKeyType type,
  ippParserCmdErrorId errorIfDuplicated,
  ippParserCmdErrorId errorIfNotFollowedByNumberInParens,
  double& valueI,
  double& valueJ,
  double& valueK
  )
{
  if (_errorCode != OK) return false;
  if (_argCount < n+3)  {
    return false;
  }

  if (_argTypes[n] != ARGKEYWORD ) { 
    return false;
  }

  if (_argKeywords[n] != type) { 
    return false; // ignore ,not for us
  } else {
    if (hasArgument ) { 
      _errorCode = errorIfDuplicated;      
    } else {
      hasArgument = true;
      if (_argTypes[n+1] != ARGIJK || _argTypes[n+2] != ARGIJK|| _argTypes[n+3] != ARGIJK) { 
        _errorCode = errorIfNotFollowedByNumberInParens;
        return false;
      }
      if ( n+4 < _argCount && _argTypes[n+4] != ARGCOMMA ) { 
        _errorCode = BAD_ARGUMENTS;
        return false;
      }
      valueI = getValue(n+1);
      valueJ = getValue(n+2);
      valueK = getValue(n+3);
    }
    n +=5;
  }
  if (_errorCode == OK ) {
    return true;
  } 
  return false;
}

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

/* ippCommandParser::makePtMeas

Returned Value: A PtMeasCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one, two, three, or four arguments.
   BAD_ARGUMENTS
2. Each argument must be one of X(<number>), Y(<number>), Z(<number>),
   or IJK(<number>,<number>,<number>), which may appear in any order.
   X_NOT_FOLLOWED_BY_NUMBER_IN_PARENS
   Y_NOT_FOLLOWED_BY_NUMBER_IN_PARENS
   Z_NOT_FOLLOWED_BY_NUMBER_IN_PARENS
   IJK_NOT_FOLLOWED_BY_ARGIJK
3. At least one of X(), Y(), or Z() must appear.
   X_Y_Z_ALL_MISSING
4. Each allowed argument must appear at most once.
   X_ARGUMENT_USED_TWICE
   Y_ARGUMENT_USED_TWICE
   Z_ARGUMENT_USED_TWICE
   IJK_ARGUMENT_USED_TWICE
5. Commas must separate the arguments if there are two or more.
   BAD_ARGUMENTS

Reference pages: 9 24 27 (41) (49) (52 - 53) (62) [71] [72] (78) 83 84 86
                 87 89 90 91 102

*/

ippCommandPtr ippCommandParser::makePtMeas()
{
  int n;
  bool hasX = false;
  bool hasY = false;
  bool hasZ = false;
  bool hasIJK = false;
  double x = 0.0;
  double y = 0.0;
  double z = 0.0;
  double i = 0.0;
  double j = 0.0;
  double k = 0.0;
 
  n = 0;
  while (n < _argCount && _errorCode == OK) {
    int old_n=n;
    CheckOptionalArgumentValue(n,hasX,_X,X_ARGUMENT_USED_TWICE,X_NOT_FOLLOWED_BY_NUMBER_IN_PARENS,x);
    CheckOptionalArgumentValue(n,hasY,_Y,Y_ARGUMENT_USED_TWICE,Y_NOT_FOLLOWED_BY_NUMBER_IN_PARENS,y);
    CheckOptionalArgumentValue(n,hasZ,_Z,Z_ARGUMENT_USED_TWICE,Z_NOT_FOLLOWED_BY_NUMBER_IN_PARENS,z);
    CheckOptionalArgumentValue(n,hasIJK,_IJK,IJK_ARGUMENT_USED_TWICE,IJK_NOT_FOLLOWED_BY_ARGIJK,i,j,k);
    if (old_n == n) {
      // the argument has not been recognized:
      _errorCode = BAD_ARGUMENTS;
    }
  }
  if ((_errorCode == OK)&&(hasX == false) && (hasY == false) && (hasZ == false)) {
    _errorCode = X_Y_Z_ALL_MISSING;
  }
  return ((_errorCode != OK) ? NULL:
    (new ippPtMeasCommand(_tag, hasX, hasY, hasZ, hasIJK, x, y, z,i,j,k)));
}

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

/* ippCommandParser::makeReQualify

Returned Value: A ippCommand of commandNameType ReQualify as described by
  the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 29 (64) 106 107
[This is called Qualify on pages 29 106 107]

*/

ippCommandPtr ippCommandParser::makeReQualify()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, ReQualify)));
}

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

/* ippCommandParser::makeScanInCylEndIsPlane

Returned Value: A ScanInCylEndIsPlaneCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be 26 arguments.
   BAD_ARGUMENTS
2. All of the arguments must be numbers.
   BAD_ARGUMENTS
3. The number of throughs must be a positive integer.
   NUMBER_THROUGH_MUST_BE_POSITIVE
   NUMBER_THROUGH_MUST_BE_INTEGER
4. StepW must be positive.
   STEPW_MUST_BE_POSITIVE
5. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 27 (90 - 91) 103

*/

ippCommandPtr ippCommandParser::makeScanInCylEndIsPlane()
{
  int n;
  
  if (_argCount != 51) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  } 
  //                                      1                   2
  //                    1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 
  if (!match(_argTypes,"#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }

  if (getValue(30) <= 0) {
    _errorCode = STEPW_MUST_BE_POSITIVE;
    return 0;
  }
  if (getValue(44) <= 0) {
    _errorCode = NUMBER_THROUGH_MUST_BE_POSITIVE;
    return 0;
  }
 
  if (!IsInteger(getValue(44))) {
    _errorCode = NUMBER_THROUGH_MUST_BE_INTEGER;
    return 0;
  }

  for (n = 0; ((n < 25) && (_errorCode == OK)); n++) {
    if ((_argTypes[2*n] != ARGDOUBLE) || (_argTypes[(2*n)+1] != ARGCOMMA)) {
       _errorCode = BAD_ARGUMENTS;
       return 0;
    } 
  }
  return ((_errorCode != OK) ? NULL:
    (new ippScanInCylEndIsPlaneCommand
     (_tag,
      getValue(0),  getValue(2),  getValue(4),  getValue(6),
      getValue(8),  getValue(10), getValue(12), getValue(14),
      getValue(16), getValue(18), getValue(20), getValue(22),
      getValue(24), getValue(26), getValue(28), getValue(30),
      getValue(32), getValue(34), getValue(36), getValue(38),
      getValue(40), getValue(42), AsInteger(getValue(44)),
      getValue(46), getValue(48), getValue(50))));
}

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

/* ippCommandParser::makeScanInCylEndIsSphere

Returned Value: A ScanInCylEndIsSphereCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be 23 arguments.
   BAD_ARGUMENTS
2. All of the arguments must be numbers.
   BAD_ARGUMENTS
3. The diameter of the sphere must be positive.
   DIAMETER_MUST_BE_POSITIVE
4. StepW must be positive.
   STEPW_MUST_BE_POSITIVE
5. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 27 (89 - 90) 103

*/

ippCommandPtr ippCommandParser::makeScanInCylEndIsSphere()
{  
  if (_argCount != 47) {
    _errorCode = BAD_ARGUMENTS;
  }
  //                                      1                   2
  //                    1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
  if (!match(_argTypes,"#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }

  if (getValue(30) <= 0) { 
    _errorCode = STEPW_MUST_BE_POSITIVE;
    return 0;
  } 
  if (getValue(38) <= 0) {
    _errorCode = DIAMETER_MUST_BE_POSITIVE;
    return 0;
  }
  if (getValue(40) <= 0)
    _errorCode = NUMBER_THROUGH_MUST_BE_POSITIVE;
  else if ( !IsInteger(getValue(40)))
    _errorCode = NUMBER_THROUGH_MUST_BE_INTEGER;

  return ((_errorCode != OK) ? NULL:
    (new ippScanInCylEndIsSphereCommand
     (_tag,
      getValue(0),  getValue(2),  getValue(4), 
      getValue(6),  getValue(8),  getValue(10), 
      getValue(12), getValue(14),  getValue(16), 
      getValue(18), getValue(20), getValue(22),
      getValue(24), getValue(26), getValue(28),
      getValue(30), // StepW
      getValue(32), getValue(34), getValue(36),
      getValue(38), // Dia
      int(getValue(40)), // n
      getValue(42), getValue(44), getValue(46))));
}

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

/* ippCommandParser::makeScanInPlaneEndIsCyl

Returned Value: A ScanInPlaneEndIsCylCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be 21 arguments.
   BAD_ARGUMENTS
2. All of the arguments must be numbers.
   BAD_ARGUMENTS
3. The number of throughs must be a positive integer.
   NUMBER_THROUGH_MUST_BE_POSITIVE
   NUMBER_THROUGH_MUST_BE_INTEGER
4. StepW must be positive.
   STEPW_MUST_BE_POSITIVE
5. The diameter of the cylinder must be positive.
   DIAMETER_MUST_BE_POSITIVE
6. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 27 (88 - 89) 103

*/

ippCommandPtr ippCommandParser::makeScanInPlaneEndIsCyl()
{
  
  if (_argCount != 47) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  //                                      1                   2
  //                    1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4
  if (!match(_argTypes,"#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  
  if (getValue(24) <= 0)
    _errorCode = STEPW_MUST_BE_POSITIVE;
  else if (getValue(38) <= 0)
    _errorCode = DIAMETER_MUST_BE_POSITIVE;
  else if (getValue(40) <= 0)
    _errorCode = NUMBER_THROUGH_MUST_BE_POSITIVE;
  else if ( !IsInteger(getValue(40)))
    _errorCode = NUMBER_THROUGH_MUST_BE_INTEGER;


  return ((_errorCode != OK) ? NULL:
    (new ippScanInPlaneEndIsCylCommand
     (_tag,
      getValue(0),  getValue(2),  getValue(4), 
      getValue(6),  getValue(8),  getValue(10),
      getValue(12), getValue(14), getValue(16), 
      getValue(18), getValue(20), getValue(22),
      getValue(24), // StepW
      getValue(26), getValue(28), getValue(30),
      getValue(32), getValue(34), getValue(36),
      getValue(38), // dia
      int(getValue(40)), // n
      getValue(42), getValue(44), getValue(46)
      )));
}

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

/* ippCommandParser::makeScanInPlaneEndIsPlane

Returned Value: A ScanInPlaneEndIsPlaneCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be 20 arguments.
   BAD_ARGUMENTS
2. All of the arguments must be numbers.
   BAD_ARGUMENTS
3. The number of throughs must be a positive integer.
   NUMBER_THROUGH_MUST_BE_POSITIVE
   NUMBER_THROUGH_MUST_BE_INTEGER
4. StepW must be positive.
   STEPW_MUST_BE_POSITIVE
5. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 27 (86 - 87) 103

*/ 

ippCommandPtr ippCommandParser::makeScanInPlaneEndIsPlane()
{
  if (_argCount != 45) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  //                                      1                   2
  //                    1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
  if (!match(_argTypes,"#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  
  if (getValue(24) <= 0)
    _errorCode = STEPW_MUST_BE_POSITIVE;
  else if (getValue(38) <= 0)
    _errorCode = NUMBER_THROUGH_MUST_BE_POSITIVE;
  else if (!IsInteger(getValue(38)) != 0)
    _errorCode = NUMBER_THROUGH_MUST_BE_INTEGER;

  return ((_errorCode != OK) ? NULL:
    (new ippScanInPlaneEndIsPlaneCommand
     (_tag,
      getValue(0),  getValue(2),  getValue(4),
      getValue(6),  getValue(8),  getValue(10), 
      getValue(12), getValue(14), getValue(16),
      getValue(18), getValue(20), getValue(22),
      getValue(24), // StepW
      getValue(26), getValue(28), getValue(30),
      getValue(32), getValue(34), getValue(36),
      int(getValue(38)), //n
      getValue(40), getValue(42), getValue(44)
      )));
}

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

/* ippCommandParser::makeScanInPlaneEndIsSphere

Returned Value: A ScanInPlaneEndIsSphereCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be 17 arguments.
   BAD_ARGUMENTS
2. All of the arguments must be numbers.
   BAD_ARGUMENTS
3. StepW must be positive.
   STEPW_MUST_BE_POSITIVE
4. The diameter of the sphere must be positive.
   DIAMETER_MUST_BE_POSITIVE
5. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 27 (85 - 86) [94] 103

*/

ippCommandPtr ippCommandParser::makeScanInPlaneEndIsSphere()
{
  
  if (_argCount != 41) {
    _errorCode = BAD_ARGUMENTS;
  }
  //                                      1                   2                   3
  //                    1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0  
  if (!match(_argTypes,"#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }

   if (getValue(24) <= 0)
    _errorCode = STEPW_MUST_BE_POSITIVE;
  else if (getValue(32) <= 0)
    _errorCode = DIAMETER_MUST_BE_POSITIVE;
  else if (!IsInteger(getValue(34)) != 0)
    _errorCode = NUMBER_THROUGH_MUST_BE_INTEGER;

  return ((_errorCode != OK) ? NULL:
    (new ippScanInPlaneEndIsSphereCommand
     (_tag,
      getValue(0),  getValue(2),  getValue(4), 
      getValue(6),  getValue(8),  getValue(10),
      getValue(12), getValue(14), getValue(16),
      getValue(18), getValue(20), getValue(22),
      getValue(24), // stepW
      getValue(26), getValue(28), getValue(30),
      getValue(32), // diameter
      int(getValue(34)), // n
      getValue(36),getValue(38),getValue(40)
     )));
}

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

/* ippCommandParser::makeScanOnCircle

Returned Value: A ScanOnCircleCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be 12 arguments.
   BAD_ARGUMENTS
2. All of the arguments must be numbers.
   BAD_ARGUMENTS
3. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 27 (82 - 83) [93] 103

It would be good to add a rule requiring StepW to have the same sign as
delta.

*/

ippCommandPtr ippCommandParser::makeScanOnCircle()
{
  
  if (_argCount != 23) {
    _errorCode = BAD_ARGUMENTS;
  }
  //                                      1                   2
  //                    1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 
  if (!match(_argTypes,"#,#,#,#,#,#,#,#,#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }

  return ((_errorCode != OK) ? NULL:
    (new ippScanOnCircleCommand
     (_tag,
      getValue(0),  getValue(2),  getValue(4),  getValue(6),
      getValue(8),  getValue(10), getValue(12), getValue(14),
      getValue(16), getValue(18), getValue(20), getValue(22))));
}

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

/* ippCommandParser::makeScanOnCircleHint

Returned Value: A ScanOnCircleHintCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be two arguments.
   BAD_ARGUMENTS
2. Both arguments must be non-negative numbers.
   BAD_ARGUMENTS
3. A comma must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 27 (82) [93] 103

*/

ippCommandPtr ippCommandParser::makeScanOnCircleHint()
{

  if ((_argCount != 3) || !match(_argTypes,"#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }

  if (getValue(0) < 0 || getValue(2) < 0) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }

  return ((_errorCode != OK) ? NULL:
    (new ippScanOnCircleHintCommand(_tag, getValue(0), getValue(2))));
}

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

/* ippCommandParser::makeScanOnLine

Returned Value: A ScanOnLineCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be 10 arguments.
   BAD_ARGUMENTS
2. All of the arguments must be numbers.
   BAD_ARGUMENTS
3. StepW must be positive.
   STEPW_MUST_BE_POSITIVE
4. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 27 (83 - 84) 103

*/

ippCommandPtr ippCommandParser::makeScanOnLine()
{

  if (_argCount != 19) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  
  //                                      1                   2
  //                    1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 
  if (!match(_argTypes,"#,#,#,#,#,#,#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }

  if (getValue(18) <= 0) {
    _errorCode = STEPW_MUST_BE_POSITIVE;
  }

  return ((_errorCode != OK) ? NULL:
    (new ippScanOnLineCommand
     (_tag,
      getValue(0),  getValue(2),  getValue(4),  getValue(6),
      getValue(8),  getValue(10), getValue(12), getValue(14),
      getValue(16), getValue(18))));
}

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

/* ippCommandParser::makeScanOnLineHint

Returned Value: A ScanOnLineHintCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be two arguments separated by a comma, and both arguments
   must be non-negative numbers.
   BAD_ARGUMENTS

Reference pages: 24 27 (83) 103

*/

ippCommandPtr ippCommandParser::makeScanOnLineHint()
{
  if ((_argCount != 3) || !match(_argTypes,"#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }

  if (getValue(0) < 0 || getValue(2) < 0) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  return ((_errorCode != OK) ? NULL:
    (new ippScanOnLineHintCommand(_tag, getValue(0), getValue(2))));
}

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

/* ippCommandParser::makeScanUnknownHint

Returned Value: A ScanUnknownHintCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one argument.
   MUST_HAVE_ONE_ARGUMENT
2. The argument must be a number.
   ARGUMENT_MUST_BE_A_NUMBER
3. The number must be positive.
   ARGUMENT_MUST_BE_POSITIVE

Reference pages: 24 27 (85) [93] 103

*/

ippCommandPtr ippCommandParser::makeScanUnknownHint()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if (_argTypes[0] != ARGDOUBLE)
    _errorCode = ARGUMENT_MUST_BE_A_NUMBER;
  else if (getValue(0) <= 0)
    _errorCode = ARGUMENT_MUST_BE_POSITIVE;
  return ((_errorCode != OK) ? NULL:
    (new ippScanUnknownHintCommand(_tag, getValue(0))));
}

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

/* ippCommandParser::makeSetCoordSystem

Returned Value: A SetCoordSystemCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one argument.
   MUST_HAVE_ONE_ARGUMENT
2. The argument must be one of:
   MachineCsy, MultipleArmCsy, PartCsy, or MoveableMachineCsy.
   BAD_ARGUMENTS

Reference pages: 24 28 58 (59) (67) [71] [72] 103

These rules are as given in the spec. Note that JogDisplayCsy, JogMoveCsy,
and SensorCsy are not included. It is not clear whether omitting these
is intentional or inadvertent.

*/

ippCommandPtr ippCommandParser::makeSetCoordSystem()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if ((_argTypes[0] != ARGKEYWORD) ||
     ((_argKeywords[0] != MachineCsy) &&
      (_argKeywords[0] != MultipleArmCsy) &&
      (_argKeywords[0] != PartCsy) &&
      (_argKeywords[0] != MoveableMachineCsy)))
    _errorCode = BAD_ARGUMENTS;
  return ((_errorCode != OK) ? NULL :
    (new ippSetCoordSystemCommand(_tag, (ippCoordSysType)_argKeywords[0])));
}

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

/* ippCommandParser::makeSetCsyTransformation

Returned Value: A SetCsyTransformationCommand as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be seven arguments.
   MUST_HAVE_7_ARGUMENTS
2. The first argument must be JogDisplayCsy, JogMoveCsy, MoveableMachineCsy,
   MultipleArmCsy, PartCsy, or SensorCsy.
   BAD_FIRST_ARGUMENT
3. All the other arguments must be numbers.
   BAD_ARGUMENTS
4. Theta, the fourth numeric argument, must be in the range 0 to 180.
   THETA_OUT_OF_RANGE
5. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 28 59 (60) 67 [71] [72] (80) 103

*/

ippCommandPtr ippCommandParser::makeSetCsyTransformation()
{
  if (_argCount != 13) {
    _errorCode = MUST_HAVE_7_ARGUMENTS;
    return 0;
  } 

  if (!match(_argTypes,"k,#,#,#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }

  ippCoordSysType type = (ippCoordSysType)_argKeywords[0]; 
  if (( type!= JogDisplayCsy) &&
     (type != JogMoveCsy) &&
     (type != MoveableMachineCsy) &&
     (type != MultipleArmCsy) &&
     (type != PartCsy) &&
     (type != SensorCsy)) {
    _errorCode = BAD_FIRST_ARGUMENT;
  }
  
  if ((getValue(8) < 0) || (getValue(8) > 180)) {
    _errorCode = THETA_OUT_OF_RANGE;
  }

  return ((_errorCode != OK) ? NULL :
    (new ippSetCsyTransformationCommand(_tag, type,
             getValue(2),  getValue(4),
             getValue(6),  getValue(8),
             getValue(10), getValue(12))));
}

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

/* ippCommandParser::makeSetProp

Returned Value: A SetPropCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be at least one argument, and each argument must have one of
   the two patterns:
   key1.key2.key3(val) -- six components in _argCount
   key1.key2.key3.key4(val) -- eight components in _argCount
   and all arguments except the last must be followed by a comma.
   BAD_ARGUMENTS
2. key1 must be FoundTool or Tool or part
   ARGUMENT_FIRST_PART_MUST_BE_TOOL_OR_FOUNDTOOL
3. key2 must be GoToPar or PtMeasPar.
   ARGUMENT_SECOND_PART_MUST_BE_GOTOPAR_OR_PTMEASPAR
4. If key2 is GoToPar, key3 must be either Speed or Accel. If key2 is
   PtMeasPar, key3 must be one of Speed, Accel, Approach, Retract, or Search.
   ARGUMENT_THIRD_PART_BAD
5. If there is a key4, it must be Actual.
   ARGUMENT_FOURTH_PART_MUST_BE_ACT
6. The dots must be placed where shown in rule 1.
   BAD_DOTS
7. The number in parentheses must be placed where shown in rule 1.
   ARGUMENT_MUST_END_WITH_NUMBER_IN_PARENTHESES

Reference pages: 24 26 29 (45) 65 [73] 77 (78) 99 108
Also see the reference pages for GetProp, since several of those imply
that certain properties cannot be set directly.

The spec is not explicit about what is allowed to be set using SetProp
and what is not. For the most part, we believe this function does what
the spec intends. For PtMeasPars, the spec (page 65) states that only the
Act value can be set by the client, so here, key4 must be ACT if it is
used. The spec does not explicitly rule out setting DEF for GoToPars, but
it appears by implication not to be allowed, so it is not allowed here.

The [(_argCount + 1) / 7] size for the keys arrays and the values array
is used because this is the smallest number that is sure to be at
least as large as the number of arguments. Each argument must have at
least six components, and the arguments are separated by commas (which
are added into _argCount).

*/
ippCommandPtr ippCommandParser::makeSetProp()
{
  ippSetPropCommandPtr command = new ippSetPropCommand(_tag);
  for (int n = 0; ((n < _argCount) && (_errorCode == OK));n++)  {
  
    ippOtherKeyType key1 = ippOtherKeyType_INVALID;
    ippOtherKeyType key2 = EmptyKey;
    ippOtherKeyType key3 = EmptyKey;
    ippOtherKeyType key4 = EmptyKey;
    double value = 0;
    if (match(_argTypes,"k.k.k.kD",n))  {
      key1 = _argKeywords[n];
      key2 = _argKeywords[n+2];
      key3 = _argKeywords[n+4];
      key4 = _argKeywords[n+6];
      value = getValue(n+7);
      n += 8;

    } else if (match(_argTypes,"k.k.kD",n)) { 
      key1 = _argKeywords[n];
      key2 = _argKeywords[n+2];
      key3 = _argKeywords[n+4];
      value = getValue(n+5);
      n += 6;
    } else if (match(_argTypes,"k.kD",n)) { 
      key1 = _argKeywords[n];
      key2 = _argKeywords[n+2];
      value = getValue(n+3);
      n += 4;
    } else if (match(_argTypes,"kD",n)) { 
      key1 = _argKeywords[n];
      value = getValue(n+1);
      n += 2;
    } else {
      _errorCode = BAD_ARGUMENTS;
    }
    if (n < _argCount && _argTypes[n] != ARGCOMMA) {
      _errorCode = BAD_ARGUMENTS;
    }
    if(_errorCode == OK ) { 
      ippProp prop(key1,key2,key3,key4);
      if (PropertyIsAllowedAndWritable(prop)) { 
        command->addPropValue(prop,value);
      } else {
       _errorCode = BAD_ARGUMENTS;
     }
    }
  }
  if (_errorCode != OK) {
    return 0;
  }
  return command;

}



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

/* ippCommandParser::makeSetTool

Returned Value: A SetToolCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one argument.
   MUST_HAVE_ONE_ARGUMENT
2. The argument must be a string.
   ARGUMENT_MUST_BE_STRING

Reference pages: 24 27 29 (54 - 55) 102 106

*/

ippCommandPtr ippCommandParser::makeSetTool()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if (_argTypes[0] != ARGSTRING)
    _errorCode = ARGUMENT_MUST_BE_STRING;
  return((_errorCode != OK) ? NULL: (new ippSetToolCommand(_tag, _argStrings[0].c_str())));
}

/*******************************************************************/
/* ippCommandParser::makeStartSession
Returned Value: A ippCommand of commandNameType StartSession as described by
  the command text, or NULL.
Called By: ippCommandParser::makeCommand
Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS
Reference pages: 18 20 24 26 (38) (41) 49 [71] (77) 81 99
*/

ippCommandPtr ippCommandParser::makeStartSession()
{
  if (_argCount != 0) {
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  }
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, StartSession)));
}

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

/* ippCommandParser::makeStopAllDaemons

Returned Value: A ippCommand of commandNameType StopAllDaemons as described by
  the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be no arguments.
   MUST_HAVE_NO_ARGUMENTS

Reference pages: 24 26 (42) (50) 99

*/

ippCommandPtr ippCommandParser::makeStopAllDaemons()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL : (new ippCommand(_tag, StopAllDaemons)));
}

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

/* ippCommandParser::makeStopDaemon

Returned Value: A StopDaemonCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be one argument.
   MUST_HAVE_ONE_ARGUMENT
2. The argument must be an event _tag.
   ARGUMENT_MUST_BE_EVENT_TAG

Reference pages: 19 (22) 24 26 [40] (42) (50) 99

*/

ippCommandPtr ippCommandParser::makeStopDaemon()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if (_argTypes[0] != ARGETAG)
    _errorCode = ARGUMENT_MUST_BE_EVENT_TAG;
  return((_errorCode != OK) ? NULL: (new ippStopDaemonCommand(_tag, _argInt)));
}

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

/* ippCommandParser::makeTiltCenterPart

Returned Value: A TiltCenterPartCommand as described by the command text,
                or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be 7 arguments.
   MUST_HAVE_7_ARGUMENTS
2. The arguments must all be numbers.
   BAD_ARGUMENTS
3. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 27 (97) 102

*/

ippCommandPtr ippCommandParser::makeTiltCenterPart()
{
  if (_argCount != 13) {
    _errorCode = MUST_HAVE_7_ARGUMENTS;
  }
  
  if (!match(_argTypes,"#,#,#,#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
  }

  return ((_errorCode != OK) ? NULL:
    new ippTiltCenterPartCommand(_tag, getValue(0), getValue(2),
            getValue(4), getValue(6),
            getValue(8), getValue(10),
            getValue(12)));
}

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

/* ippCommandParser::makeTiltPart

Returned Value: A TiltPartCommand as described by the command text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be 4 arguments.
   MUST_HAVE_4_ARGUMENTS
2. The arguments must all be numbers.
   BAD_ARGUMENTS
3. Commas must separate the arguments.
   BAD_ARGUMENTS

Reference pages: 24 27 (97) 102

*/

ippCommandPtr ippCommandParser::makeTiltPart()
{
  if (_argCount != 7) {
    _errorCode = MUST_HAVE_4_ARGUMENTS;
  } else if (!match(_argTypes,"#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
  }

  return ((_errorCode != OK) ? NULL:
    new ippTiltPartCommand(_tag, getValue(0), getValue(2),
        getValue(4), getValue(6)));
}



ippCommandPtr ippCommandParser::makeEnumToolCollection()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if (_argTypes[0] != ARGSTRING)
    _errorCode = ARGUMENT_MUST_BE_STRING;
  return ((_errorCode != OK) ? NULL :
    (new ippEnumToolCollectionCommand(_tag, _argStrings[0].c_str())));
}

ippCommandPtr ippCommandParser::makeEnumAllToolCollections()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if (_argTypes[0] != ARGSTRING)
    _errorCode = ARGUMENT_MUST_BE_STRING;
  return ((_errorCode != OK) ? NULL :
    (new ippEnumAllToolCollectionsCommand(_tag, _argStrings[0].c_str())));
}

ippCommandPtr ippCommandParser::makeOpenToolCollection()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if (_argTypes[0] != ARGSTRING)
    _errorCode = ARGUMENT_MUST_BE_STRING;
  return ((_errorCode != OK) ? NULL :
    (new ippOpenToolCollectionCommand(_tag, _argStrings[0].c_str())));
}


ippCommandPtr ippCommandParser::makeSaveActiveCoordSystem()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if (_argTypes[0] != ARGSTRING)
    _errorCode = ARGUMENT_MUST_BE_STRING;
  return ((_errorCode != OK) ? NULL :
    (new ippSaveActiveCoordSystemCommand(_tag, _argStrings[0].c_str())));
}

ippCommandPtr ippCommandParser::makeLoadCoordSystem()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if (_argTypes[0] != ARGSTRING)
    _errorCode = ARGUMENT_MUST_BE_STRING;
  return ((_errorCode != OK) ? NULL :
    (new ippLoadCoordSystemCommand(_tag, _argStrings[0].c_str())));
}

ippCommandPtr ippCommandParser::makeDeleteCoordSystem()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if (_argTypes[0] != ARGSTRING)
    _errorCode = ARGUMENT_MUST_BE_STRING;
  return ((_errorCode != OK) ? NULL :
    (new ippDeleteCoordSystemCommand(_tag, _argStrings[0].c_str())));
}

ippCommandPtr ippCommandParser::makeEnumCoordSystems()
{
  if (_argCount != 0)
    _errorCode = MUST_HAVE_NO_ARGUMENTS;
  return ((_errorCode != OK) ? NULL :
    (new ippEnumCoordSystemsCommand(_tag)));
}

ippCommandPtr ippCommandParser::makeGetNamedCsyTransformation()
{
  if (_argCount != 1)
    _errorCode = MUST_HAVE_ONE_ARGUMENT;
  else if (_argTypes[0] != ARGSTRING)
    _errorCode = ARGUMENT_MUST_BE_STRING;
  return ((_errorCode != OK) ? NULL :
    (new ippGetNamedCsyTransformationCommand(_tag, _argStrings[0].c_str())));
  return 0;
}

ippCommandPtr ippCommandParser::makeSaveNamedCsyTransformation()
{
  double x0=0;
  double y0=0;
  double z0=0;
  double theta=0;
  double phi=0;
  double psi=0;

  if (_argCount != 13) {
    _errorCode = MUST_HAVE_7_ARGUMENTS;
    return 0;
  } 
  if (!match(_argTypes,"s,#,#,#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  x0 = getValue(2);
  y0 = getValue(4);
  z0 = getValue(6);
  theta = getValue(8);
  phi = getValue(10);
  psi = getValue(12);
  return ((_errorCode != OK) ? NULL :
    (new ippSaveNamedCsyTransformationCommand(_tag,
      _argStrings[0].c_str(),x0,y0,z0,theta,phi,psi)));
  return 0;
}

/*
Returned Value: A ScanOnCurveHint as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:
1. There must be two argument.
   BAD_ARGUMENTS
2. The argument must be a number.
   BAD_ARGUMENTS
3. The number must be positive.
   DENSITY_MUST_BE_POSITIVE
   MINIMUM_RADIUS_OF_CURVATURE_MUST_BE_POSITIVE

*/ippCommandPtr ippCommandParser::makeScanOnCurveHint()
{
  if (!match(_argTypes,"#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  double density = getValue(0);
  double minRadiusOfCurvature = getValue(2);
  if ( density <=0 ) { 
    _errorCode = DENSITY_MUST_BE_POSITIVE;
  }
  if (minRadiusOfCurvature<=0){ 
    _errorCode = MINIMUM_RADIUS_OF_CURVATURE_MUST_BE_POSITIVE;
  }
  return ((_errorCode != OK) ? NULL :
    (new ippScanOnCurveHintCommand(_tag,density,minRadiusOfCurvature)));
}

/*
Returned Value: ScanOnCurveDensity as described by the command
  text, or NULL.

Called By: ippCommandParser::makeCommand

Rules:

*/
ippCommandPtr ippCommandParser::makeScanOnCurveDensity()
{
  bool hasDis = false;
  bool hasAngle = false;
  bool hasAtNominals = false;
  double dis =0.1;
  double angle = 0.0;
  bool atNominals = false;
  int n = 0;
  while (n < _argCount && _errorCode == OK) {
    int old_n=n;
    CheckOptionalArgumentValue(n,hasDis,Dis,DIS_ARGUMENT_USED_TWICE,DIS_MUST_BE_FOLLOWED_BY_NUMBER_IN_PARENS,dis);
    CheckOptionalArgumentValue(n,hasAngle,Angle,ANGLE_ARGUMENT_USED_TWICE,ANGLE_MUST_BE_FOLLOWED_BY_NUMBER_IN_PARENS,angle);
    CheckOptionalArgumentValue(n,hasAtNominals,AtNominals,ATNOMINALS_ARGUMENT_USED_TWICE,Z_NOT_FOLLOWED_BY_NUMBER_IN_PARENS,atNominals);
    if (old_n == n) {
      // the argument has not been recognized:
      _errorCode = BAD_ARGUMENTS;
    }
  } 
  if ((_errorCode == OK)&&(hasDis == false) && (hasAngle == false) && (hasAtNominals == false)) {
    _errorCode = BAD_ARGUMENTS;
  }
  return ((_errorCode != OK) ? NULL:
    (new ippScanOnCurveDensityCommand(_tag, dis, hasAngle, angle,atNominals)));
}
ippCommandPtr ippCommandParser::makeScanUnknownDensity()
{
  bool hasDis = false;
  bool hasAngle = false;
  bool hasAtNominals = false;
  double dis =0.1;
  double angle = 0.0;
  int n = 0;
  while (n < _argCount && _errorCode == OK) {
    int old_n=n;
    CheckOptionalArgumentValue(n,hasDis,Dis,DIS_ARGUMENT_USED_TWICE,DIS_MUST_BE_FOLLOWED_BY_NUMBER_IN_PARENS,dis);
    CheckOptionalArgumentValue(n,hasAngle,Angle,ANGLE_ARGUMENT_USED_TWICE,ANGLE_MUST_BE_FOLLOWED_BY_NUMBER_IN_PARENS,angle);
    if (old_n == n) {
      // the argument has not been recognized:
      _errorCode = BAD_ARGUMENTS;
    }
  } 
  if ((_errorCode == OK)&&(hasDis == false) && (hasAngle == false) && (hasAtNominals == false)) {
    _errorCode = BAD_ARGUMENTS;
  }
  return ((_errorCode != OK) ? NULL:
    (new ippScanUnknownDensityCommand(_tag, dis, hasAngle, angle)));
}


ippCommandPtr ippCommandParser::makeScanOnCurve()
{

  int n1 = _argDoubles.size();
  int n2 = _argTypes.size();
  int n3 = _argKeywords.size();
  int n4 = _argStrings.size();

  IPP_ASSERT(_argDoubles.size()  >=_argCount);
  IPP_ASSERT(_argTypes.size()    >=_argCount);
  IPP_ASSERT(_argKeywords.size() >=_argCount);

  //ScanOnCurve(Closed(1|0), Format(X(),Y(),Z(),IJK(),tag[,pi,pj,pk[,si,sj,sk]]),
  //    Data(P1x,P1y,P1z,i1,j1,k1,tag1[,pi1,pj1,pk1[,si1,sj1,sk1]]
  //
  //  ,Pnx,Pny,Pnz,in,jn,jn,tagn[,pin,pjn,pkn[,sin,sjn,skn]]))

  bool bClose = false;

  if (!match(_argTypes,"kD,kD,k")) {    
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  if ( _argKeywords[0] != Closed ) { 
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  if (!IsBoolean(getValue(1))) { 
    _errorCode = BAD_ARGUMENTS; // must be 0 or 1
    return 0;
  }
  bClose = AsBoolean(getValue(1));
  if ( _argKeywords[3] != Format ) { 
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  if ( _argKeywords[6] != Data ) { 
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  ippScanOnCurveCommand::FormatType type = ippScanOnCurveCommand::FormatType((int)getValue(4));
  int nb_per_point = 0;
  switch(type) {
    case ippScanOnCurveCommand::Type1: nb_per_point = 7;  break;
    case ippScanOnCurveCommand::Type2: nb_per_point = 10; break;
    case ippScanOnCurveCommand::Type3: nb_per_point = 13; break;
    default: IPP_ASSERT(0);
  }
  int n=7;
  int count = 0;
  ippScanOnCurveCommandPtr command = new ippScanOnCurveCommand(_tag,bClose,type);
  while (_argTypes[n] == ARGIJK && n<_argCount) {
    count++; n++;
  }
  if  ( ( count % nb_per_point ) != 0 )  { 
    // invalid number of data;
    _errorCode = BAD_NUMBER_OF_ARGUMENT_FOR_DATA_IN_SCANONCURVE;
    return 0;
  }

  n = count/nb_per_point;
  int k=7;
  for (int i=0;i<n;i++) {
    if (!IsInteger(getValue(k+6)))  {
      _errorCode = ARGUMENT_MUST_BE_INTEGER;
    }
    switch(type) {
    case ippScanOnCurveCommand::Type1: 
      command->addPoint(getValue(k),getValue(k+1),getValue(k+2),
                        getValue(k+3),getValue(k+4),getValue(k+5),AsInteger(getValue(k+6))
                        );
      break;
    case ippScanOnCurveCommand::Type2: 
      command->addPoint(getValue(k),getValue(k+1),getValue(k+2),
                        getValue(k+3),getValue(k+4),getValue(k+5),AsInteger(getValue(k+6)),
                        getValue(k+7),getValue(k+8),getValue(k+9)
                        );
      break;
    case ippScanOnCurveCommand::Type3: 
      command->addPoint(getValue(k),getValue(k+1),getValue(k+2),
                        getValue(k+3),getValue(k+4),getValue(k+5),AsInteger(getValue(k+6)),
                        getValue(k+7),getValue(k+8),getValue(k+9),
                        getValue(k+10),getValue(k+11),getValue(k+12)
                        );
      break;
    }
    k+=nb_per_point;
  }

  return (_errorCode == OK) ? command : NULL;
}

ippCommandPtr ippCommandParser::makeScanOnHelix()
{
  if (_argCount != 25) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }
  
  //                                      1                   2
  //                    1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 
  if (!match(_argTypes,"#,#,#,#,#,#,#,#,#,#,#,#,#")) {
    _errorCode = BAD_ARGUMENTS;
    return 0;
  }

  if (getValue(22) <= 0) {
    _errorCode = STEPW_MUST_BE_POSITIVE;
  }

  return ((_errorCode != OK) ? NULL:
    (new ippScanOnHelixCommand
     (_tag,
      getValue(0),  getValue(2),  getValue(4),  getValue(6),
      getValue(8),  getValue(10), getValue(12), getValue(14),
      getValue(16), getValue(18), getValue(20), getValue(22),
      getValue(24) )));
}

ippCommandPtr ippCommandParser::makePtMeasSelfCenter()
{
  bool hasX = false;
  bool hasY = false;
  bool hasZ = false;
  bool hasIJK = false;
  double x = 0;
  double y = 0;
  double z = 0;
  double i = 0;
  double j = 0;
  double k = 0;

  int n=0;
  while (n < _argCount && _errorCode == OK) {
    int old_n=n;
    CheckOptionalArgumentValue(n,hasX    ,_X   ,       X_ARGUMENT_USED_TWICE, X_NOT_FOLLOWED_BY_NUMBER_IN_PARENS, x);
    CheckOptionalArgumentValue(n,hasY    ,_Y   ,       Y_ARGUMENT_USED_TWICE, Y_NOT_FOLLOWED_BY_NUMBER_IN_PARENS, y);
    CheckOptionalArgumentValue(n,hasZ    ,_Z   ,       Z_ARGUMENT_USED_TWICE, Z_NOT_FOLLOWED_BY_NUMBER_IN_PARENS, z);
    CheckOptionalArgumentValue(n,hasIJK  ,_IJK  ,     IJK_ARGUMENT_USED_TWICE,IJK_NOT_FOLLOWED_BY_ARGIJK, i,j,k);
    if (old_n == n) { 
      // the argument has not been recognized:
      _errorCode = BAD_ARGUMENTS;
    } 
  }
  if (!hasX || !hasY || !hasZ || !hasIJK ) {
    // all part of the required enumeration must have been found
    _errorCode = BAD_ARGUMENTS;
  }
  return (_errorCode != OK) ? NULL:
    new ippPtMeasSelfCenterCommand(_tag, x, y, z,   ippTargetVector(i,j,k) );
}

ippCommandPtr ippCommandParser::makePtMeasSelfCenterLocked()
{
  bool hasX = false;
  bool hasY = false;
  bool hasZ = false;
  bool hasIJK = false;
  bool hasLMN = false;
  double x = 0;
  double y = 0;
  double z = 0;
  double i1 = 0;
  double j1 = 0;
  double k1 = 0;
  double i2 = 0;
  double j2 = 0;
  double k2 = 0;

  int n=0;
  while (n < _argCount && _errorCode == OK) {
    int old_n=n;
    CheckOptionalArgumentValue(n,hasX    ,_X   ,       X_ARGUMENT_USED_TWICE, X_NOT_FOLLOWED_BY_NUMBER_IN_PARENS, x);
    CheckOptionalArgumentValue(n,hasY    ,_Y   ,       Y_ARGUMENT_USED_TWICE, Y_NOT_FOLLOWED_BY_NUMBER_IN_PARENS, y);
    CheckOptionalArgumentValue(n,hasZ    ,_Z   ,       Z_ARGUMENT_USED_TWICE, Z_NOT_FOLLOWED_BY_NUMBER_IN_PARENS, z);
    CheckOptionalArgumentValue(n,hasIJK  ,_IJK  ,     IJK_ARGUMENT_USED_TWICE, IJK_NOT_FOLLOWED_BY_ARGIJK, i1,j1,k1);
    CheckOptionalArgumentValue(n,hasLMN  ,_LMN  ,     LMN_ARGUMENT_USED_TWICE, IJK_NOT_FOLLOWED_BY_ARGIJK, i2,j2,k2);
    if (old_n == n) { 
      // the argument has not been recognized:
      _errorCode = BAD_ARGUMENTS;
    } 
  }
  if (!hasX || !hasY || !hasZ || !hasIJK ||!hasLMN ) {
    // all part of the required enumeration must have been found
    _errorCode = BAD_ARGUMENTS;
  }
  return (_errorCode != OK) ? NULL:
    new ippPtMeasSelfCenterLockedCommand(_tag, x, y, z,   ippTargetVector(i1,j1,k1) ,ippTargetVector(i2,j2,k2));}



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

/* ippCommandParser::makeCommand

Returned Value: A ippCommand of the appropriate type or NULL.

Called By: ippCommandParser::parseCommand

Rules: None.

This just calls the makeXXX function for the command type whose name
is in the _commandName data member of the parser.

*/


ippCommandPtr ippCommandParser::makeCommand()
{
  switch(_commandName)
  {
    // this code is equivalent to 
    //  case IsHome : return makeIsHomed();
    // for all values defined in he COMMAND enumeration

#define ENUM(value,function) case ipp::value: return IPP_CONCAT(make,value)();
    COMMAND_ENUMERATION
#undef ENUM

    default: 
      return makeAbortE();
  }
}

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

/* ippCommandParser::parseCommand

Returned Value: A ippCommand of the appropriate type or NULL.

Called By:
   external functions
   main (in stand-alone command parser and stand-alone command checker)

Rules:
1. <13><10><0> must immediately follow the close parentheses at the
   end of the command.
   BAD_CHARACTER_AFTER_COMMAND_END
2. If the command is an event command, the _tag must be an event _tag.
   EVENT_COMMAND_MUST_HAVE_EVENT_TAG
3. If the command is not an event command, the _tag must not be an event _tag.
   NON_EVENT_COMMAND_MUST_NOT_HAVE_EVENT_TAG

The setInput function copies a command string into the parser's
_inputArray, stopping at the first NULL, so the rule above is reasonable.

parseTag sets the _errorCode to OK if the _tag is OK syntactically.

*/

//=============================================================================
ippCommandPtr ippCommandParser::parseCommand()
//-----------------------------------------------------------------------------
{
  ippCommandPtr aCommand = 0;

  _commandName =ippCommandNameType_INVALID;
  
  parseTag();
  
  if (_errorCode == OK)  {
    unSpaceInputArray();
  }

  if (_errorCode == OK) {
    parseCmdName();
  }
  if (_errorCode == OK) {
    parseCmdArguments();
  }

  if ((_errorCode == OK) &&
      ((_inputArray[_arrayIndex] != 13) ||
       (_inputArray[_arrayIndex + 1] != 10) ||
       (_inputArray[_arrayIndex + 2] != 0))) 
 {
    _errorCode = BAD_CHARACTER_AFTER_COMMAND_END;
  }
 
  if (_errorCode == OK) {
     if (   (_commandName == AbortE) || 
            (_commandName == GetErrStatusE) || 
            (_commandName == GetPropE) || 
            (_commandName == OnMoveReportE)
        )       {
          if (!_isEvent) {
            _errorCode = EVENT_COMMAND_MUST_HAVE_EVENT_TAG;
          }
      } else  {
        if (_isEvent) {
          _errorCode = NON_EVENT_COMMAND_MUST_NOT_HAVE_EVENT_TAG;
        }
      }
  }
  if (_errorCode == OK) {
    aCommand = makeCommand();
  }

 // Added by ER to fix potential leak
 if (_errorCode != OK ) {
   if (aCommand) {     
    aCommand = 0;
   }
 }
 return ((_errorCode != OK) ? NULL : aCommand);
}

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

/* ippCommandParser::parseCmdArguments

Returned Value: None.

Called By: ippCommandParser::parseCommand

Rules:
1. If an argument component starts with a left parenthesis and is followed
   by a number, but is not preceded by the IJK keyword, then a right
   parenthesis must follow the number.
   BAD_COMMAND_ARGUMENTS
2. The argument component being parsed does not start the way any known
   argument component starts.
   BAD_COMMAND_ARGUMENTS

Each turn around the "for" loop parses one argument component.

This decides what subordinate function to call to do the parsing
depending on how the argument component starts.

When this is called, _arrayIndex points at the first character after the
left parenthesis that starts the argument list. On subsequent turns
around the for loop, _arrayIndex points at the first character of an
argument component. Since _arrayIndex++ is executed at the end of each turn
around the loop, any function this calls must leave _arrayIndex pointing
at the last character it reads.

Spaces outside of strings are removed before this runs, so spaces
are not dealt with outside strings.

A dot may appear either before a capital letter (as in Tool.PtMeasPar)
or at the beginning of a number (as in .123). In the first case it is
an argument list component. In the second case it is part of the number.

If the right parentheses after the arguments is missing, that will be
caught either here (on the second BAD_COMMAND_ARGUMENTS line) or in one
of the functions this calls.

*/

void ippCommandParser::parseCmdArguments()
{
  char c;
  char d;

  
  
  for (_argCount = 0; ((c = _inputArray[_arrayIndex]) != ')' ); _argCount++) {
      
     if (_argCount +3 >= _argSize) {
          makeArraysBigger();
     }

     d = _inputArray[_arrayIndex + 1];

     if (c == ',') {
        
        _argTypes[_argCount] = ARGCOMMA;
         
     }  else if ((c == '.') && ( d >= 'A') && (d <= 'Z' )) { /* dot before upper letter */
       
       _argTypes[_argCount] = ARGDOT; 
     
     }  else if ((c == '(') && (d == ')')) {

        _arrayIndex++;
        _argTypes[_argCount] = ARGPARENEMPTY;

     } else if ((c == '(') &&  ((d == '-') ||(d == '+') ||(d == '.') || isdigit(d)))    {


        _arrayIndex++;
        if ((_argTypes[_argCount - 1] == ARGKEYWORD) &&  
            (_argKeywords[_argCount - 1] == Data)  ) {
          // special case for the Data keyword that accepts a variable number of argument
          parseData();

        } else  if ((_argTypes[_argCount - 1] == ARGKEYWORD) &&  
            (_argKeywords[_argCount - 1] == _IJK ||_argKeywords[_argCount - 1] == _LMN ) ) {
           // special case for the IJK or the LMN keyword that expect 3 values 
           // i.e IJK(#,#,#) 
           parseData();
 
        } else  {
          // in all other cases the argument is followed by a single value in parenthesis
          parseNumber(ARGDOUBLE);// _argDoubles, _argCount);

          if (_errorCode != OK) {
             ;// what shall we do here ?
          } else if (_inputArray[_arrayIndex + 1] == ')') {
            _arrayIndex++;
            _argTypes[_argCount] = ARGPARENDOUBLE;

          }  else {
             _errorCode = BAD_COMMAND_ARGUMENTS;

          }
        }
    }  else if (c == '"') {  /* open quote */

        parseString();
    
    }  else if ((c == '-') || (c == '+') || (c == '.') || isdigit(c)) {
     
       parseNumber(ARGDOUBLE);
    
    }  else if ((c >= 'A') && (c <= 'Z')) {
    
      parseKeyword();
    
    } else {
    
      _errorCode = BAD_COMMAND_ARGUMENTS;
    
    }
    if (_errorCode != OK) {
      break;
    }
    
    _arrayIndex++; /* move to character after end of argument just parsed */
  }
  _arrayIndex++; /* move to character after the close parenthesis */

}

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

/* ippCommandParser::parseCmdName

Returned Value: None.

Called By: ippCommandParser::parseCommand

Rules:
1. The command name must be a known command name.
   BAD_COMMAND_NAME

This reads the command name from the _inputArray and sets _commandName.
If the name is not the name of an I++ command, or if the name is not
followed immediately by a left parenthesis, _commandName is set to -1.

The _arrayIndex is left set to index the character following the left
parenthesis after the command name.

*/


ippCommandHashTable::ippCommandHashTable()
{
  for (int i=0; i<ippCOMMANDNAMETYPE_MAXIMUM;i++)
  {
#define ENUM(a,b) _map.insert(_Pair(b,a));
    COMMAND_ENUMERATION
#undef ENUM
  }
}
ippCommandNameType ippCommandHashTable::find(const std::string& name)
{
  _Iter i = _map.find((name));
  if (i == _map.end()) { 
    return ippCommandNameType_INVALID;
  }
  return i->second;
}

void ippCommandParser::parseCmdName()
{  
  // the command name should start at character 6
  const char * name = (_inputArray + 6);

  // we first try to locate the opening paren : 
  const char* paren = strstr(name,"(");
  if (!paren) { 
    _errorCode = BAD_COMMAND_NAME;
    return;
  }
  int cmdLength = (paren-name);

  // query the command hash table to find out the enum
  // value of the command.
  _errorCode = OK;
  _commandName =  g_command_hash.find(std::string(name,cmdLength));
  
  if (_commandName == ippCommandNameType_INVALID) {
    _errorCode = BAD_COMMAND_NAME;
  }

  // set arrayIndex to point at character after left paren 
  _arrayIndex = ( paren - _inputArray) +1;
}





class ippKeyWordHashTable
{
  typedef std::map<std::string,ippOtherKeyType>   Map;
  typedef std::map<std::string,ippOtherKeyType>::const_iterator  _Iter;
  typedef std::pair <std::string, ippOtherKeyType> _Pair;
  Map _map;
public:
  ippKeyWordHashTable();
  ippOtherKeyType find(const std::string& string);
} g_keyword_hash;

ippKeyWordHashTable::ippKeyWordHashTable()
{
  for (int i=0; i<ippOTHERKEYTYPE_MAXIMUM;i++)
  {
#define ENUM(a,b) _map.insert(_Pair(b,a));
    KEYWORD_ENUMERATION
#undef ENUM
  }
}
ippOtherKeyType ippKeyWordHashTable::find(const std::string& name)
{
  _Iter i = _map.find((name));
  if (i == _map.end()) { 
    return ippOtherKeyType_INVALID;
  }
  return i->second;
}


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

/* ippCommandParser::parseKeyword

Returned Value: None.

Called By: ippCommandParser::parseCmdArguments

Rules:
1. The character after a keyword must be a period, a comma, or a left or
   right parenthesis
   BAD_CHARACTER_AFTER_KEYWORD
2. The characters being parsed must form either an event _tag or a
   known keyword.
   BAD_KEYWORD

This parses event tags as well as keywords.

This is called only if the character at _inputArray[_arrayIndex] is an
upper case letter.

If there are extra letters after a valid keyword, rule 1 will be violated,
so the extra letters will be detected.

Spaces may be legal in the command itself, but spaces have been
removed before this function is called.

If one keyword is the same as the beginning of another keyword, a check
for the longer keyword must be made first. The only cases of that are
A, C, and R.

When the keyword is a single letter, it is not necessary to use a
check like [if (strncmp(keyword, "A", 1) == 0)] since that is already
known from the case statement to be true, but those checks are
included just to keep the code looking consistent.

This is parsing some keywords (MoveMan, OBB, etc.) that cannot occur
in commands, but there is no harm in that. Inappropriate keywords will
be detected elsewhere.

*/
ippOtherKeyType getFromString(const std::string& keyword )
{
  return g_keyword_hash.find(std::string(keyword));
}

void ippCommandParser::parseKeyword()
{

  _argKeywords[_argCount] = ippOtherKeyType_INVALID;
  const char* keyword = (_inputArray + _arrayIndex);// pointer to start of word
  
  // we first try to locate the end of the key workd paren : 
  const char* endkeyword = keyword;
  while(isalpha(*endkeyword++));
  
  int keywordLength = (endkeyword-keyword)-1;

  // query the command hash table to find out the enum
  // value of the command.
  _errorCode = OK;

  if (keyword[0] == 'E') {
    if (isdigit(keyword[1]) && isdigit(keyword[2]) &&
        isdigit(keyword[3]) && isdigit(keyword[4]))
    {
      _argKeywords[_argCount] = TagKey;
      _argInt = (unsigned int)((1000*(keyword[1]-'0'))+
                               (100 *(keyword[2]-'0'))+
                               (10  *(keyword[3]-'0')) +
                               (1   *(keyword[4]-'0')));
      _arrayIndex+=4;
      keywordLength = 1;
   }
  }

  if(ippOtherKeyType_INVALID == _argKeywords[_argCount]) { 
    _argKeywords[_argCount] =   getFromString(std::string(keyword,keywordLength));
    if (ippOtherKeyType_INVALID== _argKeywords[_argCount]) {
      _errorCode = BAD_KEYWORD;
      return;
    }
  }  
  // special treatment for the  "Format" keyword
  if (_argKeywords[_argCount] == Format ) { 

    // there is only 3 possibilities for the Format portion of the ScanOnCurve
    // command. 
    // I wonder why the I++ commity made this so complicated : 
    //   -> it uses a second nested level  ScanOnCuve(..,Format(Stuf(),....)
    //   -> it uses no conventional keyworks:  tag,pi,pj,pk,si,sj, and sk
    //      -> they don't take arguments whereas X,Y,Z,and IJK do
    //      -> They are the only keyword in the specs athat do not strat with a upper letter !
    //
    // this code substute the complex Format command by an ellispis so that 
    // the existing parser can work easily :
    // Format[(...](1) for the first form
    // Format[(...](2) for the second form
    // Format[(...](3) for the third form
    // 
    static const char* type1= ippScanOnCurveCommand::getFormatString(ippScanOnCurveCommand::Type1);
    static int type1_length = strlen(type1);
    static const char* type2= ippScanOnCurveCommand::getFormatString(ippScanOnCurveCommand::Type2);
    static int type2_length = strlen(type2);
    static const char* type3= ippScanOnCurveCommand::getFormatString(ippScanOnCurveCommand::Type3);
    static int type3_length = strlen(type3);
    
    int l = strlen(keyword);
    if (strncmp(keyword,type1,type1_length) == 0 ) { 
      _inputArray[_arrayIndex+type1_length-3] = '(';
      _inputArray[_arrayIndex+type1_length-2] = '1';
      keywordLength = type1_length-3;

    } else if (strncmp(keyword,type2,type2_length) == 0 ){
      _inputArray[_arrayIndex+type2_length-3] = '(';
      _inputArray[_arrayIndex+type2_length-2] = '2';
      keywordLength = type2_length-3;

    } else if (strncmp(keyword,type3,type3_length) == 0 ){ 
      _inputArray[_arrayIndex+type3_length-3] = '(';
      _inputArray[_arrayIndex+type3_length-2] = '3';
      keywordLength = type3_length-3;
    } else {
      _errorCode = BAD_SYNTAX_FOR_FORMAT_IN_SCANONCURVE;
      return;
   }

  }

  _arrayIndex = (_arrayIndex + keywordLength ) -1;
  if ((_inputArray[_arrayIndex + 1] == '.') ||
      (_inputArray[_arrayIndex + 1] == ',') ||
      (_inputArray[_arrayIndex + 1] == '(') ||
      (_inputArray[_arrayIndex + 1] == ')')) 
  {
     _argTypes[_argCount] = ((_argKeywords[_argCount] == TagKey) ? ARGETAG : ARGKEYWORD);
  } else {
     _errorCode = BAD_CHARACTER_AFTER_KEYWORD;
  }
}

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

/* ippCommandParser::parseNumber

Returned Value: None.

Called By:
  ippCommandParser::parseCmdArguments
  ippCommandParser::parseIJK

Rules:
1. A number must not have two decimal points.
   BAD_NUMBER_TWO_DECIMAL_POINTS
2. A number must have at least one digit.
   BAD_NUMBER_NO_DIGITS
3. A number must not have more than 16 digits.
   BAD_NUMBER_MORE_THAN_16_DIGITS
4. The exponent of a number must have 1, 2, or 3 digits.
   BAD_E_NUMBER_EXPONENT_MUST_HAVE_ONE_TWO_OR_THREE_DIGITS

Reference pages: (33 - 34)

In natural language, the definition of a number is: An optional sign
followed by one to sixteen digits (optionally with a decimal point
before the digits, between two digits, or after the last digit)
followed optionally by an exponent. An exponent is an upper case E or
a lower case e followed by an optional sign, followed by one, two, or
three digits.  This definition is given in the spec on page 33 in
natural language and on page 34 using a production language.

This parses all numbers as doubles. If a number is required to be an
integer by the syntax of command XXX, the makeXXX function checks that
it has the value of an integer.

When this starts up, _arrayIndex is set to indicate the first character
of what should be a number (a plus or minus sign, a digit, or a
decimal point). When this finishes, _arrayIndex is set to indicate the
last character that could be part of the number.

The parsed number is placed in the store argument.

*/
double ippCommandParser::getValue(int index) const
{
  IPP_ASSERT(index >=0 && index<=_argDoubles.size());
  IPP_ASSERT(_argTypes[index] == ARGDOUBLE || _argTypes[index] == ARGIJK  || _argTypes[index] == ARGPARENDOUBLE);
  return _argDoubles[index];
}

void ippCommandParser::parseNumber(ippArgItemType argType)
{
  IPP_ASSERT(argType == ARGDOUBLE || argType == ARGIJK);
  IPP_ASSERT_MSG(_errorCode == OK,"Parser in error state !");

  int sign = 0; // set to 1 if first character is '+' or '-'
  int dot = 0;  // set to 1 if a decimal point is found
  int k;        // index for _inputArray
  int j;        // counts digits of exponent
  char save;

  if ((_inputArray[_arrayIndex] == '-') || (_inputArray[_arrayIndex] == '+')) {
    sign = 1;
  }

  for (k = (_arrayIndex + sign);((_errorCode == OK) &&((_inputArray[k] == '.') || ((_inputArray[k] > 47) && (_inputArray[k] < 58)))); k++) {
    if (_inputArray[k] == '.') {
      if (dot == 0) {
        dot = 1;
      } else {
        _errorCode = BAD_NUMBER_TWO_DECIMAL_POINTS;
      }
    }   
  }

  if ((_errorCode == OK) && ((_arrayIndex + sign + dot) == k)) {
    _errorCode = BAD_NUMBER_NO_DIGITS;
  }
  if ((_errorCode == OK) && ((k - (_arrayIndex + sign + dot)) > 16)) {
    _errorCode = BAD_NUMBER_MORE_THAN_16_DIGITS;
  }
  if ((_errorCode == OK) && ((_inputArray[k] == 'E') || (_inputArray[k] == 'e'))) {
    k++;
    if ((_inputArray[k] == '+') || (_inputArray[k] == '-')) {
      k++;
    }
    for (j = 0; ((_inputArray[k] > 47) && (_inputArray[k] < 58)); j++) {
      k++;
    }
    if ((j < 1) || (j > 3)) {
      _errorCode = BAD_E_NUMBER_EXPONENT_MUST_HAVE_ONE_TWO_OR_THREE_DIGITS;
    }
  }

  if (_errorCode == OK) {
   save = _inputArray[k];
   _inputArray[k] = 0; //put in temporary null terminator
   double value =0;
   sscanf((_inputArray + _arrayIndex), "%lf", &value);

   if (_argCount +3 >= _argSize) {
        makeArraysBigger();
   }

   IPP_ASSERT(_argDoubles.size() > _argCount);
   IPP_ASSERT(_argTypes.size()   > _argCount);

   _argDoubles[_argCount] = value;
   _argTypes[_argCount]= argType;
   
   _inputArray[k] = save; // put char back
   _arrayIndex = (k - 1); // set _arrayIndex to end of number
  }
}

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

/* ippCommandParser::parseString

Returned Value: None.

Called By: ippCommandParser::parseCmdArguments

Rules:
1. There must be a terminating double-quote (ASCII 34), and all characters
   between the double quotes must be in the range ASCII 32 to 126.
   BAD_STRING
2. A string must have at least one character in it.
   BAD_STRING

Reference pages: 10 (33) 34 35 43 46 66 73 99 102 106 107 108 109
These references are only those where string is the data type of a
component of a command or a response. The word string is used in other
places to refer to an entire command or response.

A String starts with a double quote (ASCII 34) and ends at the
next double quote. A double quote cannot be inside a string.
When this function starts, _arrayIndex is indicating the opening
double quote.

*/

void ippCommandParser::parseString()
{
  int start;
  char c;

  _arrayIndex++; // skip starting quote
  
  start = _arrayIndex;

  for (; ((c = _inputArray[_arrayIndex]) != 34); _arrayIndex++){
    if ((c < 32) || (c > 126)) {
      _errorCode = BAD_STRING;
      break;
    }
  }
  if (start == _arrayIndex) {
    _errorCode = BAD_STRING;
  }
  if (_errorCode == OK) {
      _inputArray[_arrayIndex] = 0; // set temporary null terminator
      _argStrings[_argCount] = _inputArray + start; // hook copy in
      _inputArray[_arrayIndex] = 34; // restore quote at end
      _argTypes[_argCount] = ARGSTRING;
  }
}

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

/* ippCommandParser::parseTag

Returned Value: None.

Called By: ippCommandParser::parseCommand

Rules:
1. A _tag must have five characters, the first of which is a digit or E,
   and the rest of which are digits.
   BAD_TAG_CHARACTER
2. The sixth input character (which should follow the last _tag character)
   must be a space.
   SPACE_MISSING_AFTER_TAG
3. If the first character is a digit, the number formed by the five digits
   must be in the range 1 - 99999. Since there are only five digits,
   the upper limit does not need testing, so the only check is for 0.
   TAG_NUMBER_OUT_OF_RANGE_FOR_COMMAND_TAG
4. If the first character is E, the number formed by the four digits must
   be in the range 1 - 9999. Since there are only four digits, the upper
   limit does not need checking, so the only check is for 0.
   TAG_NUMBER_OUT_OF_RANGE_FOR_EVENT_TAG

Reference pages: (21) (22) 26-30 (34-42) (47) (49) (50) (75) (77) 99-113

There should be a _tag at the beginning of the _inputArray. This function
reads that _tag.

In responses, the event _tag E0000 is allowed, but this is a command parser,
so it is not allowed here.

*/


void ippCommandParser::parseTag()
{
  _errorCode = OK;
  if ((_inputArray[1] < 48) ||
      (_inputArray[1] > 57) ||
      (_inputArray[2] < 48) ||
      (_inputArray[2] > 57) ||
      (_inputArray[3] < 48) ||
      (_inputArray[3] > 57) ||
      (_inputArray[4] < 48) ||
      (_inputArray[4] > 57)) {

    _errorCode = BAD_TAG_CHARACTER;


  }  else if (_inputArray[5] != 32) {

    _errorCode = SPACE_MISSING_AFTER_TAG;

  } else if (_inputArray[0] == 'E') {
    
    _isEvent = true;
    sscanf((_inputArray + 1), "%d", &_tag);
    if (_tag == 0) {
      _errorCode = TAG_NUMBER_OUT_OF_RANGE_FOR_EVENT_TAG;
    }

  } else if ( isdigit(_inputArray[0]) ) {
    
    _isEvent = false;
    sscanf(_inputArray, "%d", &_tag);
    if (_tag == 0) {
      _errorCode = TAG_NUMBER_OUT_OF_RANGE_FOR_COMMAND_TAG;
    }
  
  } else {
    _errorCode = BAD_TAG_CHARACTER;
  }
}

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

/* ippCommandParser::parseIJK

Returned Value: None.

Called By: ippCommandParser::parseCmdArguments

Rules:
1. A comma must follow the first and second numbers.
   BAD_IJK_NUMBERS
2. Each of the three numbers must start with a plus sign, minus
   sign, decimal point, or digit.
   BAD_IJK_NUMBERS
3. The third number must be followed by a right parenthesis.
   BAD_IJK_NUMBERS

Reference pages: 27 28 (49) (52 - 53) (61) (62) (78) (81) 103 104
These reference pages include all uses of IJK, not just the use
that is is parsed by this function.

This is called only if arguments are being parsed, a left parenthesis
has been found, the keyword IJK precedes the left parenthesis, and the
character after the left parenthesis could be part of a number. Three
numbers separated by commas and followed by a right parenthesis are
expected.  The numbers are placed in the _argDoubles array.

When this starts, _arrayIndex is set to indicate the beginning of the
first number. When this finishes, _arrayIndex is set to indicate the
closing right parenthesis.

*/

void ippCommandParser::parseData()
{
  char c;
  int n =0;
  while(_errorCode == OK) {
    if (_inputArray[_arrayIndex+1] == ')') { 
      _argCount--;
      break;
    }
    if (n > 0) {
      _arrayIndex++;
      if (_inputArray[_arrayIndex] != ',') {
        _errorCode = BAD_IJK_NUMBERS;
        break;
      } else {
        _arrayIndex++;
      }
    }
   
    c = _inputArray[_arrayIndex];
    if ((c == '-') || (c == '+') ||(c == '.') || isdigit(c)) {
      parseNumber(ARGIJK);
      //xx _argTypes[_argCount] = ARGIJK;
      _argCount++;
    } else{
      _errorCode = BAD_IJK_NUMBERS;
      break;
    }
    n++;
  } // end while

  if (_errorCode == OK) {
    _arrayIndex++;
    if (_inputArray[_arrayIndex] != ')') {
      _errorCode = BAD_IJK_NUMBERS;
    }
  }


}


bool UnSpaceInputArray(char* _inputArray,int start)
{
  bool result =true;
  char c;
  int n;
  int gap = 0;
  bool stringing = false;
  bool spaceBefore = false;
  bool puncBefore = false;

  for (n = start; _inputArray[n-1] != NULL; n++){
   
    c = _inputArray[n];
    if (stringing){
      if (c == '"') { stringing = false; }
    }  else if (c == ' ') {
      gap++;
      if (!puncBefore) {spaceBefore = true;}
      continue;
    } else if (spaceBefore) {
      
      if ((c == '(') || (c == ')') || (c == ',')) {
        spaceBefore = false;
        puncBefore = true;
      } else {
        result = false;
        break;
      }
    } else if ((c == '(') || (c == ')') || (c == ',')) {
       puncBefore = true; 
    } else {
      puncBefore = false;
      if (c == '"') {
         stringing = true;
      }
    }
    _inputArray[n - gap] = c;
  }
  return result;

}

void ippCommandParser::unSpaceInputArray()
{
  if(!::UnSpaceInputArray(_inputArray,6)) {
    _errorCode =ILLEGAL_SPACE;
  }
}

---