ippCommandChecker.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"

/* ippCommandCheckerBase.cc

  This defines functions in the ippCommandCheckerBase class.

  Functions named checkXXX (where XXX is a command name) are used to
  check each type of command in context. The checkXXX functions are
  called by checkCommand, which does some checks before calling.  The
  documentation for each checkXXX function gives the rules that it is
  enforcing and gives one or more references to pages of version 1.4 of
  the spec. The error code generated if a rule is broken is given after
  each rule.

  The arguments to each command are assumed to have passed the checks
  performed by the command parser. If this checker is used without the
  checks performed by the command parser having been made previously, the
  checker may crash or give wrong results.

  Several semantic checks are made in this checker that could be made in
  the command parser (because context is not required). For example, the
  check that a direction vector is not (0, 0, 0). These are identified
  here as semantic checks.

  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.
              
*/

#include "ippdme/Checker/ippCommandChecker.h"
#include "ippdme/world.h"

#include "ippdme/Command/commands.h"
#include "ippdme/ippErrorNameType.h"
#include "ippdme/assert.h"




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

/* ippCommandCheckerBase::getIppErr

  Returned Value: int (the number of the I++ error corresponding to the
  "code" argument)

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

  Rules: None.

  For attempting to do anything with UNDEFTOOL, the IppErr is always
  ToolNotDefined.

  For attempting to do illegal things with NOTOOL, the IppErr is always
  IllegalCommand.
          
*/
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define CHECKER_ENUMERATION \
  CHECKER_ENUM(CHECKER_OK                                  ,GenericError            ,"OK") \
  CHECKER_ENUM(AXIS_DIRECTION_VECTOR_HAS_ZERO_LENGTH       ,VectorHasNoNorm         ,"AXIS DIRECTION VECTOR HAS ZERO LENGTH")\
  CHECKER_ENUM(BAD_ERROR_NUMBER                            ,ArgumentOutOfRange      ,"BAD ERROR NUMBER")\
  CHECKER_ENUM(CAN_NOT_CHANGE_TOOL_TO_UNDEFTOOL            ,ToolNotDefined          ,"CAN NOT CHANGE TOOL TO UNDEFTOOL")\
  CHECKER_ENUM(CAN_NOT_ENUMALLPROP_NOTOOL_PTMEASPAR        ,IllegalCommand          ,"CAN NOT ENUMALLPROP NOTOOL PTMEASPAR")\
  CHECKER_ENUM(CAN_NOT_ENUMALLPROP_UNDEFTOOL_GOTOPAR       ,ToolNotDefined          ,"CAN NOT ENUMALLPROP UNDEFTOOL GOTOPAR")\
  CHECKER_ENUM(CAN_NOT_ENUMALLPROP_UNDEFTOOL_PTMEASPAR     ,ToolNotDefined          ,"CAN NOT ENUMALLPROP UNDEFTOOL PTMEASPAR")\
  CHECKER_ENUM(CAN_NOT_ENUMPROP_NOTOOL_PTMEASPAR           ,IllegalCommand          ,"CAN NOT ENUMPROP NOTOOL PTMEASPAR")\
  CHECKER_ENUM(CAN_NOT_ENUMPROP_UNDEFTOOL_GOTOPAR          ,ToolNotDefined          ,"CAN NOT ENUMPROP UNDEFTOOL GOTOPAR")\
  CHECKER_ENUM(CAN_NOT_ENUMPROP_UNDEFTOOL_PTMEASPAR        ,ToolNotDefined          ,"CAN NOT ENUMPROP UNDEFTOOL PTMEASPAR")\
  CHECKER_ENUM(CAN_NOT_GETPROP_PTMEASPARS_OF_NOTOOL        ,IllegalCommand          ,"CAN NOT GETPROP PTMEASPARS OF NOTOOL")\
  CHECKER_ENUM(CAN_NOT_GETPROP_UNDEFTOOL                   ,ToolNotDefined          ,"CAN NOT GETPROP UNDEFTOOL")\
  CHECKER_ENUM(CAN_NOT_GETPROPE_PTMEASPARS_OF_NOTOOL       ,IllegalCommand          ,"CAN NOT GETPROPE PTMEASPARS OF NOTOOL")\
  CHECKER_ENUM(CAN_NOT_GETPROPE_UNDEFTOOL                  ,ToolNotDefined          ,"CAN NOT GETPROPE UNDEFTOOL")\
  CHECKER_ENUM(CAN_NOT_GOTO_USING_UNDEFTOOL                ,IllegalCommand          ,"CAN NOT GOTO USING UNDEFTOOL")\
  CHECKER_ENUM(CAN_NOT_PTMEAS_USING_NOTOOL                 ,IllegalCommand          ,"CAN NOT PTMEAS USING NOTOOL")\
  CHECKER_ENUM(CAN_NOT_PTMEAS_USING_UNDEFTOOL              ,ToolNotDefined          ,"CAN NOT PTMEAS USING UNDEFTOOL")\
  CHECKER_ENUM(CAN_NOT_REQUALIFY_NOTOOL                    ,IllegalCommand          ,"CAN_NOT_REQUALIFY_NOTOOL")\
  CHECKER_ENUM(CAN_NOT_REQUALIFY_UNDEFTOOL                 ,ToolNotDefined          ,"CAN_NOT_REQUALIFY_UNDEFTOOL")\
  CHECKER_ENUM(CAN_NOT_SCAN_USING_NOTOOL                   ,IllegalCommand          ,"CAN NOT SCAN USING NOTOOL")\
  CHECKER_ENUM(CAN_NOT_SCAN_USING_UNDEFTOOL                ,ToolNotDefined          ,"CAN NOT SCAN USING UNDEFTOOL")\
  CHECKER_ENUM(CAN_NOT_SET_TOOL_TO_UNDEFTOOL               ,ToolNotDefined          ,"CAN NOT SET TOOL TO UNDEFTOOL")\
  CHECKER_ENUM(CAN_NOT_SETPROP_PTMEASPARS_OF_NOTOOL        ,IllegalCommand          ,"CAN NOT SETPROP PTMEASPARS OF NOTOOL")\
  CHECKER_ENUM(CAN_NOT_SETPROP_UNDEFTOOL                   ,ToolNotDefined          ,"CAN NOT SETPROP UNDEFTOOL")\
  CHECKER_ENUM(DAEMON_TO_STOP_DOES_NOT_EXIST               ,DaemonDoesNotExist      ,"DAEMON TO STOP DOES NOT EXIST")\
  CHECKER_ENUM(DIRECTION_VECTOR_HAS_ZERO_LENGTH            ,VectorHasNoNorm         ,"DIRECTION VECTOR HAS ZERO LENGTH")\
  CHECKER_ENUM(DIS_ARGUMENT_MUST_BE_POSITIVE               ,BadProperty             ,"DIS ARGUMENT MUST BE POSITIVE")\
  CHECKER_ENUM(FIRST_VECTOR_NOT_NORMALIZED                 ,IncorrectArguments      ,"FIRST VECTOR NOT NORMALIZED")\
  CHECKER_ENUM(MUST_STOP_EXISTING_DAEMON_BEFORE_STARTING_ANOTHER,DaemonAlreadyExists, "MUST STOP EXISTING DAEMON BEFORE STARTING ANOTHER")\
  CHECKER_ENUM(NOT_HOMED_CAN_NOT_EXECUTE_COMMAND           ,IllegalCommand          ,"NOT HOMED CAN NOT EXECUTE COMMAND")\
  CHECKER_ENUM(RADIUS_MUST_BE_PERPENDICULAR_TO_NORMAL      ,IllegalCommand          ,"RADIUS MUST BE PERPENDICULAR TO NORMAL")\
  CHECKER_ENUM(RADIUS_MUST_HAVE_POSITIVE_LENGTH            ,IncorrectArguments      ,"RADIUS MUST HAVE POSITIVE LENGTH")\
  CHECKER_ENUM(READINESS_ABORTED_CAN_NOT_EXECUTE_COMMAND   ,UseClearAllErrorsToCont ,"READINESS ABORTED CAN NOT EXECUTE COMMAND")\
  CHECKER_ENUM(READINESS_ERRED_CAN_NOT_EXECUTE_COMMAND     ,UseClearAllErrorsToCont ,"READINESS ERRED CAN NOT EXECUTE COMMAND")\
  CHECKER_ENUM(SCAN_POINT_MUST_BE_IN_WORK_VOLUME           ,ArgumentOutOfRange      ,"SCAN POINT MUST BE IN WORK VOLUME")\
  CHECKER_ENUM(SECOND_VECTOR_NOT_NORMALIZED                ,IncorrectArguments      ,"SECOND VECTOR NOT NORMALIZED")\
  CHECKER_ENUM(START_POINT_MUST_DIFFER_FROM_DIRECTION_POINT,IncorrectArguments      ,"START POINT MUST DIFFER FROM DIRECTION POINT")\
  CHECKER_ENUM(START_POINT_MUST_DIFFER_FROM_END_POINT      ,IncorrectArguments      ,"START POINT MUST DIFFER FROM END POINT")\
  CHECKER_ENUM(START_POINT_MUST_NOT_BE_ON_CYLINDER_AXIS    ,IncorrectArguments      ,"START POINT MUST NOT BE ON CYLINDER AXIS")\
  CHECKER_ENUM(TARGET_POINT_OUT_OF_WORK_VOLUME             ,TargetPosOutOfMachVol   ,"TARGET POINT OUT OF WORK VOLUME")\
  CHECKER_ENUM(THETA_MUST_NOT_BE_NEGATIVE_OR_MORE_THAN_180 ,ThetaOutOfRange         ,"THETA MUST NOT BE NEGATIVE OR MORE THAN 180")\
  CHECKER_ENUM(TIME_ARGUMENT_MUST_NOT_BE_LESS_THAN_A_TENTH ,BadProperty             ,"TIME ARGUMENT MUST NOT BE LESS THAN A TENTH")\
  CHECKER_ENUM(UNKNOWN_TOOL                                ,ToolNotFound            ,"UNKNOWN TOOL")\


ippErrorNameType ippCommandCheckerBase::getIppErr(ippCheckerErrorId code)
{
    switch(code){
#define CHECKER_ENUM(enumValue,IPPError,c) case enumValue: return IPPError;
      CHECKER_ENUMERATION
#undef CHECKER_ENUM
    }
    return GenericError;
}

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

/* ippCommandCheckerBase::getErrorMessageString

  Returned Value: std::string
  If there is a problem with providing a string, this returns an empty string.
  Otherwise, it returns the full text of the message

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

  Rules: None.

  This copies an error message into the buffer, preceded by the name
  of the command being checked when the error was found.

  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 ippCommandChecker.h.
          
*/

std::string ippCommandCheckerBase::getErrorMessageString() const
{
  std::string error_string;
  if ((_commandName > -1) && (_commandName < ippCOMMANDNAMETYPE_MAXIMUM)) {
    
    error_string.append(getCommandNameString(_commandName));
    error_string.append(" : ");
  }

  switch(_errorCode){
    #define CHECKER_ENUM(x,b,c) case x: error_string.append(c); break;
      CHECKER_ENUMERATION
    #undef CHECKER_ENUM
  }

  return error_string.c_str();
}

ippCommandCheckerBase::ippCommandCheckerBase()
{
}
/*******************************************************************/

/* ippCommandChecker::checkAbortE 1

  Returned Value: None.
  
  Called By: ippCommandChecker::checkCommand

  Rules: None.

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

void ippCommandChecker::checkAbortE(
  ippCommandConstPtr aCommand
)
{
  
}

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

/* ippCommandChecker::checkAlignPart 2

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules:
  1. The system must be homed (see p. 48)
  NOT_HOMED_CAN_NOT_EXECUTE_COMMAND

  Reference pages: 24 28 63 (95) 105
        
*/

void ippCommandChecker::checkAlignPart( ippCommandConstPtr aCommand)
{
  if (!(_world->getIsHomed())) {
    _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;
  }
}

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

/* ippCommandChecker::checkAlignTool 3

    Returned Value: None.

    Called By: ippCommandChecker::checkCommand

    Rules:
    1. Vector1 must be a unit vector.
    FIRST_VECTOR_NOT_NORMALIZED
    2. If vector2 is set, it must be a unit vector.
    SECOND_VECTOR_NOT_NORMALIZED
    3. The system must be homed (see p. 48)
    NOT_HOMED_CAN_NOT_EXECUTE_COMMAND

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

    The first two rules are semantic checks.

    Might add not allowing AlignTool using UnDefTool or NoTool.

*/

void ippCommandChecker::checkAlignTool( ippCommandConstPtr aCommand)
{
  const ippAlignToolCommand* theAlign = static_cast<const ippAlignToolCommand*>(aCommand.get());

  double i;
  double j;
  double k;
  

  i = theAlign->getVector1i();
  j = theAlign->getVector1j();
  k = theAlign->getVector1k();
  if (fabs(sqrt((i*i)+(j*j)+(k*k)) - 1.0) > IPP_NORMAL_ERROR)
    _errorCode = FIRST_VECTOR_NOT_NORMALIZED;
  if ((_errorCode == CHECKER_OK) && (theAlign->getHas2()))
  {
    i = theAlign->getVector2i();
    j = theAlign->getVector2j();
    k = theAlign->getVector2k();
    if (fabs(sqrt((i*i)+(j*j)+(k*k)) - 1.0) > IPP_NORMAL_ERROR)
      _errorCode = SECOND_VECTOR_NOT_NORMALIZED;
  }
  if ((_errorCode == CHECKER_OK) && (!(_world->getIsHomed())))
    _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;
}

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

/* ippCommandCheckerBase:: checkCenterPart 4

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules:
  1.The system must be homed (see p. 48)
  NOT_HOMED_CAN_NOT_EXECUTE_COMMAND

  Reference pages: 24 27 (96) 102
        
*/

void ippCommandChecker::checkCenterPart( ippCommandConstPtr aCommand)
{
  if (!_world->getIsHomed()) {
    _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;
  }
}

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

/* ippCommandChecker::checkChangeTool 5

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules:
  1. The name of the tool must not be "UnDefTool".
  CAN_NOT_CHANGE_TOOL_TO_UNDEFTOOL
  2. The tool must be one of the tools known to the toolchanger.
  UNKNOWN_TOOL

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

  Rule 2 above is not explicit in the spec, but seems implicit. It also
  seems implicit that it should be possible to change to "NoTool",
  "BaseTool" or "RefTool". Rule 2 is a semantic check.

  This is not currently requiring that the machine be homed, since it may
  be possible to change tools without moving the machine on some machines.
            
*/

void ippCommandChecker::checkChangeTool( ippCommandConstPtr aCommand)
{
  const ippChangeToolCommand * theChange = static_cast<const ippChangeToolCommand *>(aCommand.get());

  if (strcmp("UnDefTool", theChange->getToolName()) == 0) {
    _errorCode = CAN_NOT_CHANGE_TOOL_TO_UNDEFTOOL;
  } else if (_world->getTools()->findTool(theChange->getToolName()).get() == NULL) {
    _errorCode = UNKNOWN_TOOL;
  } 
}

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

/* ippCommandChecker::checkClearAllErrors 6

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

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

void ippCommandChecker::checkClearAllErrors( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkDisableUser 7

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

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

*/

void ippCommandChecker::checkDisableUser( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkEnableUser 8

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

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

void ippCommandChecker::checkEnableUser( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkEndSession 9

    Returned Value: None.

    Called By: ippCommandChecker::checkCommand

    Rules: None.

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

void ippCommandChecker::checkEndSession( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkEnumAllProp 10

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  The parser requires that the argument have one of the following patterns.
  key1()
  key1.key2()
  key1.key2.key3()
  key1.key2.key3.key4()
  where key1 must be FoundTool or Tool and key2 must be GoToPar or PtMeasPar.

  Rules:
  1. If the value found by key1 is UnDefTool, there must be no key2.
  CAN_NOT_ENUMALLPROP_UNDEFTOOL_PTMEASPAR
  CAN_NOT_ENUMALLPROP_UNDEFTOOL_GOTOPAR
  2. If the value found by key1 is NoTool, key2 must not be PtMeasPar.
  CAN_NOT_ENUMALLPROP_NOTOOL_PTMEASPAR

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

  These rules are not explicit in the spec, but seem implicit. The rules
  are consistent with the rules for EnumProp, GetProp, and GetPropE.
            
*/
typedef boost::intrusive_ptr<ippEnumAllPropCommand> ippEnumAllPropCommandPtr;
typedef boost::intrusive_ptr<const ippEnumAllPropCommand> ippEnumAllPropCommandConstPtr;

void ippCommandChecker::checkEnumAllProp(ippCommandConstPtr aCommand)
{
  const ippEnumAllPropCommand* theEnum =
     static_cast<const ippEnumAllPropCommand*>(aCommand.get());

  ippKToolPtr theTool;
  
  if (theEnum->getProp().getKey1() == Tool){                  
    theTool = _world->getTools()->getActiveTool();

  } else if (theEnum->getProp().getKey1() == FoundTool) {
    theTool = _world->getTools()->getFoundTool();
  } else{  // should never happen
    theTool = NULL;
  }
  if (theTool && (theTool == _world->getTools()->getUnDefTool()))
  {
    if (theEnum->getProp().getNumberKeys() > 1)
    {
      if (theEnum->getProp().getKey2() == PtMeasPar)
        _errorCode = CAN_NOT_ENUMALLPROP_UNDEFTOOL_PTMEASPAR;
      else // if (theEnum->getKey2() == GoToPar)
        _errorCode = CAN_NOT_ENUMALLPROP_UNDEFTOOL_GOTOPAR;
    }
  }
  else if (theTool && (theTool == _world->getTools()->getNoTool()))
  {
    if ((theEnum->getProp().getNumberKeys() > 1) && (theEnum->getProp().getKey2() == PtMeasPar))
      _errorCode = CAN_NOT_ENUMALLPROP_NOTOOL_PTMEASPAR;
  }
}

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

/* ippCommandChecker::checkEnumProp 11

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
    The parser requires that the argument have one of the following patterns.
    key1()
    key1.key2()
    key1.key2.key3()
    key1.key2.key3.key4()
    where key1 must be FoundTool or Tool and key2 must be GoToPar or PtMeasPar.

    Rules:
    1. If the value found by key1 is UnDefTool, there must be no key2.
    CAN_NOT_ENUMPROP_UNDEFTOOL_PTMEASPAR
    CAN_NOT_ENUMPROP_UNDEFTOOL_GOTOPAR
    2. If the value found by key1 is NoTool, key2 must not be PtMeasPar.
    CAN_NOT_ENUMPROP_NOTOOL_PTMEASPAR

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

    These rules are not explicit in the spec, but seem implicit. The rules
    are consistent with the rules for EnumAllProp, GetProp, and GetPropE.
            
*/

void ippCommandChecker::checkEnumProp( ippCommandConstPtr aCommand)
{
  const ippEnumPropCommand * theEnum= (const ippEnumPropCommand *)aCommand.get();
  
  ippKToolConstPtr theTool;
  
  const ippProp& prop = theEnum->getProp();

  if (prop.getKey1() == Tool) {
    theTool = _world->getTools()->getActiveTool();

  } else if (prop.getKey1() == FoundTool) {
    theTool = _world->getTools()->getFoundTool();
  } else {
    theTool = NULL;
  
  }

  if (theTool && (theTool == _world->getTools()->getUnDefTool()))
  {
    if (prop.getNumberKeys() > 1)
    {
      if (prop.getKey2() == PtMeasPar) {
        _errorCode = CAN_NOT_ENUMPROP_UNDEFTOOL_PTMEASPAR;
      }  else  { // if (theEnum->getKey2() == GoToPar)
        _errorCode = CAN_NOT_ENUMPROP_UNDEFTOOL_GOTOPAR;
      }
    }
  } else if (theTool && (theTool == _world->getTools()->getNoTool()))  {
    if ((prop.getNumberKeys() > 1) && (prop.getKey2() == PtMeasPar)) {
      _errorCode = CAN_NOT_ENUMPROP_NOTOOL_PTMEASPAR;
    }
  }
}

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

/* ippCommandChecker::checkEnumTools 12

  Returned Value: None.
  
  Called By: ippCommandChecker::checkCommand

  Rules: None.

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

void ippCommandChecker::checkEnumTools( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkFindTool 13

  Returned Value: None.
  
  Called By: ippCommandChecker::checkCommand

  Rules: None.

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

  ipp1.4 This (unlike checkChangeTool) is allowing "UnDefTool". Thus, FoundTool
  can be UnDefTool. It might be better to make this illegal.

  ipp1.5 Has this changed ?

*/

void ippCommandChecker::checkFindTool( ippCommandConstPtr aCommand)
{
 // Etienne doesn't know if this test would be valid : 
 //xx const ippFindToolCommand * theFind = static_cast<const ippFindToolCommand *>(aCommand.get());
 //xx if (strcmp("UnDefTool", theFind->getToolName()) == 0) {
 //xx   _errorCode = CAN_NOT_CHANGE_TOOL_TO_UNDEFTOOL;
 //xx }  
}

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

/* ippCommandChecker::checkGet 14

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None

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

void ippCommandChecker::checkGet( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandCheckerBase:: checkGetChangeToolAction 15

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules:
  1. The name of the tool must not be "UnDefTool".
  CAN_NOT_CHANGE_TOOL_TO_UNDEFTOOL
  2. The tool must be one of the tools known to the toolchanger.
  UNKNOWN_TOOL

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

void ippCommandChecker::checkGetChangeToolAction( ippCommandConstPtr aCommand)
{
  const ippGetChangeToolActionCommand* theChangeAction = 
      static_cast<const ippGetChangeToolActionCommand*>(aCommand.get());

  if (strcmp("UnDefTool", theChangeAction->getToolName()) == 0){
    
    _errorCode = CAN_NOT_CHANGE_TOOL_TO_UNDEFTOOL;

  } else if (_world->getTools()->findTool(theChangeAction->getToolName()).get()== NULL){
    
    _errorCode = UNKNOWN_TOOL;

  }
}

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

/* ippCommandChecker::checkGetCoordSystem 16

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

  Reference pages: 24 28 (59) 103
        
*/

void ippCommandChecker::checkGetCoordSystem( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkGetCsyTransformation 17

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

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

void ippCommandChecker::checkGetCsyTransformation( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandCheckerBase:: checkGetDMEVersion 18

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

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

void ippCommandChecker::checkGetDMEVersion( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkGetErrorInfo 19

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules:
  1. The error number must be an allowed error number.
  BAD_ERROR_NUMBER

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

  The range 8000-9999 is provided for server-defined and client-defined
  errors, as given on page 75, but it is not clear how such error numbers
  are to be defined.

  Rule 1 is a semantic check.

*/

void ippCommandChecker::checkGetErrorInfo(ippCommandConstPtr aCommand)
{
  const ippGetErrorInfoCommand* theGetErrorInfo = 
    static_cast<const  ippGetErrorInfoCommand*>(aCommand.get());

  int error_number = theGetErrorInfo->getErrorNumber().asInteger();

  if (((error_number >=    0) && (error_number <=    8)) ||
    ((error_number >=  500) && (error_number <=  515)) ||
    ((error_number >= 1000) && (error_number <= 1010)) ||
    ((error_number >= 1500) && (error_number <= 1503)) ||
    ((error_number >= 2000) && (error_number <= 2002)) ||
    ((error_number >= 2500) && (error_number <= 2506)) ||
    ((error_number >= 8000) && (error_number <= 9999)));
  else
    _errorCode = BAD_ERROR_NUMBER;
}

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

/* ippCommandChecker::checkGetErrStatusE 20

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

  Reference pages: 24 27 (50) 102
        
*/

void ippCommandChecker::checkGetErrStatusE( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkGetMachineClass 21

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

  Reference pages: 18 24 27 (50) 102
        
*/

void ippCommandChecker::checkGetMachineClass( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkGetProp 22

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: 
  1. Properties of UnDefTool cannot be gotten by GetProp.
  CAN_NOT_GETPROP_UNDEFTOOL
  2. PtMeas parameters of NoTool cannot be gotten by GetProp.
  CAN_NOT_GETPROP_PTMEASPARS_OF_NOTOOL

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

  These rules are not explicit in the spec, but seem implicit. The rules
  are consistent with the rules for EnumAllProp, EnumProp, and GetPropE.

*/

void ippCommandChecker::checkGetProp( ippCommandConstPtr aCommand)
{
  const ippGetPropCommand* theGetProp  = 
   static_cast<const ippGetPropCommand*>(aCommand.get());
  

  ippKToolConstPtr theTool;
  int n;
  
  for (n = 0; ((_errorCode == CHECKER_OK) && (n < theGetProp->getNumberProps())); n++)
  {
    const ippProp& prop = theGetProp->getProp(n);

    if (theGetProp->getProp(n).getKey1() == Tool) {
      theTool = _world->getTools()->getActiveTool();

    } else if (theGetProp->getProp(n).getKey1() == FoundTool) {
      theTool = _world->getTools()->getFoundTool();

    } else { 
      theTool = NULL;
    }
    if (theTool && (theTool == _world->getTools()->getUnDefTool())) {
      _errorCode = CAN_NOT_GETPROP_UNDEFTOOL;

    } else if (theTool && (theGetProp->getProp(n).getKey2() == PtMeasPar) &&
      (theTool == _world->getTools()->getNoTool())) {
        _errorCode = CAN_NOT_GETPROP_PTMEASPARS_OF_NOTOOL;
    }
  }
}

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

/* ippCommandChecker::checkGetPropE 23

    Returned Value: None.

    Called By: ippCommandChecker::checkCommand

    Rules:
    1. Properties of UnDefTool cannot be gotten by GetPropE.
    CAN_NOT_GETPROPE_UNDEFTOOL
    2. PtMeas parameters of NoTool cannot be gotten by GetPropE.
    CAN_NOT_GETPROPE_PTMEASPARS_OF_NOTOOL

    Reference pages: 24 26 29 (45) 99 108

    These rules are not explicit in the spec, but seem implicit. The rules
    are consistent with the rules for EnumAllProp, EnumProp, and GetProp.
          
*/

void ippCommandChecker::checkGetPropE( ippCommandConstPtr aCommand)
{
  const ippGetPropECommand * theGetPropE = 
    static_cast<const ippGetPropECommand*>(aCommand.get());

  ippKToolConstPtr theTool;
  int n;
  
  for (n = 0;
  ((_errorCode == CHECKER_OK) && (n < theGetPropE->getNumberProps()));
  n++)
  {
    if (theGetPropE->getProp(n).getKey1() == Tool) {
      theTool = _world->getTools()->getActiveTool();
    }  else if (theGetPropE->getProp(n).getKey1() == FoundTool){
      theTool = _world->getTools()->getFoundTool();
    } else{
      theTool = NULL;
    }

    if (theTool && (theTool == _world->getTools()->getUnDefTool())){
      _errorCode = CAN_NOT_GETPROPE_UNDEFTOOL;
    } else if (theTool && (theGetPropE->getProp(n).getKey2() == PtMeasPar) && 
      (theTool == _world->getTools()->getNoTool())) {
      _errorCode = CAN_NOT_GETPROPE_PTMEASPARS_OF_NOTOOL;
    }
  }
}

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

/* ippCommandChecker::checkGetXtdErrStatus 24

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

  Reference pages: 24 27 (50) 102

*/

void ippCommandChecker::checkGetXtdErrStatus( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkGoTo 25

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules:
  1. The system must be homed (see page 48).
  NOT_HOMED_CAN_NOT_EXECUTE_COMMAND
  2. The active tool must not be UnDefTool.
  CAN_NOT_GOTO_USING_UNDEFTOOL
  3. The target point must be inside the work volume of the machine.
  TARGET_POINT_OUT_OF_WORK_VOLUME

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

void ippCommandChecker::checkGoTo( ippCommandConstPtr aCommand)
{
  const ippGoToCommand * theGoTo = static_cast<const ippGoToCommand*>(aCommand.get());

  if (!(_world->getIsHomed())) {
    _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;

  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getUnDefTool()){
     _errorCode = CAN_NOT_GOTO_USING_UNDEFTOOL;
  } else if (!(_world->inWorkVolume
    ((theGoTo->getHasX() ? theGoTo->getX() : _world->getCurrentX()),
    (theGoTo->getHasY() ? theGoTo->getY() : _world->getCurrentY()),
    (theGoTo->getHasZ() ? theGoTo->getZ() : _world->getCurrentZ())))) {
      _errorCode = TARGET_POINT_OUT_OF_WORK_VOLUME;
    }
}

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

/* ippCommandChecker::checkHome 26

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

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

void ippCommandChecker::checkHome( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkIsHomed 27

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

  Reference pages: 24 27 (48) 102 111
        
*/

void ippCommandChecker::checkIsHomed( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkIsUserEnabled 28

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

  Reference pages: 24 27 (49) 102
        
*/

void ippCommandChecker::checkIsUserEnabled( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandCheckerBase:: checkLockAxis 29

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

  Reference pages: 24 (97-98)
        
*/

void ippCommandChecker::checkLockAxis( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkOnMoveReportE 30

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules:
  1. If Time is included, the interval must not be less than 0.1.
  TIME_ARGUMENT_MUST_NOT_BE_LESS_THAN_A_TENTH
  2. If Dis is included, the interval must be positive.
  DIS_ARGUMENT_MUST_BE_POSITIVE
  3. An OnMoveReportE daemon must not already exist.
  MUST_STOP_EXISTING_DAEMON_BEFORE_STARTING_ANOTHER

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

  Rules 1 and 2 are semantic checks.
          
*/

void ippCommandChecker::checkOnMoveReportE( ippCommandConstPtr aCommand)
{
  const ippOnMoveReportECommand* theOn =
    static_cast<const ippOnMoveReportECommand*>(aCommand.get());
  
  if (theOn->getHasTime() && (theOn->getTheTime() < 0.1)) {
    _errorCode = TIME_ARGUMENT_MUST_NOT_BE_LESS_THAN_A_TENTH;
  } else if (theOn->getHasDis() && (theOn->getTheDis() <= 0)) {
    _errorCode = DIS_ARGUMENT_MUST_BE_POSITIVE;
  } else if (_world->daemonCount() != 0) {
    _errorCode = MUST_STOP_EXISTING_DAEMON_BEFORE_STARTING_ANOTHER;
  }
}

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

/* ippCommandChecker::checkOnPtMeasReport 31

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: None.

  Reference pages: 24 27 (41) (49) (52) (53) 61 [71] [72] (78) 102
        
*/

void ippCommandChecker::checkOnPtMeasReport( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkOnScanReport 32

    Returned Value: None.

    Called By: ippCommandChecker::checkCommand

    Rules: None.

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

void ippCommandChecker::checkOnScanReport( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkPtMeas 33

  
*/

//=============================================================================
void ippCommandChecker::checkPtMeas( ippCommandConstPtr aCommand)

// Returned Value: None.
//
// Called By: ippCommandChecker::checkCommand
//
// Rules:
// 1. If there is an IJK vector, its length must not be zero.
//    DIRECTION_VECTOR_HAS_ZERO_LENGTH
// 2. The system must be homed (see p. 48).
//    NOT_HOMED_CAN_NOT_EXECUTE_COMMAND
// 3. The target point must be inside the work volume of the machine.
//    TARGET_POINT_OUT_OF_WORK_VOLUME
// 4. The active tool must be an actual tool.
//    CAN_NOT_PTMEAS_USING_UNDEFTOOL
//    CAN_NOT_PTMEAS_USING_NOTOOL
//
//  Reference pages: 9 24 27 (41) (49) (52 - 53) (62) [71] [72] (78) 83 84 86
//                 87 89 90 91 102
{
  ippPtMeasCommandConstPtr thePtMeas =  boost::static_pointer_cast<const ippPtMeasCommand>(aCommand);
  
  if (!(_world->getIsHomed())) {
    
    _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;
    
  }  else if ((thePtMeas->getHasIJK()) && (thePtMeas->getI() == 0) && (thePtMeas->getJ() == 0) && (thePtMeas->getK() == 0)) {
    
    _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;
    
  } else if (!(_world->inWorkVolume(
    (thePtMeas->getHasX() ? thePtMeas->getX() : _world->getCurrentX()),
    (thePtMeas->getHasY() ? thePtMeas->getY() : _world->getCurrentY()),
    (thePtMeas->getHasZ() ? thePtMeas->getZ() : _world->getCurrentZ()))))
  {
    _errorCode = TARGET_POINT_OUT_OF_WORK_VOLUME;
    
    
  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getUnDefTool()) {
    
    _errorCode = CAN_NOT_PTMEAS_USING_UNDEFTOOL;
    
  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getNoTool()) {
    
    _errorCode = CAN_NOT_PTMEAS_USING_NOTOOL;
  }
}

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

/* ippCommandChecker::checkReQualify 34

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules:
  1. The system must be homed (see p. 48).
  NOT_HOMED_CAN_NOT_EXECUTE_COMMAND
  2. The current tool must not be UnDefTool.
  CAN_NOT_REQUALIFY_UNDEFTOOL
  3. The current tool must not be NoTool.
  CAN_NOT_REQUALIFY_NOTOOL

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

  Rules 2 and 3 are not explicit in the spec, but it seems prudent not
  to attempt to qualify a non-existent tool or a tool whose identity and
  existence are unknown.

  It might be good to add not allowing Requalify when the tool is BaseTool,
  since that does not seem to be an actual tool.
            
*/

void ippCommandChecker::checkReQualify( ippCommandConstPtr aCommand)
{
  if (!(_world->getIsHomed()))
    _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;
  else if (_world->getTools()->getActiveTool() ==
           _world->getTools()->getUnDefTool())
     _errorCode = CAN_NOT_REQUALIFY_UNDEFTOOL;
  else if (_world->getTools()->getActiveTool() ==
           _world->getTools()->getNoTool())
     _errorCode = CAN_NOT_REQUALIFY_NOTOOL;
}

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

/* ippCommandChecker::checkScanInCylEndIsPlane 35

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules:
  1. The system must be homed (see p. 48).
  NOT_HOMED_CAN_NOT_EXECUTE_COMMAND
  2. The active tool must be an actual tool.
  CAN_NOT_SCAN_USING_UNDEFTOOL
  CAN_NOT_SCAN_USING_NOTOOL
  3. The direction vector of the axis of the cylinder must not have length 0.
  DIRECTION_VECTOR_HAS_ZERO_LENGTH
  4. The direction vector at the start point must not have length 0.
  DIRECTION_VECTOR_HAS_ZERO_LENGTH
  5. The direction vector of the stop plane must not have length 0.
  DIRECTION_VECTOR_HAS_ZERO_LENGTH
  6. The direction vector at the end point must not have length 0.
  DIRECTION_VECTOR_HAS_ZERO_LENGTH
  7. The start point must be in the work volume.
  SCAN_POINT_MUST_BE_IN_WORK_VOLUME
  8. The direction point must be in the work volume.
  SCAN_POINT_MUST_BE_IN_WORK_VOLUME
  9. The start point must differ from the direction point.
  START_POINT_MUST_DIFFER_FROM_DIRECTION_POINT
  10. The start point must not be on the cylinder axis.
  START_POINT_MUST_NOT_BE_ON_CYLINDER_AXIS

  Reference pages: 24 27 (90 - 91) 103

  Rules 3 - 6 are semantic checks.

  Rule 10 is explicit on page 91. The check is made by checking that the
  absolute value of the cosine of the angle between [the axis vector] and
  [the vector from the axis point to the start point] is less than one
  (actually, less than 0.9999, to account for rounding error).

*/

void ippCommandChecker::checkScanInCylEndIsPlane( ippCommandConstPtr aCommand)
{
  const ippScanInCylEndIsPlaneCommand * theScan = 
    static_cast<const ippScanInCylEndIsPlaneCommand*>(aCommand.get());

  double ci = theScan->getCI();
  double cj = theScan->getCJ();
  double ck = theScan->getCK();
  double vi = (theScan->getSx() - theScan->getCx());
  double vj = (theScan->getSy() - theScan->getCy());
  double vk = (theScan->getSz() - theScan->getCz());

  double lengthc = sqrt((ci * ci) + (cj * cj) + (ck * ck));
  double lengthv = sqrt((vi * vi) + (vj * vj) + (vk * vk));

  if (!(_world->getIsHomed())) {
    _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;

  } else if (_world->getTools()->getActiveTool() ==  _world->getTools()->getUnDefTool()) {
     _errorCode = CAN_NOT_SCAN_USING_UNDEFTOOL;

  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getNoTool()) {
     _errorCode = CAN_NOT_SCAN_USING_NOTOOL;

  }  else if (lengthc == 0) {
    _errorCode = AXIS_DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  }  else if ((theScan->getSI() == 0) && (theScan->getSJ() == 0) && (theScan->getSK() == 0)) {
     _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  }  else if ((theScan->getPI() == 0) && (theScan->getPJ() == 0) &&  (theScan->getPK() == 0)){
    _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  }  else if ((theScan->getEI() == 0) && (theScan->getEJ() == 0) &&  (theScan->getEK() == 0)) {
     _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  }  else if (!(_world->inWorkVolume(theScan->getSx(), theScan->getSy(), theScan->getSz()))) {
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;

  }  else if (!(_world->inWorkVolume(theScan->getDx(), theScan->getDy(), theScan->getDz()))) {
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;

  } else if ((theScan->getSx() == theScan->getDx()) && (theScan->getSy() == theScan->getDy()) &&  (theScan->getSz() == theScan->getDz())) {
     _errorCode = START_POINT_MUST_DIFFER_FROM_DIRECTION_POINT;

  }  else if ((lengthv == 0) ||  (fabs((((ci * vi) + (cj * vj) + (ck * vk)) / lengthc) / lengthv) > 0.9999)) {
      _errorCode = START_POINT_MUST_NOT_BE_ON_CYLINDER_AXIS;
  }
}

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

/* ippCommandChecker::checkScanInCylEndIsSphere 36

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules: 
  1. The system must be homed (see p. 48).
  NOT_HOMED_CAN_NOT_EXECUTE_COMMAND
  2. The active tool must be an actual tool.
  CAN_NOT_SCAN_USING_UNDEFTOOL
  CAN_NOT_SCAN_USING_NOTOOL
  3. The direction vector of the axis of the cylinder must not have length 0.
  DIRECTION_VECTOR_HAS_ZERO_LENGTH
  4. The direction vector at the start point must not have length 0.
  DIRECTION_VECTOR_HAS_ZERO_LENGTH
  5. The direction vector at the end point must not have length 0.
  DIRECTION_VECTOR_HAS_ZERO_LENGTH
  6. The start point must be in the work volume.
  SCAN_POINT_MUST_BE_IN_WORK_VOLUME
  7. The direction point must be in the work volume.
  SCAN_POINT_MUST_BE_IN_WORK_VOLUME
  8. The start point must differ from the direction point.
  START_POINT_MUST_DIFFER_FROM_DIRECTION_POINT
  9. The start point must not be on the cylinder axis.
  START_POINT_MUST_NOT_BE_ON_CYLINDER_AXIS

  Reference pages: 24 27 (89 - 90) 103

  Rules 3 - 5 are semantic checks.

  Rule 9 is explicit on page 90. The check is made by checking that the
  absolute value of the cosine of the angle between [the axis vector] and
  [the vector from the axis point to the start point] is less than one
  (actually, less than 0.9999, to account for rounding error).

*/

void ippCommandChecker::checkScanInCylEndIsSphere( ippCommandConstPtr aCommand)
{
  const ippScanInCylEndIsSphereCommand * theScan =
    static_cast<const ippScanInCylEndIsSphereCommand*>(aCommand.get());

  double ci = theScan->getCI();
  double cj = theScan->getCJ();
  double ck = theScan->getCK();
  double vi = (theScan->getSx() - theScan->getCx());
  double vj = (theScan->getSy() - theScan->getCy());
  double vk = (theScan->getSz() - theScan->getCz());
  double lengthc = sqrt((ci * ci) + (cj * cj) + (ck * ck));
  double lengthv = sqrt((vi * vi) + (vj * vj) + (vk * vk));

  if (!(_world->getIsHomed())) {
    _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;

  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getUnDefTool()) {
     _errorCode = CAN_NOT_SCAN_USING_UNDEFTOOL;

  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getNoTool()) {
     _errorCode = CAN_NOT_SCAN_USING_NOTOOL;

  } else if (lengthc == 0) {
    _errorCode = AXIS_DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  } else if ((theScan->getSI() == 0) &&  (theScan->getSJ() == 0) && (theScan->getSK() == 0)){
     _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  } else if ((theScan->getEI() == 0) &&(theScan->getEJ() == 0) && (theScan->getEK() == 0)) {
     _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  } else if (!(_world->inWorkVolume(theScan->getSx(), theScan->getSy(), theScan->getSz()))) {
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;

  } else if (!(_world->inWorkVolume (theScan->getDx(), theScan->getDy(), theScan->getDz()))) {
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;

  } else if ((theScan->getSx() == theScan->getDx()) &&(theScan->getSy() == theScan->getDy()) && (theScan->getSz() == theScan->getDz())){
     _errorCode = START_POINT_MUST_DIFFER_FROM_DIRECTION_POINT;

  } else if ((lengthv == 0) ||(fabs((((ci * vi) + (cj * vj) + (ck * vk)) / lengthc) / lengthv)> 0.9999)) {
     _errorCode = START_POINT_MUST_NOT_BE_ON_CYLINDER_AXIS;
  }
}

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

/* ippCommandChecker::checkScanInPlaneEndIsCyl 37

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules:
      1. The system must be homed (see p. 48).
      NOT_HOMED_CAN_NOT_EXECUTE_COMMAND
      2. The active tool must be an actual tool.
      CAN_NOT_SCAN_USING_UNDEFTOOL
      CAN_NOT_SCAN_USING_NOTOOL
      3. The direction vector of the axis of the cylinder must not have length 0.
      AXIS_DIRECTION_VECTOR_HAS_ZERO_LENGTH
      4. The direction vector at the start point must not have length 0.
      DIRECTION_VECTOR_HAS_ZERO_LENGTH
      5. The direction vector at the end point must not have length 0.
      DIRECTION_VECTOR_HAS_ZERO_LENGTH
      6. The start point must be in the work volume.
      SCAN_POINT_MUST_BE_IN_WORK_VOLUME
      7. The direction point must be in the work volume.
      SCAN_POINT_MUST_BE_IN_WORK_VOLUME
      8. The start point must differ from the direction point.
      START_POINT_MUST_DIFFER_FROM_DIRECTION_POINT
      
        Reference pages: 24 27 (88 - 89) 103
        
*/

void ippCommandChecker::checkScanInPlaneEndIsCyl( ippCommandConstPtr aCommand)
{
  const ippScanInPlaneEndIsCylCommand * theScan = 
    static_cast<const ippScanInPlaneEndIsCylCommand*>(aCommand.get());
  
  if (!(_world->getIsHomed())) {
    _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;

  }  else if (_world->getTools()->getActiveTool() ==  _world->getTools()->getUnDefTool()){
     _errorCode = CAN_NOT_SCAN_USING_UNDEFTOOL;

  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getNoTool()){
     _errorCode = CAN_NOT_SCAN_USING_NOTOOL;

  }  else if ((theScan->getCI() == 0) && (theScan->getCJ() == 0) && (theScan->getCK() == 0)){
     _errorCode = AXIS_DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  } else if ((theScan->getSI() == 0) && (theScan->getSJ() == 0) && (theScan->getSK() == 0)) {
    _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;


  } else if ((theScan->getEI() == 0) &&  (theScan->getEJ() == 0) && (theScan->getEK() == 0)){
     _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  } else if (!(_world->inWorkVolume(theScan->getSx(), theScan->getSy(), theScan->getSz()))){
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;

  } else if (!(_world->inWorkVolume(theScan->getDx(), theScan->getDy(), theScan->getDz()))){
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;
  
  }else if ((theScan->getSx() == theScan->getDx()) &&(theScan->getSy() == theScan->getDy()) && (theScan->getSz() == theScan->getDz())){
     _errorCode = START_POINT_MUST_DIFFER_FROM_DIRECTION_POINT;

  }
}

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

/* ippCommandChecker::checkScanInPlaneEndIsPlane 38

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules:
      1. The system must be homed (see p. 48).
      NOT_HOMED_CAN_NOT_EXECUTE_COMMAND
      2. The active tool must be an actual tool.
      CAN_NOT_SCAN_USING_UNDEFTOOL
      CAN_NOT_SCAN_USING_NOTOOL
      3. The direction vector at the start point must not have length 0.
      DIRECTION_VECTOR_HAS_ZERO_LENGTH
      4. The direction vector of the stop plane must not have length 0.
      DIRECTION_VECTOR_HAS_ZERO_LENGTH
      5. The direction vector at the end point must not have length 0.
      DIRECTION_VECTOR_HAS_ZERO_LENGTH
      6. The start point must be in the work volume.
      SCAN_POINT_MUST_BE_IN_WORK_VOLUME
      7. The direction point must be in the work volume.
      SCAN_POINT_MUST_BE_IN_WORK_VOLUME
      8. The start point must differ from the direction point.
      START_POINT_MUST_DIFFER_FROM_DIRECTION_POINT
      
        Reference pages: 24 27 (86 - 87) 103
        
*/

void ippCommandChecker::checkScanInPlaneEndIsPlane( ippCommandConstPtr aCommand)
{
  const ippScanInPlaneEndIsPlaneCommand* theScan= 
    static_cast<const ippScanInPlaneEndIsPlaneCommand*>(aCommand.get());

  
  if (!(_world->getIsHomed())) {
   _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;

  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getUnDefTool()) {
   _errorCode = CAN_NOT_SCAN_USING_UNDEFTOOL;

  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getNoTool()){
   _errorCode = CAN_NOT_SCAN_USING_NOTOOL;
  
  } else if ((theScan->getSI() == 0) &&(theScan->getSJ() == 0) && (theScan->getSK() == 0)){
   _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  }else if ((theScan->getPI() == 0) && (theScan->getPJ() == 0) &&(theScan->getPK() == 0)) {
    _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  } else if ((theScan->getEI() == 0) &&(theScan->getEJ() == 0) &&(theScan->getEK() == 0)) {
    _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  } else if (!(_world->inWorkVolume(theScan->getSx(), theScan->getSy(), theScan->getSz()))){
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;

  } else if (!(_world->inWorkVolume(theScan->getDx(), theScan->getDy(), theScan->getDz()))){
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;

  } else if ((theScan->getSx() == theScan->getDx()) &&(theScan->getSy() == theScan->getDy()) && (theScan->getSz() == theScan->getDz())) {
     _errorCode = START_POINT_MUST_DIFFER_FROM_DIRECTION_POINT;

  }
}

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

/* ippCommandChecker::checkScanInPlaneEndIsSphere 39

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules:
      1. The system must be homed (see p. 48).
      NOT_HOMED_CAN_NOT_EXECUTE_COMMAND
      2. The active tool must be an actual tool.
      CAN_NOT_SCAN_USING_UNDEFTOOL
      CAN_NOT_SCAN_USING_NOTOOL
      3. The direction vector at the start point must not have length 0.
      DIRECTION_VECTOR_HAS_ZERO_LENGTH
      4.The direction vector at the end point must not have length 0.
      DIRECTION_VECTOR_HAS_ZERO_LENGTH
      5. The start point must be in the work volume.
      SCAN_POINT_MUST_BE_IN_WORK_VOLUME
      6. The end point must be in the work volume.
      SCAN_POINT_MUST_BE_IN_WORK_VOLUME
      7. The direction point must be in the work volume.
      SCAN_POINT_MUST_BE_IN_WORK_VOLUME
      8. The start point must differ from the direction point
      START_POINT_MUST_DIFFER_FROM_DIRECTION_POINT
      
        Reference pages: 24 27 (85 - 86) [94] 103
        
*/

void ippCommandChecker::checkScanInPlaneEndIsSphere( ippCommandConstPtr aCommand)
{
  const ippScanInPlaneEndIsSphereCommand * theScan = 
    static_cast<const ippScanInPlaneEndIsSphereCommand*>(aCommand.get());
  
  if (!(_world->getIsHomed()))  {
    _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;
  
  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getUnDefTool()){
     _errorCode = CAN_NOT_SCAN_USING_UNDEFTOOL;

  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getNoTool()){
     _errorCode = CAN_NOT_SCAN_USING_NOTOOL;

  } else if ((theScan->getSI() == 0) && (theScan->getSJ() == 0) && (theScan->getSK() == 0)) {
    _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;
  
  } else if ((theScan->getEI() == 0) && (theScan->getEJ() == 0) && (theScan->getEK() == 0)){
     _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;
  
  } else if (!(_world->inWorkVolume(theScan->getSx(), theScan->getSy(), theScan->getSz()))){
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;

  } else if (!(_world->inWorkVolume(theScan->getDx(), theScan->getDy(), theScan->getDz()))){
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;
  
  } else if (!(_world->inWorkVolume(theScan->getEx(), theScan->getEy(), theScan->getEz()))){
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;

  } else if ((theScan->getSx() == theScan->getDx()) && (theScan->getSy() == theScan->getDy()) && (theScan->getSz() == theScan->getDz())){
     _errorCode = START_POINT_MUST_DIFFER_FROM_DIRECTION_POINT;

  }
}

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

/* ippCommandChecker::checkScanOnCircle 40

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules:
      1. The system must be homed (see p. 48).
      NOT_HOMED_CAN_NOT_EXECUTE_COMMAND
      2. The active tool must be an actual tool.
      CAN_NOT_SCAN_USING_UNDEFTOOL
      CAN_NOT_SCAN_USING_NOTOOL
      3. The direction vector of the axis of the circle must not have length 0.
      DIRECTION_VECTOR_HAS_ZERO_LENGTH
      4. The radius of the circle must not have length 0.
      RADIUS_MUST_HAVE_POSITIVE_LENGTH
      5. The radius of the circle must be perpendicular to its normal
      RADIUS_MUST_BE_PERPENDICULAR_TO_NORMAL
      6. The start point must be in the work volume.
      SCAN_POINT_MUST_BE_IN_WORK_VOLUME
      
        Reference pages: 24 27 (82 - 83) [93] 103
        
          It would be useful to add:
          5. end point in work volume
          
*/

void ippCommandChecker::checkScanOnCircle( ippCommandConstPtr aCommand)
{
  const ippScanOnCircleCommand * theScan = 
    static_cast<const ippScanOnCircleCommand *>(aCommand.get());

  double i = theScan->getI();
  double j = theScan->getJ();
  double k = theScan->getK();
  double norml = sqrt((i * i) + (j * j) + (k * k));
  double radx = (theScan->getSx() - theScan->getCx());
  double rady = (theScan->getSy() - theScan->getCy());
  double radz = (theScan->getSz() - theScan->getCz());
  double radl = sqrt((radx * radx) + (rady * rady) + (radz * radz));
  
  if (!(_world->getIsHomed())) {
    _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;

  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getUnDefTool()){
     _errorCode = CAN_NOT_SCAN_USING_UNDEFTOOL;

  }  else if (_world->getTools()->getActiveTool() == _world->getTools()->getNoTool()) {
     _errorCode = CAN_NOT_SCAN_USING_NOTOOL;

  }  else if (norml == 0) {
    _errorCode = DIRECTION_VECTOR_HAS_ZERO_LENGTH;

  } else if (radl == 0) {
    _errorCode = RADIUS_MUST_HAVE_POSITIVE_LENGTH;

  }  else if (fabs(((i * radx) + (j * rady) + (k * radz)) / (norml * radl)) > IPP_NORMAL_ERROR) {
    _errorCode = RADIUS_MUST_BE_PERPENDICULAR_TO_NORMAL;

  }  else if (!(_world->inWorkVolume(theScan->getSx(), theScan->getSy(), theScan->getSz()))) {
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;

  }
}

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

/* ippCommandChecker::checkScanOnCircleHint 41

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules: None
      
        Reference pages: 24 27 (82) [93] 103
        
*/

void ippCommandChecker::checkScanOnCircleHint( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkScanOnLine 42

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules:
      1. The system must be homed (see p. 48).
      NOT_HOMED_CAN_NOT_EXECUTE_COMMAND
      2. The active tool must be an actual tool.
      CAN_NOT_SCAN_USING_UNDEFTOOL
      CAN_NOT_SCAN_USING_NOTOOL
      3. The start point must differ from the end point.
      START_POINT_MUST_DIFFER_FROM_END_POINT
      4. The start point must be in the work volume.
      SCAN_POINT_MUST_BE_IN_WORK_VOLUME
      5. The end point must be in the work volume.
      SCAN_POINT_MUST_BE_IN_WORK_VOLUME
      
        Reference pages: 24 27 (83 - 84) 103
        
*/

void ippCommandChecker::checkScanOnLine( ippCommandConstPtr aCommand)
{
  const ippScanOnLineCommand* theScan =
   static_cast<const ippScanOnLineCommand *>(aCommand.get());

  if (!(_world->getIsHomed())) {
    _errorCode = NOT_HOMED_CAN_NOT_EXECUTE_COMMAND;

  } else if (_world->getTools()->getActiveTool() == _world->getTools()->getUnDefTool()){
     _errorCode = CAN_NOT_SCAN_USING_UNDEFTOOL;

  }  else if (_world->getTools()->getActiveTool() == _world->getTools()->getNoTool()){
     _errorCode = CAN_NOT_SCAN_USING_NOTOOL;

  }  else if ((theScan->getSx() == theScan->getEx()) && (theScan->getSy() == theScan->getEy()) &&(theScan->getSz() == theScan->getEz())){
     _errorCode = START_POINT_MUST_DIFFER_FROM_END_POINT;

  } else if (!(_world->inWorkVolume(theScan->getSx(), theScan->getSy(), theScan->getSz()))){
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;

  }  else if (!(_world->inWorkVolume(theScan->getEx(), theScan->getEy(), theScan->getEz()))){
    _errorCode = SCAN_POINT_MUST_BE_IN_WORK_VOLUME;

  }
}

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

/* ippCommandChecker::checkScanOnLineHint 43

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules: None.
      
        Reference pages: 24 27 (83) 103
        
*/

void ippCommandChecker::checkScanOnLineHint( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkScanUnknownHint 44

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules: None.
      
        Reference pages: 24 27 (85) [93] 103
        
*/

void ippCommandChecker::checkScanUnknownHint( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkScanUnknownDensity 

         
*/

void ippCommandChecker::checkScanUnknownDensity( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkSetCoordSystem 45

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules: None.
      
        Reference pages: 24 28 58 (59) (67) [71] [72] 103
        
*/

void ippCommandChecker::checkSetCoordSystem( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkSetCsyTransformation 46

  Returned Value: None.
  
    Called By:
    ippCommandChecker::checkCommand
    Rules:
    1. Theta must not be negative or more than 180 degrees.
    THETA_MUST_NOT_BE_NEGATIVE_OR_MORE_THAN_180
    
      Reference pages: 24 28 59 (60) 67 [71] [72] (80) 103
      
        Rule 1 is a semantic check and is currently also done in the command
        parser.
        
*/

void ippCommandChecker::checkSetCsyTransformation( ippCommandConstPtr aCommand)
{
  const ippSetCsyTransformationCommand* theSetCsyTransformation =  
    static_cast<const ippSetCsyTransformationCommand *>(aCommand.get());

  if ((theSetCsyTransformation->getTheta() < 0) || (theSetCsyTransformation->getTheta() > 180)){
    _errorCode = THETA_MUST_NOT_BE_NEGATIVE_OR_MORE_THAN_180;
  }

}

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

/* ippCommandChecker::checkSetProp 47

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules: 
      1. Properties of UnDefTool cannot be set by SetProp.
      CAN_NOT_SETPROP_UNDEFTOOL
      2. PtMeas parameters of NoTool cannot be set by SetProp.
      CAN_NOT_SETPROP_PTMEASPARS_OF_NOTOOL
      
        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.
        
          These rules are not explicit in the spec, but seem implicit.
          
            This is not checking for attempting to cause an out-of-range condition
            or attempting to set an unsettable parameter. These checks might be
            added. The behavior of updateSetProp in world.cc, combined with the
            behavior of the Param class in tools.h handles these cases without error.
            
*/

void ippCommandChecker::checkSetProp( ippCommandConstPtr aCommand)
{
  const ippSetPropCommand * theSetProp = 
    static_cast<const ippSetPropCommand*>(aCommand.get());

  ippKToolConstPtr theTool;
  int n;
  
  for (n = 0;
  ((_errorCode == CHECKER_OK) && (n < theSetProp->getNumberProps()));
  n++)
  {
    if (theSetProp->getProp(n).getKey1() == Tool)
      theTool = _world->getTools()->getActiveTool();
    else if (theSetProp->getProp(n).getKey1() == FoundTool)
      theTool = _world->getTools()->getFoundTool();
    else
      theTool = NULL;
    if (theTool && (theTool == _world->getTools()->getUnDefTool()))
      _errorCode = CAN_NOT_SETPROP_UNDEFTOOL;
    else if (theTool && (theSetProp->getProp(n).getKey2() == PtMeasPar) &&
      (theTool == _world->getTools()->getNoTool()))
      _errorCode = CAN_NOT_SETPROP_PTMEASPARS_OF_NOTOOL;
  }
}

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

/* ippCommandChecker::checkSetTool 48

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules: 
      1. The tool must be one of the tools known to the toolchanger.
      UNKNOWN_TOOL
      2. The name of the tool must not be "UnDefTool".
      CAN_NOT_SET_TOOL_TO_UNDEFTOOL
      
        Reference pages: 24 27 29 (54 - 55) 102 106
        
          Rule 2 above is not explicit in the spec, but seems implicit. It also
          seems implicit that it should be possible to set the tool to "NoTool",
          "BaseTool" or "RefTool". These are the same rules as used for ChangeTool.
          
*/

void ippCommandChecker::checkSetTool( ippCommandConstPtr aCommand)
{
  const ippSetToolCommand * theSet = 
    static_cast<const ippSetToolCommand*>(aCommand.get());
  
  if (strcmp("UnDefTool", theSet->getToolName()) == 0) {
    _errorCode = CAN_NOT_SET_TOOL_TO_UNDEFTOOL;
  } else if (!_world->getTools()->findTool(theSet->getToolName())) {
    _errorCode = UNKNOWN_TOOL;
  }
}

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

/* ippCommandChecker::checkStartSession 49

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules:
      1. A session must not already be in progress.
      ALREADY_IN_SESSION
      
        Reference pages: 18 20 24 26 (38) (41) 49 [71] (77) 81 99
        
*/

void ippCommandChecker::checkStartSession( ippCommandConstPtr aCommand)
{
}

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

/* ippCommandChecker::checkStopAllDaemons 50

  Returned Value: None.
  
    Called By: ippCommandChecker::checkCommand
    
      Rules: None.
      
        Reference pages: 24 26 (42) (50) 99
        
          The spec lists no errors. It is not an error to call this when no
          daemons exist.
          
*/

void ippCommandChecker::checkStopAllDaemons( ippCommandConstPtr aCommand)
{
  
}

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

/* ippCommandChecker::checkStopDaemon 51

  Returned Value: None.

  Called By: ippCommandChecker::checkCommand

  Rules:
  1. The daemon identified in the command must exist.
  DAEMON_TO_STOP_DOES_NOT_EXIST

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

void ippCommandChecker::checkStopDaemon( ippCommandConstPtr aCommand)
{
  const ippStopDaemonCommand * theStop = 
    static_cast<const ippStopDaemonCommand* >(aCommand.get());

  int tagNumber= theStop->getDaemonTag().getTagNumber();
  if (!(_world->daemonExists(tagNumber))) {
    _errorCode = DAEMON_TO_STOP_DOES_NOT_EXIST;
  }
}

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

/* ippCommandCheckerBase:: checkTiltCenterPart 52

  Returned Value: None.
  
  Called By: ippCommandChecker::checkCommand

  Rules:
  1. The two circle centers must not be in the same place.
  AXIS_DIRECTION_VECTOR_HAS_ZERO_LENGTH

  Reference pages: 24 27 (97) 102

  If the circle centers are in the same place, the vector between them
  does not have a direction. This rule is not explicit in the spec, but
  if the direction does not exist, the distance to the axis (which is
  needed for determining whether the centers are within the limit) does
  not exist.

    Rule 1 is a semantic check.
            
*/

void ippCommandChecker::checkTiltCenterPart( ippCommandConstPtr aCommand)
{
  const ippTiltCenterPartCommand * theTiltCenter =
    static_cast<const ippTiltCenterPartCommand *>(aCommand.get());
  
  double vecX = (theTiltCenter->getPx1() - theTiltCenter->getPx2());
  double vecY = (theTiltCenter->getPy1() - theTiltCenter->getPy2());
  double vecZ = (theTiltCenter->getPz1() - theTiltCenter->getPz2());
  double length = sqrt((vecX * vecX) + (vecY * vecY) + (vecZ * vecZ));
  
  if (length == 0) {
    _errorCode = AXIS_DIRECTION_VECTOR_HAS_ZERO_LENGTH;
  }
}

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

/* ippCommandCheckerBase:: checkTiltPart 53

  Returned Value: None.
  
  Called By: ippCommandChecker::checkCommand

  Rules:
  1. The length of the axis direction vector must not be 0.
  AXIS_DIRECTION_VECTOR_HAS_ZERO_LENGTH

  Reference pages: 24 27 (97) 102

  Rule 1 is not explicit in the spec, but if the direction vector has no
  length, it has no direction and cannot be used for the required
  comparison with the measured direction.

  Rule 1 is a semantic check.
            
*/

void ippCommandChecker::checkTiltPart(ippCommandConstPtr aCommand)
{
  const ippTiltPartCommand*  theTilt  = 
    static_cast<const ippTiltPartCommand *>(aCommand.get());
  
  double vecX = theTilt->getDx();
  double vecY = theTilt->getDy();
  double vecZ = theTilt->getDz();
  double length = sqrt((vecX * vecX) + (vecY * vecY) + (vecZ * vecZ));
  if (length == 0){
    _errorCode = AXIS_DIRECTION_VECTOR_HAS_ZERO_LENGTH;
  }
}


void ippCommandChecker::checkEnumToolCollection(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkEnumAllToolCollections(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkOpenToolCollection(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkSaveActiveCoordSystem(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkLoadCoordSystem(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkDeleteCoordSystem(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkEnumCoordSystems(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkGetNamedCsyTransformation(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkSaveNamedCsyTransformation(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkScanOnCurveDensity(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkScanOnCurve(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkScanOnCurveHint(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkScanOnHelix(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkPtMeasSelfCenter(ippCommandConstPtr aCommand)
{

}
void ippCommandChecker::checkPtMeasSelfCenterLocked(ippCommandConstPtr aCommand)
{

}

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

/* ippCommandChecker::checkCommand 54

  Returned Value: None.

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

  Rules:
  1. If a session is not in progress, only StartSession and EndSession
  may be executed.
  NOT_IN_SESSION_CAN_NOT_EXECUTE_COMMAND
  2. If in session and readiness is erred, only GetErrStatusE,
  GetXtdErrStatus, or ClearAllErrors may be executed.
  READINESS_ERRED_CAN_NOT_EXECUTE_COMMAND
  3. If readiness is aborted, only GetErrStatusE,
  GetXtdErrStatus, or ClearAllErrors may be executed.
  READINESS_ABORTED_CAN_NOT_EXECUTE_COMMAND

  This is allowing AbortE if readiness is aborted or erred, but not if no
  session is in progress.

  StartSession has the effect of ClearAllErrors (in case an error occurs
  during the execution of StartSession).

  References:
  Rule 1 above: (41)
  AbortE: 9 24 26 (42) [43] 99
  ClearAllErrors: 24 26 [38] (40) (41) (42) (43) [44] (47) (75) 76 99
  StartSession: 18 20 24 26 (38) (41) 49 [71] (77) 81 99

  After checking the rules described above, the function calls a checker
  specific to the command.

  There is currently no command that can call for an abort while a
  StartSession command is being executed.

  Allowing GetErrStatusE and GetXtdErrStatus when in an error state or
  an aborted state (as done by Rules 2 and 3 above) is not currently
  supported by the spec, but it should be because otherwise
  GetErrStatusE and GetXtdErrStatus have no useful function. The spec
  actually says (page 43) that after AbortE, only ClearAllErrors is
  allowed, and (page 40) that after an error of severity 2 or greater,
  only ClearAllErrors is allowed.

  It seems prudent to allow AbortE at any time, even though the spec
  does not support that. It was allowed in previous versions of this
  command checker (1.0 to 2.1) but is not allowed in this version.

  The positions of functions in the checkers array correspond to the
  names in the commandNameType enumeration in IppCmdRes.h. The
  enumeration has no name for indexes 0 and 1. checkAbortE is
  used here in those positions. These indexes will never be used, so
  any of the checkXXX functions could have been used there.

*/
ippCheckerErrorId ippCommandCheckerBase::checkCommand( ippCommandConstPtr aCommand)
{
  _errorCode = CHECKER_OK;
  return _errorCode;
}

ippCommandChecker::ippCommandChecker(world& inWorld)
: _world(&inWorld)
{
}

ippCheckerErrorId ippCommandChecker::checkCommand( ippCommandConstPtr aCommand)
{

  _errorCode = CHECKER_OK;

  _commandName = aCommand->getCommandName();
 
  if (_errorCode == CHECKER_OK) {
    
    if ((_world->getReadiness() == erred) && // we are in error state ...
                    (_commandName != GetErrStatusE)    && // and the command is not related
        (_commandName != GetXtdErrStatus)  && // to clearing or asking about the error
        (_commandName != ClearAllErrors)) { 
      
      // an error has been reported 
      // the client must send ClearAllErrors() 
      _errorCode = READINESS_ERRED_CAN_NOT_EXECUTE_COMMAND;
      
    } else if ((_world->getReadiness() == aborted) &&
      (_commandName != GetErrStatusE) &&
      (_commandName != GetXtdErrStatus) &&
      (_commandName != ClearAllErrors)) {
      
      _errorCode = READINESS_ABORTED_CAN_NOT_EXECUTE_COMMAND;
    }
  }
  if (_errorCode == CHECKER_OK) {
  
      switch(_commandName)
      {
        // this code is equivalent to 
        //  case IsHome : return executeIsHomed();
        // for all values defined in he COMMAND enumeration

  #define ENUM(value,function) case ipp::value: IPP_CONCAT(check,value)(aCommand); break;
      COMMAND_ENUMERATION
  #undef ENUM
      default:
        IPP_ASSERT_FAIL(" Unknown command");

      }
  }
  return _errorCode;

}


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

---