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


/* ippResponseParser.cc

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

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

Functions named makeXXX (where XXX is a response name) are used to
check the components of each type of response and to return an instance
of the response.

References to the responses are given here. 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 relevantippPtMeasOrGetResponse text on page 39 and an example on page 40.

*/

#include "ippdme/ippChangeToolActionType.h"
#include "ippdme/Property/ippOnePropertyNumber.h"
#include "ippdme/Property/ippOnePropertyAlignment.h"
#include "ippdme/Property/ippOnePropertyName.h"
#include "ippdme/Property/ippOnePropertyId.h"
#include "ippdme/Property/ippOnePropertyCollisionVolume.h"

#include "ippdme/Response/ippResponse.h"
#include "ippdme/Response/ippAlignResponse.h"
#include "ippdme/Response/ippCenterPartResponse.h"
#include "ippdme/Response/ippChangeToolEResponse.h"
#include "ippdme/Response/ippEnumPropResponse.h"
#include "ippdme/Response/ippErrorResponse.h"
#include "ippdme/Response/ippGetChangeToolActionResponse.h"
#include "ippdme/Response/ippGetCoordSystemResponse.h"
#include "ippdme/Response/ippGetCsyTransformationResponse.h"
#include "ippdme/Response/ippGetDMEVersionResponse.h"
#include "ippdme/Response/ippGetErrStatusEResponse.h"
#include "ippdme/Response/ippGetMachineClassResponse.h"
#include "ippdme/Response/ippGetPropResponse.h"
#include "ippdme/Response/ippGoToEResponse.h"
#include "ippdme/Response/ippIsHomedResponse.h"
#include "ippdme/Response/ippIsUserEnabledResponse.h"
#include "ippdme/Response/ippKeyPressEResponse.h"
#include "ippdme/Response/ippPtMeasEResponse.h"
#include "ippdme/Response/ippPtMeasOrGetResponse.h"
#include "ippdme/Response/ippScanResponse.h"
#include "ippdme/Response/ippSetPropEResponse.h"
#include "ippdme/Response/ippOnMoveReportEResponse.h"
#include "ippdme/Response/ippStringResponse.h"
#include "ippdme/Response/ippTiltCenterPartResponse.h"
#include "ippdme/Response/ippTiltPartResponse.h"
#include "ippdme/Response/ippAckResponse.h"
#include "ippdme/Response/ippCompleteResponse.h"


#include "ippdme/Parser/ippResponseParser.h"
#include "ippdme/ippResponseNameStrings.h"

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

#include <memory>
#include <iostream>
#include <iomanip>
using namespace ipp;


#define INITSIZE 10

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



//=============================================================================
ippResponseParser::ippResponseParser()
// ----------------------------------------------------------------------------
{
  _itemCount = 0;
  _resSize = INITSIZE;
  _resTypes.resize(_resSize);
  _resKeywords.resize(_resSize);
  _resDoubles.resize(_resSize);
  _arrayIndex = 0;
}

//=============================================================================
ippResponseParser::~ippResponseParser()
// ----------------------------------------------------------------------------
{
 
}

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

/* ippResponseParser::getErrorMessage

Returned Value : const 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 response parser)

Errors: None.

This copies an error message into the buffer.

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 ippResponseParser.h.

*/

std::string ippResponseParser::getErrorMessageString() const
{
  static const char * const errorStrings[] = {
    "OK",
    "BAD CHARACTER AFTER KEYWORD",
    "BAD CHARACTER AFTER RESPONSE END",
    "BAD COORDINATE SYSTEM",
    "BAD E NUMBER EXPONENT MUST HAVE ONE TWO OR THREE DIGITS",
    "BAD ERROR CODE",
    "BAD GOTOPAR PROPERTY",
    "BAD KEYWORD",
    "BAD MACHINE CLASS",
    "BAD NUMBER MORE THAN 16 DIGITS",
    "BAD NUMBER NO DIGITS",
    "BAD NUMBER TWO DECIMAL POINTS",
    "BAD PTMEASPAR PROPERTY",
    "BAD RESPONSE ITEMS",
    "BAD SECOND KEYWORD",
    "BAD SEVENTH CHARACTER IN RESPONSE",
    "BAD SEVERITY",
    "BAD STRING",
    "BAD _tag CHARACTER",
    "BAD TEXT",
    "BAD THIRD KEYWORD",
    "BUG",
    "ER USED TWICE",
    "ERROR CODE MUST HAVE FOUR DIGITS",
    "FIRST ARGUMENT MUST BE SWITCH ROTATE MOVEAUTO OR MOVEMAN",
    "IJK USED TWICE",
    "IJKAct USED TWICE",
    "Q USED TWICE",
    "IJK VALUES MUST BE ZERO",
    "ILLEGAL SPACE",
    "R USED TWICE",
    "RESPONSE NAME MUST BE ERROR",
    "SEVERITY MUST HAVE ONE DIGIT",
    "SPACE MISSING AFTER _tag",
    "SPACE MISSING AT EIGHTH CHARACTER OF RESPONSE",
    "_tag NUMBER OUT OF RANGE FOR COMMAND _tag",
    "TOOL A USED TWICE",
    "TOOL B USED TWICE",
    "TOOL C USED TWICE",
    "VALUE MUST BE 0 OR 1",
    "X USED TWICE",
    "Y USED TWICE",
    "Z USED TWICE",
    "ZERO _tag MUST BE SERVER INITIATED RESPONSE",
    "Bad Property"
  };
  static char buffer[1000];
  if ((_responseName > -1) && (_responseName < ippResponseNameType_MAXVALUE))
    sprintf(buffer, "%s: %s",
            ippResponseNameStrings[_responseName], errorStrings[_errorCode]);
  else
    sprintf(buffer, "%s",errorStrings[_errorCode]);
  return buffer;
}

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

/* parserCmd::makeArraysBigger

Returned Value: None.

Called By: ippResponseParser::parseArguments

Rules: None.

This doubles the sizes of the four arrays in which response items are stored.
It also doubles resSize.

This makes new arrays twice the size of the old arrays and copies the
contents of the old arrays into the first half of the new arrays.
The old arrays are deleted.

*/

void ippResponseParser::makeArraysBigger()
{
  _resSize = (2 * _resSize);
  _resKeywords.resize(_resSize);
  _resDoubles.resize(_resSize);
  _resTypes.resize(_resSize);
}

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

/* ippResponseParser::makeAlignResponse

Returned Value: An AlignResponse as described by the response text,
   or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. If the response does not match either of the patterns
   (double, double, double)
   (double, double, double, double, double, double)   :
   BAD_RESPONSE_ITEMS.

This is called when the first data character of a data response is
a left parenthesis, because the only valid response which has a left
parenthesis in that position is an AlignResponse.

An AlignResponse responds to either an AlignTool command or an AlignPart
command.

Example 1. 00010 # (0.6, 0.0, 0.8)
Example 2. 00010 # (1, 0, 0, 0, 0, 1)

AlignPart Reference pages: 24 28 63 (95) 105
AlignTool Reference pages: 24 27 29 (55) 66 70 102 107

*/



ippResponsePtr ippResponseParser::makeAlignResponse()
{
  _responseName = DataAlign;

  if (match(_resTypes,"(#,#,#)")) { 
    return new ippAlignResponse(_tag,
                  _resDoubles[1], _resDoubles[3],_resDoubles[5]);

  } else if (match(_resTypes,"(#,#,#,#,#,#)")) {
      return new ippAlignResponse(_tag,
                  _resDoubles[1], _resDoubles[3],_resDoubles[5],
                  _resDoubles[7], _resDoubles[9], _resDoubles[11] );
 } else {
    _errorCode = BAD_RESPONSE_ITEMS;
 }
  return 0;
}

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

/* ippResponseParser::makeCenterPartResponse

Returned Value: A CenterPartResponse as described by the response text,
   or NULL if the response text is bad.

Called By: ippResponseParser::makeDataResponse

Errors:
1. If the response items do not match the pattern
   CenterPart(double)
   or the double is not a single character: BAD_RESPONSE_ITEMS.
2. If the double is not 0 or 1: VALUE_MUST_BE_0_OR_1;

This function is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == CenterPart), so those conditions are not checked here.

The check on _inputArray[20] ensures there is only one character between
parentheses.

A CenterPartResponse responds to a CenterPart command.

Example 1. 00010 # CenterPart(1)

Reference pages: 24 27 (96) 102

*/

ippResponsePtr ippResponseParser::makeCenterPartResponse()
{
  _responseName = DataCenterPart;

  // check the syntax
  if (!match(_resTypes,"k(#)")) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }
  // check the arguments
  if ((_resDoubles[2] != 0) && (_resDoubles[2] != 1)) {
    _errorCode = VALUE_MUST_BE_0_OR_1;
    return 0;
  }
  bool value = ((_resDoubles[2] == 1) ? true : false);

  return  new ippCenterPartResponse(_tag, value);
}

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

/* ippResponseParser::makeChangeToolEResponse

Returned Value: A ChangeToolEResponse as described by the response text,
   or NULL if the response text is bad.

Called By:  ippResponseParser::makeServerInitiatedResponse

Errors:
  1. If the response does not have the pattern
     ChangeTool(string)
     BAD_RESPONSE_ITEMS

This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == ChangeToolKey), so those conditions are not checked here.

A ChangeToolE response is server-initiated and is not a response to a command.

Example 1. E0000 # ChangeTool("Probe1")

Reference pages: (78)

*/

ippResponsePtr ippResponseParser::makeChangeToolEResponse()
{
  _responseName = DataChangeToolE;
  // check the syntax
  if (!match(_resTypes,"k(s)")) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }
        return  new ippChangeToolEResponse(_resStrings[2].c_str());
}

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

/* ippResponseParser::makeDataResponse

Returned Value: A data ippResponse of the appropriate type as described
   by the response text, or NULL if the response text is bad.

Called By:  ippResponseParser::parseResponse

Errors:
1. The response items do not conform to any defined pattern of response
   items: BAD_RESPONSE_ITEMS.

This examines the type of the first response item (and possibly other
information about response items), decides what type of response it must
be, and calls a subordinate function to make a response of that type.

This is called if the seventh character of the response is # and the
_tag is OK but is not E0000.

*/

ippResponsePtr ippResponseParser::makeDataResponse()
{
  ippResponsePtr aResponse;

  if (_resTypes[0] == RESPARENLEFT)
    aResponse = makeAlignResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == CenterPartKey))
    aResponse = makeCenterPartResponse();
  else if ((_resTypes[0] == RESSTRING) && (_itemCount == 3))
    aResponse = makeEnumPropResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == ChangeToolAction))
    aResponse = makeGetChangeToolActionResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == CoordSystem))
    aResponse = makeGetCoordSystemResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == GetCsyTr))
    aResponse = makeGetCsyTransformationResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == DMEVersion))
    aResponse = makeGetDMEVersionResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == ErrStatus))
    aResponse = makeGetErrStatusEResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == GetMachineKey))
    aResponse = makeGetMachineClassResponse();
  else if (  match(_resTypes,"k.k")  && IsMainObject(_resKeywords[0],_resKeywords[2])) 
    aResponse = makeGetPropResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == IsHomedKey))
    aResponse = makeIsHomedResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == IsUserEnabledKey))
    aResponse = makeIsUserEnabledResponse();
  else if ((_resTypes[0] == RESKEYWORD) &&
           ((_resKeywords[0] == ER)  ||
            (_resKeywords[0] == IJK) ||
            (_resKeywords[0] == R)   ||
            (_resKeywords[0] == X)   ||
            (_resKeywords[0] == Y)   ||
            (_resKeywords[0] == Z)   ||
            (_resKeywords[0] == Tool)))
    aResponse = makePtMeasOrGetResponse();
  else if (_resTypes[0] == RESDOUBLE)
    aResponse = makeScanResponse();
  else if ((_resTypes[0] == RESSTRING) && (_itemCount == 1))
    aResponse = makeStringResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == TiltCenterPartKey))
    aResponse = makeTiltCenterPartResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == TiltPartKey))
    aResponse = makeTiltPartResponse();
  else
    {
      aResponse = NULL;
      _errorCode = BAD_RESPONSE_ITEMS;
    }
  return aResponse;
}

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

/* ippResponseParser::makeEnumPropResponse

Returned Value: An EnumPropResponse as described by the response text,
   or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. If the response items do not match the pattern
   string, string
   BAD_RESPONSE_ITEMS

This is called when (_itemCount == 3) and (_resTypes[0] == RESSTRING),
so those conditions are not checked here.

An EnumPropResponse responds to an EnumProp command or an EnumAllProp command.

Example 1. 00020 # "GoToPar", "Property"

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

*/

ippResponsePtr ippResponseParser::makeEnumPropResponse()
{
  _responseName = DataEnumProp;

  if (!match(_resTypes,"s,s")) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }
  return new ippEnumPropResponse(_tag, 
    _resStrings[0].c_str(), _resStrings[2].c_str());
}

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

/* ippResponseParser::makeErrorResponse

Returned Value: An ErrorResponse as described by the response text,
   or NULL if the response text is bad.

Called By:  ippResponseParser::parseResponse

Errors:
1. If the response does not match the pattern
   keyword(double, double, string, string):
   BAD_RESPONSE_ITEMS.
2. If the keyword is not Error: RESPONSE_NAME_MUST_BE_ERROR.
3. If the first double (the severity) has more than one digit:
   SEVERITY_MUST_HAVE_ONE_DIGIT.
4. If the second double (the error code) does not consist of four digits:
   ERROR_CODE_IS_MUST_HAVE_FOUR_DIGITS.
5. If the severity is 4 (which happens only if the error code is not a
   defined error code): BAD_ERROR_CODE.
6. If the error text is not the correct error text for the given error
   code: BAD_TEXT.
7. If the severity is not the correct severity for the given error code:
   BAD_SEVERITY.

This is called when an exclamation point follows the _tag.

An ErrorResponse responds to any command whose execution causes an error.
An ErrorResponse may also be server-initiated.

Example 1. 00010 ! Error(3,1008, "Do", "Target position out of machine volume")
Example 2. E0000 ! Error(3, 1009, "pressureCheck", "Air pressure out of range")

Reference pages: 20 26 30 31 33-35 [36] 37 38 [38] 39 [39]
                 40 43 [43] [44] (75-76) 100 101 113
These reference pages cover only the format and use of error messages.
They do not cover the specific errors that can occur for each command.
They do not cover ClearAllErrors, GetErrStatusE, or GetXtdErrStatus.

*/

ippResponsePtr ippResponseParser::makeErrorResponse()
{
  char severity;
  ipp::parserResErrorId  code = OK;
  ippErrorResponsePtr aResponse;

  // check the syntax
  if (!match(_resTypes,"k(#,#,s,s)")) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }
  _responseName = ErrorError;

  if (_resKeywords[0] != ErrorKey) {
    _errorCode = RESPONSE_NAME_MUST_BE_ERROR;

  } else if (_inputArray[15] != ','){
    _errorCode = SEVERITY_MUST_HAVE_ONE_DIGIT;

  } else if (
     !isdigit(_inputArray[16]) ||
           !isdigit(_inputArray[17]) ||
           !isdigit(_inputArray[18]) ||
           !isdigit(_inputArray[19]) ||
     (_inputArray[20] != ',')) {
        _errorCode = ERROR_CODE_MUST_HAVE_FOUR_DIGITS;
  } else {
    severity = ((_resDoubles[2] == 0) ? '0' :
                (_resDoubles[2] == 1) ? '1' :
                (_resDoubles[2] == 2) ? '2' :
                (_resDoubles[2] == 3) ? '3' :
                (_resDoubles[2] == 9) ? '9' : '4');
    
   ippErrorNameType errCode = Convert2ippErrorNameType(_resDoubles[4]);
   
   aResponse = new ippErrorResponse(_tag, _tagType, errCode, _resStrings[6].c_str());
 
   std::string errTxt = aResponse->getTheError()->getText();
   if (aResponse->getTheError()->getSeverity() == '4') {
      _errorCode = BAD_ERROR_CODE;

    } else if ( aResponse->getTheError()->getText()!= _resStrings[8] ){
      _errorCode = BAD_TEXT;
    } else if (severity != aResponse->getTheError()->getSeverity()){
      _errorCode = BAD_SEVERITY;
    }
  }
  return ((_errorCode != OK) ? NULL : aResponse);
}

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

/* ippResponseParser::makeGetChangeToolActionResponse

Returned Value: A GetChangeToolActionResponse as described by the response
   text, or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
  1. The response does not have the pattern
     ChangeToolAction(Arg, X(<number>), Y(<number>), Z(<number>))
     BAD_RESPONSE_ITEMS
  2. The arg is not SWITCH, ROTATE, MOVEAUTO, MOVEMAN
     FIRST_ARGUMENT_MUST_BE_SWITCH_ROTATE_MOVEAUTO_OR_MOVEMAN
  
This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == ChangeToolAction), so those conditions are not checked here.

A ChangeToolActionResponse responds to a GetChangeToolAction command.

Example 1. 00010 # ChangeToolAction(Switch, X(1), Y(2), Z(3))

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

*/


ippResponsePtr ippResponseParser::makeGetChangeToolActionResponse()
{
  _responseName = DataGetChangeToolAction;

  if (!match(_resTypes,"k(k,k(#),k(#),k(#))")) {
     _errorCode = BAD_RESPONSE_ITEMS;
     return 0;
  }
  if (_resKeywords[4] != X) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }
  if (_resKeywords[9] != Y) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }
  if (_resKeywords[14]!= Z) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }

  ippChangeToolActionType action = ChangeToolActionFromKeyWord(_resKeywords[2]);

  if (ippChangeToolActionType_INVALID == action) {
    _errorCode = FIRST_ARGUMENT_MUST_BE_SWITCH_ROTATE_MOVEAUTO_OR_MOVEMAN;
    return 0;
 }
 return new ippGetChangeToolActionResponse(_tag,action,
                                          _resDoubles[6],
                                          _resDoubles[11],
                                          _resDoubles[16]);
}

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

/* ippResponseParser::makeGetCoordSystemResponse

Returned Value: A GetCoordSystemResponse as described by the response
   text, or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. If the response items do not match the pattern
   CoordSystem(keyword)
   BAD_RESPONSE_ITEMS.
2. If the keyword is not MachineCsy, MoveableMachineCsy, MultipleArmCsy
   or PartCsy:
   BAD_COORDINATE_SYSTEM.

This function is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == CoordSystem), so those conditions are not checked here.

A GetCoordSystemResponse responds to a GetCoordSystem command.

Example 1. 00010 # CoordSystem(PartCsy)

Reference pages: 24 28 (59) 103

*/

ippResponsePtr ippResponseParser::makeGetCoordSystemResponse()
{
  _responseName = DataGetCoordSystem;
  if (!match(_resTypes,"k(k)")) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }

  if ( (_resKeywords[2] < MachineCsy) ||  (_resKeywords[2] > PartCsy)) {
    _errorCode = BAD_COORDINATE_SYSTEM;
    return 0;
  }
  return ((_errorCode != OK) ? NULL :
          new ippGetCoordSystemResponse(_tag, (ippCoordSysType)_resKeywords[2]));
}

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

/* ippResponseParser::makeGetCsyTransformationResponse

Returned Value: A GetCsyTransformationResponse as described by the
   response text, or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. If the response items do not match the pattern:
   GetCsyTransformation(double, double, double, double, double, double)
   BAD_RESPONSE_ITEMS.

This function is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == GetCsyTr), so those conditions are not checked here.

A GetCsyTransformationResponse responds to a GetCsyTransformation command.

Example 1. 00040 # GetCsyTransformation(1,2,3,4,5,6)

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

Note: The response does not identify the coordinate system. Release 2.1
mistakenly included that.

*/

ippResponsePtr ippResponseParser::makeGetCsyTransformationResponse()
{
  _responseName = DataGetCsyTransformation;

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

        return new ippGetCsyTransformationResponse(_tag,
                _resDoubles[2], _resDoubles[4], _resDoubles[6],
                _resDoubles[8], _resDoubles[10], _resDoubles[12]);
}

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

/* ippResponseParser::makeGetDMEVersionResponse

Returned Value: A GetDMEVersionResponse as described by the response
   text, or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. If the response items do not match the pattern
   DMEVersion(string)
   BAD_RESPONSE_ITEMS.

This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == DMEVersion), so those conditions are not checked here.

A GetDMEVersionResponse responds to a GetDMEVersion command.

Example 1. 00010 # DMEVersion("1.3.9")

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

*/

ippResponsePtr ippResponseParser::makeGetDMEVersionResponse()
{
  _responseName = DataGetDMEVersion;
  if (!match(_resTypes,"k(s)")) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }
  return ((_errorCode != OK) ? NULL :
          new ippGetDMEVersionResponse(_tag, _resStrings[2].c_str()));
}

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

/* ippResponseParser::makeGetErrStatusEResponse

Returned Value: A GetErrStatusResponse as described by the response
   text, or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. If the response items do not match the pattern
   ErrStatus(double)
   or the double does not consist of a single character:
   BAD_RESPONSE_ITEMS.
2. If the double is not 0 or 1: VALUE_MUST_BE_0_OR_1.

This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == ErrStatus), so those conditions are not checked here.

The check on _inputArray[19] ensures there is only one character between
parentheses.

A GetErrStatusEResponse responds to a GetErrStatusE command.

Example 1. E0010 # ErrStatus(1)

Reference pages: 24 27 (50) 102

*/

ippResponsePtr ippResponseParser::makeGetErrStatusEResponse()
{
  _responseName = DataGetErrStatusE;
  
  if (!match(_resTypes,"k(#)")) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }

  if ((_resDoubles[2] != 0) && (_resDoubles[2] != 1)) {
    _errorCode = VALUE_MUST_BE_0_OR_1;
  }
  
  bool value = (_resDoubles[2]==1) ? true : false;

  return  new ippGetErrStatusEResponse(_tag, value);
}

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

/* ippResponseParser::makeGetMachineClassResponse

Returned Value: A GetMachineClassResponse as described by the response
   text, or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. If the response items do not match the pattern
   MachineClass(value)
   BAD_RESPONSE_ITEMS.
2. If the value is not CartCMM or CartCMMWithRotaryTable
   BAD_MACHINE_CLASS.

This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == GetMachineKey), so those conditions are not checked here.

A GetMachineClassResponse responds to a GetMachineClass command.

Example 1. 00010 # GetMachineClass(CartCMM)

Reference pages: 18 24 27 (50) 102

*/

ippResponsePtr ippResponseParser::makeGetMachineClassResponse()
{
  _responseName = DataGetMachineClass;

  if (!match(_resTypes,"k(k)")) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }

  ippMachineClassType machineType = MachineClassTypeFromKeyWord(_resKeywords[2]);
  if (machineType ==ippMachineClassType_INVALID) { 
    _errorCode = BAD_MACHINE_CLASS;
    return 0;

  }
  return new ippGetMachineClassResponse(_tag,machineType);
}

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

/* ippResponseParser::makeGetPropResponse

Returned Value: A GetPropResponse as described by the response text,
   or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. There must be at least one argument, and each argument must have at
   least six components and begin with the pattern:
   key1.key2 ...
   in which key1 is Tool or FoundTool.
   BAD_RESPONSE_ITEMS
2. If key1 is Tool, key2 must be Alignment, CollisionVolume, Name,
   Id, GoToPar, or PtMeasPar.
   If key1 is FoundTool, key2 must be Name, Id, GoToPar, or PtMeasPar.
   BAD_SECOND_KEYWORD

This is called when (_resTypes[0] == RESKEYWORD) and
((_resKeywords[0] == Tool) or (_resKeywords[0] == FoundTool))
[except when _resKeywords[2] is A, B, or C].

A GetPropResponse responds to a GetProp or GetPropE command.

Example 1. 00010 # Tool.GoToPar.Speed(30), Tool.GoToPar.Speed.Act(30)

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

Notes:

oneProps1 may be larger than necessary, so it is copied to
oneProps2 for making the GetPropResponse.

Each of the makeOnePropertyXXX functions resets n to be the index of
the next item to be parsed. If there is no next item, the "for" loop
terminates. 

*/

ippResponsePtr ippResponseParser::makeGetPropResponse()
{

  _responseName = DataGetProp;

  ippGetPropResponsePtr response = new ippGetPropResponse(_tag, _tagType);
  

  for (int n = 0; ((n < _itemCount) && (_errorCode == OK)); ) {

    ippOtherKeyType key1 = EmptyKey; 
    ippOtherKeyType key2 = EmptyKey; 
    ippOtherKeyType key3 = EmptyKey; 
    ippOtherKeyType key4 = EmptyKey;
    double value = 0;
    
    int m=n;
    bool foundPropertyNumber = false;
/*    if(match(_resTypes,"k(#)",m)) { 
      key1 =  _resKeywords[m];
      value = _resDoubles[m+2];
      foundPropertyNumber = true;
      n = (m + 5);
    } else
    */
    if(match(_resTypes,"k.k(#)",m)) { 
      key1 =  _resKeywords[m];
      key2 =  _resKeywords[m+2];
      value = _resDoubles[m+4];
      foundPropertyNumber = true;
      n = (m + 7);
    } else if(match(_resTypes,"k.k.k(#)",m)) { 
      key1 =  _resKeywords[m];
      key2 =  _resKeywords[m+2];
      key3 =  _resKeywords[m+4];
      value = _resDoubles[m+6];
      foundPropertyNumber = true;
      n = (m + 9);
    } else if(match(_resTypes,"k.k.k.k(#)",m)) { 
      key1 =  _resKeywords[m];
      key2 =  _resKeywords[m+2];
      key3 =  _resKeywords[m+4];
      key4 =  _resKeywords[m+6];
      value = _resDoubles[m+8];
      foundPropertyNumber = true;
      n = (m + 11);
    }  
    if (foundPropertyNumber) {
      ippProp prop(key1,key2,key3,key4);
      if (!PropertyIsDouble(prop)) {
        _errorCode = BAD_PROPERTY;
      }
      ippOnePropertyPtr r = new ippOnePropertyNumber(prop,value);
      response->append(r);
      
    } else if (_resKeywords[n + 2] == Alignment){      
      response->append(makeOnePropertyAlignment(&n));
    } else if (_resKeywords[n+2 ] == AlignmentVolume ) { 
      response->append(makeOnePropertyAlignmentVolume(&n));
    } else if (_resKeywords[n + 2] == CollisionVolume){
      response->append(makeOnePropertyCollisionVolume(&n));
    } else if (_resKeywords[n + 2] == Name) {
            response->append(makeOnePropertyName(&n));
    } else if (_resKeywords[n + 2] == Id){
            response->append(makeOnePropertyId(&n));
    } else { 
            _errorCode = BAD_SECOND_KEYWORD;
    }
  }
  if (_errorCode != OK) {
    response =0;
  }
  return response;
}

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

/* ippResponseParser::makeGoToEResponse

Returned Value: A GoToEResponse as described by the response text,
   or NULL if the response text is bad.

Called By:  ippResponseParser::makeServerInitiatedResponse

Errors:
1. The response does not have the pattern
   GoTo(<data items>)
   BAD_RESPONSE_ITEMS
2. There are not one to nine data items.
   BAD_RESPONSE_ITEMS
3. A data item is not one of: ER(double), IJK(double, double, double),
   R(double), X(double), Y(double), Z(double), Tool.A(double),
   Tool.B(double), or Tool.C(double).
   BAD_RESPONSE_ITEMS
4. An allowed data item appears more than 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
5. IJK is used but the not all three doubles are zero.
   IJK_VALUES_MUST_BE_ZERO
6. Commas do not separate the response items if there are two or more.
   BAD_RESPONSE_ITEMS

This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == GoToKey), so those conditions are not checked here.

A GoToE response is server-initiated and is not a response to a command.

Example 1. E0000 # GoTo(X(15), Z(-0.09))

server-initiated GoTo Reference pages: (78)
other GoTo Ref. pages : 24 27 [38] [43] (51 - 53) (58) (62) [71] [72] (98) 102
OnPtMeas Report Ref. pages: 24 27 (41) (49) (52) (53) 61 [71] [72] (78) 102

Notes:

The spec provides that a server-initiated GoTo response should use the
same format inside the GoTo(..) as a response to an OnPtMeasReport command,
so that is done here. The body of this function is very similar to the body
of makePtMeasOrGetResponse.

*/

ippResponsePtr ippResponseParser::makeGoToEResponse()
{
  int n; // index for components of response items
  bool hasER = false;
  bool hasIJK = false;
  bool hasR = false;
  bool hasToolA = false;
  bool hasToolB = false;
  bool hasToolC = false;
  bool hasX = false;
  bool hasY = false;
  bool hasZ = false;
  double ERvalue = 0;
  double Rvalue = 0;
  double toolAvalue = 0;
  double toolBvalue = 0;
  double toolCvalue = 0;
  double Xvalue = 0;
  double Yvalue = 0;
  double Zvalue = 0;
  double Ivalue = 0;
  double Jvalue = 0;
  double Kvalue = 0;
  _responseName = DataGoToE;



  if (_resTypes[1] != RESPARENLEFT) {
    _errorCode = BAD_RESPONSE_ITEMS;
  }
  if (_resTypes[_itemCount-1] != RESPARENRIGHT) {
    _errorCode = BAD_RESPONSE_ITEMS;
  }

  for (n = 2; ((n < _itemCount) && (_errorCode == OK)); ) {
   
    int old_n=n;
   CheckOptionalArgument(n,hasER,ER,ERvalue,ER_USED_TWICE);
   CheckOptionalArgument(n,hasX, _X,Xvalue ,X_USED_TWICE);
   CheckOptionalArgument(n,hasY, _Y,Yvalue ,Y_USED_TWICE);
   CheckOptionalArgument(n,hasZ, _Z,Zvalue ,Z_USED_TWICE);
   CheckOptionalArgument(n,hasR, _R,Rvalue ,R_USED_TWICE);
   CheckOptionalArgument(n,hasToolA,Tool,_A,toolAvalue ,TOOL_A_USED_TWICE);
   CheckOptionalArgument(n,hasToolB,Tool,_B,toolBvalue ,TOOL_B_USED_TWICE);
   CheckOptionalArgument(n,hasToolC,Tool,_C,toolCvalue ,TOOL_C_USED_TWICE);
   CheckOptionalArgument(n,hasIJK  ,_IJK, Ivalue,Jvalue,Kvalue,IJK_USED_TWICE);
  //xx CheckOptionalArgument(n,hasIJKAct,_IJKAct, IJKActvalue,IJK_USED_TWICE);
     if (old_n == n && _errorCode == OK) { 
      // the argument has not been recognized:
      _errorCode = BAD_RESPONSE_ITEMS;
   }
 }

 if (hasIJK) { 
   if (Ivalue!=0 || Jvalue !=0 || Kvalue!=0 ){
     _errorCode = IJK_VALUES_MUST_BE_ZERO;
   }
 }
  return ((_errorCode != OK) ? NULL:
          new ippGoToEResponse(hasER, hasIJK, hasR, hasToolA, hasToolB, hasToolC,
                            hasX, hasY, hasZ, ERvalue, Rvalue, toolAvalue,
                            toolBvalue, toolCvalue, Xvalue, Yvalue, Zvalue));
}

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

/* ippResponseParser::makeIsHomedResponse

Returned Value: An IsHomedResponse as described by the response
   text, or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. If the response items do not match the pattern
   IsHomed(double)
   or the double is not a single character: BAD_RESPONSE_ITEMS.
2. If the double is not 0 or 1: VALUE_MUST_BE_0_OR_1.

This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == IsHomedKey), so those conditions are not checked here.

An IsHomedResponse responds to an IsHomed command.

Example 1. 00010 # IsHomed(1)

Reference pages: 24 27 (48) 102 111

Notes:

The check on _inputArray[17] ensures there is only one character between
parentheses.

*/

ippResponsePtr ippResponseParser::makeIsHomedResponse()
{
  _responseName = DataIsHomed;

   // check the syntax
  if (!match(_resTypes,"k(#)")) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }
  // check the arguments
  if ((_resDoubles[2] != 0) && (_resDoubles[2] != 1)) {
    _errorCode = VALUE_MUST_BE_0_OR_1;
    return 0;
  }
  bool value = ((_resDoubles[2] == 1) ? true : false);
  return ((_errorCode != OK) ? NULL :
          new ippIsHomedResponse(_tag, value));
}

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

/* ippResponseParser::makeIsUserEnabledResponse

Returned Value: An IsUserEnabledResponse as described by the response
   text, or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. If the response items do not match the pattern
   IsUserEnabled(double)
   or the double is not a single character: BAD_RESPONSE_ITEMS.
2. If the double is not 0 or 1: VALUE_MUST_BE_0_OR_1.

This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == IsUserEnabledKey), so those conditions are not checked
here.

Example 1. 00010 # IsUserEnabled(1)

Reference pages: 24 27 (49) 102

Notes:

The check on _inputArray[23] ensures there is only one character between
parentheses.

*/

ippResponsePtr ippResponseParser::makeIsUserEnabledResponse()
{
  _responseName = DataIsUserEnabled;

  // check the syntax
  if (!match(_resTypes,"k(#)")) {
  _errorCode = BAD_RESPONSE_ITEMS;
  return 0;
  }
  // check the arguments
  if ((_resDoubles[2] != 0) && (_resDoubles[2] != 1)) {
    _errorCode = VALUE_MUST_BE_0_OR_1;
    return 0;
  }

  bool value = ((_resDoubles[2] == 1) ? true : false);

  return ((_errorCode != OK) ? NULL :
          new ippIsUserEnabledResponse(_tag, value));
}

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

/* ippResponseParser::makeKeyPressEResponse

Returned Value: A KeyPressEResponse as described by the response text,
   or NULL if the response text is bad.

Called By:  ippResponseParser::makeServerInitiatedResponse

Errors:
1. The response does not have the pattern
   KeyPress(string)
   BAD_RESPONSE_ITEMS

This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == KeyPress), so those conditions are not checked here.

A KeyPressEResponse is server-initiated and is not a response to a command.

Example 1. E0000 # KeyPress("F1")

Reference pages: (78-79)

*/

ippResponsePtr ippResponseParser::makeKeyPressEResponse()
{
  _responseName = DataKeyPressE;

  if (!match(_resTypes,"k(s)")) {
    _errorCode = BAD_RESPONSE_ITEMS;
    return 0;
  }

  return ((_errorCode != OK) ? NULL :
          new ippKeyPressEResponse(_resStrings[2].c_str()));
}

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

/* ippResponseParser::makeOnePropertyAlignment

Returned Value: A OnePropertyAlignment as described by the response
  items, or NULL if the response items are bad.

Called By:  ippResponseParser::makeGetPropResponse

Errors:
  1. The argument does not have one of the two patterns
     Tool.Alignment(double, double, double)
     Tool.Alignment(double, double, double, double, double, double)
     BAD_RESPONSE_ITEMS
  2. There are more response items after this argument, but the next
     response item is not a comma.
     BAD_RESPONSE_ITEMS

This is called by makeGetPropResponse when an argument starts with
Tool.Alignment, so the first three response items are not checked here.

Example 1. Tool.Alignment(0.0, 0.6, 0.8)

Reference pages: 24 29 (70) 107

Notes:

This resets *n to (*n + 11) or (*n + 17), since, including a comma,
this function handles 11 or 17 response items. These settings are OK
when the end of the response items has been reached and there is no
comma, since the loop in makeGetPropResponse will stop in that case.

It is known that there are at least five more response items to be parsed
when this is called, the first of which (Tool or FoundTool) has index *n.

*/

ippOnePropertyAlignmentPtr ippResponseParser::makeOnePropertyAlignment(
  int* n
)
{

  int m = *n;
  if ( _resKeywords[m]!=ipp::Tool  && _resKeywords[m]!=ipp::FoundTool ) { 
    _errorCode = BAD_SECOND_KEYWORD;
    return 0;
  }

  if (match(_resTypes,"k.k(#,#,#)",m)) {
    *n = (m + 11);
          return new ippOnePropertyAlignment(
                    _resKeywords[m],
                    _resDoubles[m + 4], _resDoubles[m + 6],_resDoubles[m + 8]);

  } else if (match(_resTypes,"k.k(#,#,#,#,#,#)",m)) {

    *n = (m + 17);
          return new ippOnePropertyAlignment(
                    _resKeywords[m],
                    _resDoubles[m + 4], _resDoubles[m + 6], _resDoubles[m + 8], 
                    _resDoubles[m + 10],_resDoubles[m + 12], _resDoubles[m + 14]);
  } 

        _errorCode = BAD_RESPONSE_ITEMS;
  
  return 0;
}
ippOnePropertyAlignmentVolumePtr ippResponseParser::makeOnePropertyAlignmentVolume(
  int* n
)
{

  int m = *n;

  if (match(_resTypes,"k.k(k,#,#,#,#)",m)) {
    *n = (m + 15);
    if ( _resKeywords[m]!=ipp::Tool  && _resKeywords[m]!=ipp::FoundTool ) { 
      _errorCode = BAD_SECOND_KEYWORD;
      return 0;
    }
          return new ippOnePropertyAlignmentVolume(
            _resKeywords[m],
            _resDoubles[m + 6], _resDoubles[m + 8],
            _resDoubles[m + 10],_resDoubles[m + 12]);

  } 

        _errorCode = BAD_RESPONSE_ITEMS;
  
  return 0;
}
/*******************************************************************/

/* ippResponseParser::makeOnePropertyCollisionVolume

Returned Value: A OnePropertyCollisionVolume as described by the response
  items, or NULL if the response items are bad.

Called By:  ippResponseParser::makeGetPropResponse

Errors:
  1. The argument being parsed does not have the pattern
     Tool.CollisionVolume(OBB,double<15 times>, ... OBB,double<15 times>)
     or the pattern Tool.CollisionVolume(), indicating no boxes
     BAD_RESPONSE_ITEMS
  2. There are more response items after this argument, but the next
     response item is not a comma.
     BAD_RESPONSE_ITEMS

This is called by makeGetPropResponse when an argument starts with
Tool.CollisionVolume, so the first three response items are not checked here.

Example 1. Tool.CollisionVolume(OBB,150,10,530,50,50,50,1,0,0,0,1,0,0,0,1),

Example 2. Tool.CollisionVolume(),

Reference pages: 24 29 (67-70) [68] [69] 107

Notes:

This resets *n to (*n + 6) if there are no boxes and to (*n + 5 + (m *
32)) where m > 0 is the number of boxes in the CollisionVolume, since,
including a comma at the end, this function handles 6 or (5 + (m * 32)
response items. This setting is OK when the end of the response items
has been reached and there is no comma, since the loop in
makeGetPropResponse will stop in that case.

It is known that there are at least five more response items to be
parsed when this is called, the first of which (Tool) has index *n.

*/
// ER note : for some reason the compiler of VC6 doesn't optimise this function
//           very well and cause this code to misinterpret the 
//           _resTypes[k + 1] != RESKEYWORD)
#if _MSC_VER <= 1200
#ifndef _DEBUG
#pragma message("Turning  compiler optimisation off to make makeOnePropertyCollisionVolume work ")
#pragma optimize("",off)
#endif

#endif

ippOnePropertyCollisionVolumePtr 
ippResponseParser::makeOnePropertyCollisionVolume(int * n)
{
  
  ippOtherKeyType _keyword = _resKeywords[*n];
  if ( _keyword!=ipp::Tool  && _keyword!=ipp::FoundTool ) { 
    _errorCode = BAD_SECOND_KEYWORD;
    return 0;
  }
  int m =0;       // number of boxes


  int j = 0;       // utility counter
  
  std::vector<ippBox> boxes; // array of boxes
  
  int k = (*n + 3);// index for response items
  if (_resTypes[k] != RESPARENLEFT) {
    _errorCode = BAD_RESPONSE_ITEMS;

  } else if (_resTypes[k + 1] == RESPARENRIGHT) {

    *n = (*n + 6);
    m = 0;
    if ((_itemCount != (k + 2)) && (_resTypes[k + 2] != RESCOMMA)){
            _errorCode = BAD_RESPONSE_ITEMS;  
    }

  } else {
  
    while(_errorCode == OK) {
     
      m++;
      
      //xx dump_token(k+1);

            if (_resTypes[k + 1] != RESKEYWORD)  {
         // the next element must be  a KEYWORD
               _errorCode = BAD_RESPONSE_ITEMS;
      } else if (_resKeywords[k + 1] != OBB) {
        // .. and should be a OBB keyword 
              _errorCode = BAD_RESPONSE_ITEMS;
      } else if (_itemCount < (k + 32) ) {
        // let check if there is enough parameters to form a valid OBB block
              _errorCode = BAD_RESPONSE_ITEMS;
      }

            if (_errorCode == OK) {
        // verify that we have a suite of 15 time [ comma double 
              k +=  2;

              for (j = 0; j < 30; j = (j + 2)) {
                      if ((_resTypes[k + j] != RESCOMMA) ||
            (_resTypes[k + j + 1] != RESDOUBLE)) {
                          _errorCode = BAD_RESPONSE_ITEMS;
          }
                    }
            }

            if (_errorCode == OK) { 

        if (_resTypes[k + 30] == RESPARENRIGHT) {
           // this was the last OBB block in the string
                 break;
        } else if (_resTypes[k + 30] != RESCOMMA) {
           // if not last we expect a comma again
                _errorCode = BAD_RESPONSE_ITEMS;
        } else {
          // everything is fine, lets seek for the next OBB sequence
                k += 30;
        }
            }
          }
    if (_errorCode == OK) {
      if ((_itemCount != (k + 31)) && (_resTypes[k + 31] != RESCOMMA)){
              _errorCode = BAD_RESPONSE_ITEMS;
      }
          }
    if (_errorCode == OK) {
           
      k = (*n + 6);
           
            for (j = 0; j < m; j++) {
        ippBox box;
              box.Cx = _resDoubles[k + 0];
              box.Cy = _resDoubles[k + 2];
              box.Cz = _resDoubles[k + 4];
              box.Ex = _resDoubles[k + 6];
              box.Ey = _resDoubles[k + 8];
              box.Ez = _resDoubles[k + 10];
              box.Ix = _resDoubles[k + 12];
              box.Iy = _resDoubles[k + 14];
              box.Iz = _resDoubles[k + 16];
              box.Jx = _resDoubles[k + 18];
              box.Jy = _resDoubles[k + 20];
              box.Jz = _resDoubles[k + 22];
              box.Kx = _resDoubles[k + 24];
              box.Ky = _resDoubles[k + 26];
              box.Kz = _resDoubles[k + 28];
        boxes.push_back(box);

              k = (k + 32);
            }
          } 
    *n = (*n + 5 + (m * 32));
  }
  return ((_errorCode != OK) ? NULL :
          new ippOnePropertyCollisionVolume(_keyword, boxes));
}

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

/* ippResponseParser::makeOnePropertyId

Returned Value: A OnePropertyId as described by the response
  items, or NULL if the response items are bad.

Called By:  ippResponseParser::makeGetPropResponse

Errors:
  1. The argument being parsed does not have either pattern
     Tool.Id(string) or FoundTool.Id(string)
     BAD_RESPONSE_ITEMS
  2. There are more response items after this argument, but the next
     response item is not a comma.
     BAD_RESPONSE_ITEMS


This is called by makeGetPropResponse when an argument starts with Tool.Id
or FoundTool.Id, so the first three response items are not checked here.

Example 1. Tool.Id("123")

Reference pages: 24 29 (66) 107

Notes:

This resets *n to (*n + 7), since, including a comma, this function
handles seven response items. This setting is OK when the end of the
response items has been reached and there is no comma, since the loop
in makeGetPropResponse will stop in that case.

It is known that there are at least five more response items to be
parsed when this is called, the first of which (Tool or FoundTool)
has index *n.

*/

ippOnePropertyIdPtr ippResponseParser::makeOnePropertyId(int * n)
{
  int m;
  m = *n;
  if ((_itemCount < (m + 6))              ||
      (_resTypes[m + 3] != RESPARENLEFT)  ||
      (_resTypes[m + 4] != RESSTRING)     ||
      (_resTypes[m + 5] != RESPARENRIGHT) ||
      ((_itemCount != (m + 6)) && (_resTypes[m + 6] != RESCOMMA)))
    _errorCode = BAD_RESPONSE_ITEMS;
  *n = (m + 7);
  return ((_errorCode != OK) ? NULL :
          new ippOnePropertyId(_resKeywords[m], _resStrings[m + 4].c_str()));
}

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

/* ippResponseParser::makeOnePropertyName

Returned Value: A OnePropertyName as described by the response
  items, or NULL if the response items are bad.

Called By:  ippResponseParser::makeGetPropResponse

Errors:
  1. The argument being parsed does not have either pattern
     Tool.Name(string) or FoundTool.Name(string)
     BAD_RESPONSE_ITEMS
  2. There are more response items after this argument, but the next
     response item is not a comma.
     BAD_RESPONSE_ITEMS

This is called by makeGetPropResponse when an argument starts with Tool.Name
or FoundTool.Name, so the first three response items are not checked here.

Example 1. Tool.Name("probe1")

Reference pages: 24 29 (66) 107

Notes:

This resets *n to (*n + 7), since, including a comma, this function
handles seven response items. This setting is OK when the end of the
response items has been reached and there is no comma, since the loop
in makeGetPropResponse will stop in that case.

It is known that there are at least six more response items to be
parsed when this is called, the first of which (Tool or FoundTool)
has index *n.

*/

ippOnePropertyNamePtr ippResponseParser::makeOnePropertyName(int * n)
{
  int m;
  m = *n;
  if ((_itemCount < (m + 6))              ||
      (_resTypes[m + 3] != RESPARENLEFT)  ||
      (_resTypes[m + 4] != RESSTRING)     ||
      (_resTypes[m + 5] != RESPARENRIGHT) ||
      ((_itemCount != (m + 6)) && (_resTypes[m + 6] != RESCOMMA)))
    _errorCode = BAD_RESPONSE_ITEMS;
  *n = (m + 7);
  return ((_errorCode != OK) ? NULL :
          new ippOnePropertyName(_resKeywords[m], _resStrings[m+4].c_str()));
}


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

/* ippResponseParser::makePtMeasEResponse

Returned Value: A PtMeasOrGetResponse as described by the response text,
   or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. The response items do not have the pattern
   PtMeas(<data items>)
   BAD_RESPONSE_ITEMS
2. There are not one to nine data items.
   BAD_RESPONSE_ITEMS
3. A data item is not one of: ER(double), IJK(double, double, double),
   R(double), X(double), Y(double), Z(double), Tool.A(double),
   Tool.B(double), or Tool.C(double).
   BAD_RESPONSE_ITEMS
4. An allowed data item appears more than once.
   ER_USED_TWICE
   IJK_USED_TWICE
   R_USED_TWICE
   X_USED_TWICE
   Y_USED_TWICE
   Z_USED_TWICE
   TOOL_A_USED_TWICE
   TOOL_B_USED_TWICE
   TOOL_C_USED_TWICE
5. Commas do not separate the response items if there are two or more.
   BAD_RESPONSE_ITEM

This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == PtMeasKey), so those conditions are not checked here.

A PtMeasEResponse is server-initiated and is not a response to a command.

Example 1. E0000 # PtMeas(X(15), Z(-0.09))

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

*/
bool ippResponseParser::CheckOptionalArgument(
  int& n,
  bool& hasArgument,
  ippOtherKeyType type,
  double& value,
  parserResErrorId errorIfDuplicated
)
{
  // keyword ( # )
  if (_errorCode != OK)  { return false; }
  if (_itemCount < n+3)  { return false; }
  if (!match(_resTypes,"k(#)",n)) {
    return true;// ignore ,not for us
  }
  if (_resKeywords[n] != type ){ 
    return true;// ignore ,not for us
  }
  if (hasArgument ) { 
    _errorCode = errorIfDuplicated;      
  } else {
    hasArgument = true;
    value = _resDoubles[ n + 2];
    n += 5;
  }
//  if (n <=_resTypes.size()) {
//    // next must be a ) or a ,
//    if (_resTypes[n-1]!=RESPARENRIGHT &&_resTypes[n-1]!=RESCOMMA) {
//      _errorCode = BAD_RESPONSE_ITEMS;
//    }
//  }
  return true;
}
bool ippResponseParser::CheckOptionalArgument(
  int& n,
  bool& hasArgument,
  ippOtherKeyType type1,
  ippOtherKeyType type2,
  double& value,
  parserResErrorId errorIfDuplicated
)
{
  // keyword ( # )
  if (_errorCode != OK)  { return false; }
  if (_itemCount < n+3)  { return false; }
  if (!match(_resTypes,"k.k(#)",n)) {
    return true;// ignore ,not for us
  }
  if (_resKeywords[n] != type1  || _resKeywords[n+2] != type2){ 
    return true;// ignore ,not for us
  }
  if (hasArgument ) { 
    _errorCode = errorIfDuplicated;      
  } else {
    hasArgument = true;
    value = _resDoubles[ n + 4];
    n += 7;
  }
  return true;
}

bool ippResponseParser::CheckOptionalArgument(
  int& n,
  bool& hasArgument,
  ippOtherKeyType type,
  double& value1,
  double& value2,
  double& value3,
  parserResErrorId errorIfDuplicated
)
{
  // keyword ( # )
  if (_errorCode != OK)  { return false; }
  if (_itemCount < n+3)  { return false; }
  if (!match(_resTypes,"k(#,#,#)",n)) {
    return true;// ignore ,not for us
  }
  if (_resKeywords[n] != type  ){ 
    return true;// ignore ,not for us
  }
  if (hasArgument ) { 
    _errorCode = errorIfDuplicated;      
  } else {
    hasArgument = true;
    value1 = _resDoubles[ n + 2];
    value2 = _resDoubles[ n + 4];
    value3 = _resDoubles[ n + 6];
    n += 9;
  }
//  if (n <_resTypes.size()) {
//    // next must be a ) or a ,
//    if (_resTypes[n-1]!=RESPARENRIGHT &&_resTypes[n-1]!=RESCOMMA) {
//      _errorCode = BAD_RESPONSE_ITEMS;
//    }
//  }
  return true;
}

ippResponsePtr ippResponseParser::makePtMeasEResponse()
{
  int n; // index for components of response items
  bool hasER = false;
  bool hasIJK = false;
  bool hasIJKAct = false;
  bool hasQ  = false;
  bool hasR = false;
  bool hasToolA = false;
  bool hasToolB = false;
  bool hasToolC = false;
  bool hasX = false;
  bool hasY = false;
  bool hasZ = false;
  double ERvalue = 0;
  double Ivalue = 0;
  double Jvalue = 0;
  double Kvalue = 0;
  double Rvalue = 0;
  double IJKActvalue = 0;
  double QValue = 0;
  double toolAvalue = 0;
  double toolBvalue = 0;
  double toolCvalue = 0;
  double Xvalue = 0;
  double Yvalue = 0;
  double Zvalue = 0;

  _responseName = DataPtMeasE;

  if (_resTypes[1] != RESPARENLEFT) {
    _errorCode = BAD_RESPONSE_ITEMS;
  }

  for (n = 2; ((n < _itemCount) && (_errorCode == OK)); ) {
   
   int old_n=n;
   CheckOptionalArgument(n,hasER,ER,ERvalue,ER_USED_TWICE);
   CheckOptionalArgument(n,hasX, _X,Xvalue ,X_USED_TWICE);
   CheckOptionalArgument(n,hasY, _Y,Yvalue ,Y_USED_TWICE);
   CheckOptionalArgument(n,hasZ, _Z,Zvalue ,Z_USED_TWICE);
   CheckOptionalArgument(n,hasR, _R,Rvalue ,R_USED_TWICE);
   CheckOptionalArgument(n,hasToolA,Tool,_A,toolAvalue ,TOOL_A_USED_TWICE);
   CheckOptionalArgument(n,hasToolB,Tool,_B,toolBvalue ,TOOL_B_USED_TWICE);
   CheckOptionalArgument(n,hasToolC,Tool,_C,toolCvalue ,TOOL_C_USED_TWICE);
   CheckOptionalArgument(n,hasIJK  ,_IJK, Ivalue,Jvalue,Kvalue,IJK_USED_TWICE);
   CheckOptionalArgument(n,hasIJKAct,_IJKAct, IJKActvalue,IJK_USED_TWICE);
   if (old_n == n && _errorCode == OK) { 
      // the argument has not been recognized:
      _errorCode = BAD_RESPONSE_ITEMS;
   }
 }
 return ((_errorCode != OK) ? NULL :
          new ippPtMeasEResponse(hasER, hasIJK,hasIJKAct, hasR, hasToolA, hasToolB,
                              hasToolC, hasX, hasY, hasZ, ERvalue, Ivalue,
                              Jvalue, Kvalue, IJKActvalue,Rvalue, toolAvalue, toolBvalue,
                              toolCvalue, Xvalue, Yvalue, Zvalue));
}

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

/* ippResponseParser::makePtMeasOrGetResponse

Returned Value: A PtMeasOrGetResponse as described by the response text,
   or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. There must be one to nine data items.
   BAD_RESPONSE_ITEMS
2. A data item is not one of: ER(double), IJK(double, double, double),
   R(double), X(double), Y(double), Z(double), Tool.A(double),
   Tool.B(double), or Tool.C(double).
   BAD_RESPONSE_ITEMS
3. An allowed data item appears more than once.
   ER_USED_TWICE
   IJK_USED_TWICE
   R_USED_TWICE
   X_USED_TWICE
   Y_USED_TWICE
   Z_USED_TWICE
   TOOL_A_USED_TWICE
   TOOL_B_USED_TWICE
   TOOL_C_USED_TWICE
4. Commas do not separate the response items if there are two or more.
   BAD_RESPONSE_ITEMS

This is called when (_resTypes[0] == RESKEYWORD) and the keyword is ER, IJK, R,
X, Y, Z, or [the keyword is Tool and the keyword after that is A, B, or C].
Other responses where (_resTypes[0] == RESKEYWORD) and the keyword is Tool
are handled by makeGetPropResponse.

A PtMeasOrGetResponse responds to a PtMeas command or a Get command.

Example 1. X(3), Y(4)

PtMeas Reference pages: 9 24 27 (41) (49) (52 - 53) (62) [71] [72] (78)
                        83 84 86 87 89 90 91 102
Get Reference pages: 24 27 [38] [44] (49) (51) 57 (61) (63) (66) (81) 102

Note: A PtMeasOrGetResponse responding to a Get command should never
have ER or IJK. When the response does not have ER or IJK, it is not
possible to tell solely by examining the response whether the command
was a PtMeas or a Get. The caller must keep a record of commands and
check the _tag to determine what the command was.

Which items should be included in a PtMeasOrGetResponse made in
response to a PtMeas command is determined by the most recent
OnPtMeasReport command. This function does not try to determine if
the appropriate items have been reported.

*/

ippResponsePtr ippResponseParser::makePtMeasOrGetResponse()
{
  int n; // index for components of response items
  bool hasER = false;
  bool hasIJK = false;
  bool hasIJKAct = false;
  bool hasQ  = false;

  bool hasR = false;
  bool hasToolA = false;
  bool hasToolB = false;
  bool hasToolC = false;
  bool hasX = false;
  bool hasY = false;
  bool hasZ = false;
  double ERvalue = 0;
  double Ivalue = 0;
  double Jvalue = 0;
  double Kvalue = 0;
  double IJKActvalue = 0;
  double Qvalue =0;
  double Rvalue = 0;
  double toolAvalue = 0;
  double toolBvalue = 0;
  double toolCvalue = 0;
  double Xvalue = 0;
  double Yvalue = 0;
  double Zvalue = 0;

  _responseName = DataPtMeasOrGet;

  for (n = 0; ((n <=_itemCount) && (_errorCode == OK)); ) {

     int old_n=n;
     CheckOptionalArgument(n,hasER,ER,ERvalue,ER_USED_TWICE);
     CheckOptionalArgument(n,hasX, _X,Xvalue ,X_USED_TWICE);
     CheckOptionalArgument(n,hasY, _Y,Yvalue ,Y_USED_TWICE);
     CheckOptionalArgument(n,hasZ, _Z,Zvalue ,Z_USED_TWICE);
     CheckOptionalArgument(n,hasR, _R,Rvalue ,R_USED_TWICE);
     CheckOptionalArgument(n,hasToolA,Tool,_A,toolAvalue ,TOOL_A_USED_TWICE);
     CheckOptionalArgument(n,hasToolB,Tool,_B,toolBvalue ,TOOL_B_USED_TWICE);
     CheckOptionalArgument(n,hasToolC,Tool,_C,toolCvalue ,TOOL_C_USED_TWICE);
     CheckOptionalArgument(n,hasIJK  ,_IJK, Ivalue,Jvalue,Kvalue,IJK_USED_TWICE);
     CheckOptionalArgument(n,hasIJKAct,_IJKAct, IJKActvalue,IJKACT_USED_TWICE);
     CheckOptionalArgument(n,hasQ  ,Q, Qvalue,Q_USED_TWICE);
     if (old_n == n && _errorCode == OK) { 
        // the argument has not been recognized:
        _errorCode = BAD_RESPONSE_ITEMS;
     } 
  }
  if(_errorCode != OK) {
    return 0;
  }
  if (_tagType == EventTag) {
    
    if (hasER || hasIJK) { 
          _errorCode = BAD_RESPONSE_ITEMS;
      return 0;
    }
          return  new  ippOnMoveReportEResponse(_tag, hasR, hasToolA,
                                   hasToolB, hasToolC, hasX, hasY, hasZ,
                                     Rvalue,
                                     toolAvalue, toolBvalue, toolCvalue,
                            Xvalue, Yvalue, Zvalue);

  } else {
          return  new  ippPtMeasOrGetResponse(
             _tag, hasER, hasIJK,hasIJKAct,hasQ, hasR,
             hasToolA,hasToolB, hasToolC, 
             hasX, hasY, hasZ,
                                     ERvalue, Ivalue, Jvalue, Kvalue, int(IJKActvalue),Qvalue,Rvalue,
                                     toolAvalue, toolBvalue, toolCvalue,
                                    Xvalue, Yvalue, Zvalue);
  }
}

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

/* ippResponseParser::makeScanResponse

Returned Value: A ScanResponse as described by the response text,
   or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors:
1. If the number of response items is not odd:
   BAD_RESPONSE_ITEMS.
2. If the first of a pair of response items is not a double:
   BAD_RESPONSE_ITEMS
3. If the second of a pair of response items (followed by more response
   items) is not a comma: BAD_RESPONSE_ITEMS.

This is called when (_resTypes[0] == RESDOUBLE). Scan data is just
doubles separated by commas.

Example 1. 00010 # 1, 2, 3, 4, 5, 6

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

*/

ippResponsePtr ippResponseParser::makeScanResponse()
{
  int n;
  
  
  _responseName = DataScan;
  
  if ((_itemCount % 2) != 1) {
    _errorCode = BAD_RESPONSE_ITEMS;
  }

  std::auto_ptr<double> scanData(new double[(_itemCount + 1) / 2]);
  
  for (n = 0; (_errorCode == OK); n++) {    
    if (_resTypes[n] == RESDOUBLE) {
        scanData.get()[n / 2] = _resDoubles[n];
    } else {      
            _errorCode = BAD_RESPONSE_ITEMS;
    }
    n++;
    if (n >= _itemCount) {
            break;
    }
    if (_resTypes[n] != RESCOMMA) {
             _errorCode = BAD_RESPONSE_ITEMS;
    }
  }
  return ((_errorCode != OK) ? NULL :
          new ippScanResponse(_tag, ((_itemCount + 1) / 2), scanData.get()));
}

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

/* ippResponseParser::makeServerInitiatedResponse

Returned Value: A data ippResponse of the appropriate type as described
   by the response text, or NULL if the response text is bad.

Called By:  ippResponseParser::parseResponse

Errors:
1. The response items do not conform to any defined pattern of response
   items: BAD_RESPONSE_ITEMS.

This examines the type of the first response item (and possibly other
information about response items), decides what type of response it must
be, and calls a subordinate function to make a response of that type.

This is called only if the _tag is known to be E0000.

*/

ippResponsePtr ippResponseParser::makeServerInitiatedResponse()
{
  ippResponsePtr aResponse;

  if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == ChangeToolKey))
    aResponse = makeChangeToolEResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == GoToKey))
    aResponse = makeGoToEResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == KeyPress))
    aResponse = makeKeyPressEResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == PtMeasKey))
    aResponse = makePtMeasEResponse();
  else if ((_resTypes[0] == RESKEYWORD) && (_resKeywords[0] == SetPropKey))
    aResponse = makeSetPropEResponse();
  else
    {
      aResponse = NULL;
      _errorCode = BAD_RESPONSE_ITEMS;
    }
  return aResponse;
}

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

/* ippResponseParser::makeSetPropEResponse

Returned Value: A SetPropEResponse as described by the response text,
   or NULL if the response text is bad.

Called By:  makeServerInitiatedResponse

Errors:
1. If the response items do not match one of the three patterns:
   SetProp(key1.key2(val))           --  9 components in _itemCount
   SetProp(key1.key2.key3(val))      -- 11 components in _itemCount
   SetProp(key1.key2.key3.key4(val)) -- 13 components in _itemCount
   BAD_RESPONSE_ITEMS
2. key1 must be FoundTool or Tool.
   BAD_KEYWORD
3. key2 must be GoToPar or PtMeasPar.
   BAD_KEYWORD
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.
   BAD_KEYWORD
5. If there is a key4, it must be Actual.
   BAD_KEYWORD

This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] == SetPropKey), so those conditions are not checked here.

A SetPropE response is server-initiated and is not a response to a command.

Example 1. E0000 # SetProp(Tool.GoToPar.Speed(55))

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

*/

ippResponsePtr ippResponseParser::makeSetPropEResponse()
{
  _responseName = DataSetPropE;

  ippSetPropEResponsePtr response = new ippSetPropEResponse();
  
  IPP_ASSERT(_resTypes[0] == RESKEYWORD || _resKeywords[0] == SetPropKey);
  if (_resTypes[1] != RESPARENLEFT) { 
    _errorCode = BAD_CHARACTER_AFTER_KEYWORD;
    return 0;
  }
  if (_resTypes[_itemCount-1] != RESPARENRIGHT) { 
    _errorCode = BAD_CHARACTER_AFTER_KEYWORD;
    return 0;
  }

  int n =2;
  for ( n = 2; ((n < _itemCount-1) && (_errorCode == OK)); ) {

    ippOtherKeyType key1 = EmptyKey; 
    ippOtherKeyType key2 = EmptyKey; 
    ippOtherKeyType key3 = EmptyKey; 
    ippOtherKeyType key4 = EmptyKey;
    double value = 0;
    
    int m=n;
    bool foundPropertyNumber = false;

    if(match(_resTypes,"k.k(#)",m)) { 
      key1 =  _resKeywords[m];
      key2 =  _resKeywords[m+2];
      value = _resDoubles[m+4];
      foundPropertyNumber = true;
      n = (m + 7);
    } else if(match(_resTypes,"k.k.k(#)",m)) { 
      key1 =  _resKeywords[m];
      key2 =  _resKeywords[m+2];
      key3 =  _resKeywords[m+4];
      value = _resDoubles[m+6];
      foundPropertyNumber = true;
      n = (m + 9);
    } else if(match(_resTypes,"k.k.k.k(#)",m)) { 
      key1 =  _resKeywords[m];
      key2 =  _resKeywords[m+2];
      key3 =  _resKeywords[m+4];
      key4 =  _resKeywords[m+6];
      value = _resDoubles[m+8];
      foundPropertyNumber = true;
      n = (m + 11);
    }  
    if (foundPropertyNumber) {
      ippProp prop(key1,key2,key3,key4);
      if (!PropertyIsAllowedAndWritable(prop)) {
        _errorCode = BAD_PROPERTY;
      }
      //xx ippOnePropertyPtr r = new ippOnePropertyNumber(prop,value);
      response->addPropValue(prop,value);
      
    /*} else if (_resKeywords[n + 2] == Alignment){      
      response->append(makeOnePropertyAlignment(&n));
    } else if (_resKeywords[n+2 ] == AlignmentVolume ) { 
      response->append(makeOnePropertyAlignmentVolume(&n));
    } else if (_resKeywords[n + 2] == CollisionVolume){
      response->append(makeOnePropertyCollisionVolume(&n));
    } else if (_resKeywords[n + 2] == Name) {
            response->append(makeOnePropertyName(&n));
    } else if (_resKeywords[n + 2] == Id){
            response->append(makeOnePropertyId(&n));
    */
    } else { 
            _errorCode = BAD_SECOND_KEYWORD;
    }
  }
  if (n -1 >= _resTypes.size() || _resTypes[n-1] != RESPARENRIGHT) { 
    _errorCode = BAD_CHARACTER_AFTER_KEYWORD;
    return 0;
  }
  if (_errorCode != OK) {
    response =0;
  }
  return response;

}

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

/* ippResponseParser::makeStringResponse

Returned Value: A StringResponse as described by the response text,
   or NULL if the response text is bad.

Called By:  ippResponseParser::makeDataResponse

Errors: None.

This is called when (_itemCount == 1) and (_resTypes[0] == RESSTRING),
so those conditions are not checked here.

StringResponse responds to a GetErrorInfo command or an EnumTools command.

Example 1. "No clue"
Example 2. "Probe6"

GetErrorInfo Reference pages: 19 24 26 (43) 76 99
Page 76 does not mention the command but gives allowable error numbers.
EnumTools Reference pages: 24 29 (53) (54) (56) 106

*/

ippResponsePtr ippResponseParser::makeStringResponse()
{
  _responseName = DataString;
  return new ippStringResponse(_tag, _resStrings[0].c_str());
}

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

/* ippResponseParser::makeTiltCenterPartResponse

Called By:  ippResponseParser::makeDataResponse

Errors: 
1. If the response items do not match the pattern
   TiltCenterPart(double)
   or the double is not a single character: BAD_RESPONSE_ITEMS.
2. If the double is not 0 or 1: VALUE_MUST_BE_0_OR_1.


This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] = TiltCenterPartKey), so those conditions are not checked here.

A TiltCenterPartResponse responds to a TiltCenterPart command.

Example 1. 00010 # TiltCenterPart(1)

Reference pages: 24 27 (97) 102

*/

ippResponsePtr ippResponseParser::makeTiltCenterPartResponse()
{
  _responseName = DataTiltCenterPart;
  if ((_itemCount != 4) || !match(_resTypes,"k(#)")) {
    _errorCode = BAD_RESPONSE_ITEMS;
  } else if ((_resDoubles[2] != 0) && (_resDoubles[2] != 1)) {
    _errorCode = VALUE_MUST_BE_0_OR_1;
  }
  return ((_errorCode != OK) ? NULL :
          new ippTiltCenterPartResponse(_tag,((_resDoubles[2] == 1) ? true :false)));
}

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

/* ippResponseParser::makeTiltPartResponse

Called By:  ippResponseParser::makeDataResponse

Errors: 
1. If the response items do not match the pattern
   TiltPart(double)
   or the double is not a single character: BAD_RESPONSE_ITEMS.
2. If the double is not 0 or 1: VALUE_MUST_BE_0_OR_1.


This is called when (_resTypes[0] == RESKEYWORD) and
(_resKeywords[0] = TiltPartKey), so those conditions are not checked here.

A TiltPartResponse responds to a TiltPart command.

Example 1. 00010 # TiltPart(1)

Reference pages: 24 27 (97) 102

*/

ippResponsePtr ippResponseParser::makeTiltPartResponse()
{
  _responseName = DataTiltPart;
  if ((_itemCount != 4) || !match(_resTypes,"k(#)")) {
    _errorCode = BAD_RESPONSE_ITEMS;
  } else if ((_resDoubles[2] != 0) && (_resDoubles[2] != 1)) {
    _errorCode = VALUE_MUST_BE_0_OR_1;
  }
  return ((_errorCode != OK) ? NULL :
          new ippTiltPartResponse(_tag, ((_resDoubles[2] == 1) ? true : false)));
}

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

/* ippResponseParser::parseKeyword

Returned Value: None.

Called By: ippResponseParser::parseResItems

Errors:
1. If the letters starting with _inputArray[arrayIndex] do not make
   any defined keyword: BAD_KEYWORD.
2. If the keyword is not followed by a dot, comma, left parenthesis,
   or right parenthesis: BAD_CHARACTER_AFTER_KEYWORD.

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

If there are extra letters after a valid keyword, that is detected.

If one keyword is the same as the beginning of another keyword, a check
for the longer keyword must be made first. There are several cases of that.

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.

If the keyword is OK, it is stored in the parser's _resKeywords[_itemCount].

*/



ippOtherKeyType getFromString(const std::string& );

void ippResponseParser::parseKeyword()
{
  int length =0;

  _resKeywords[_itemCount] = ippOtherKeyType_INVALID;
  _errorCode = BAD_KEYWORD;
  const char* keyword = (_inputArray + _arrayIndex);
  const char* endkeyword = keyword;
  while(isalpha(*endkeyword++));
  
  int keywordLength = (endkeyword-keyword)-1;
 
  _resKeywords[_itemCount] =   getFromString(std::string(keyword,keywordLength));
  if (ippOtherKeyType_INVALID== _resKeywords[_itemCount]) {
    _errorCode = BAD_KEYWORD;
    return;
  }

  if (_resKeywords[_itemCount] != -1) {
      _arrayIndex = (_arrayIndex + keywordLength)-1;
      if ((_inputArray[_arrayIndex + 1] == '.') ||
                (_inputArray[_arrayIndex + 1] == ',') ||
                (_inputArray[_arrayIndex + 1] == '(') ||
          (_inputArray[_arrayIndex + 1] == ')')) {
        _errorCode = OK;
      }   else {
        _errorCode = BAD_CHARACTER_AFTER_KEYWORD;
      }
    }
}

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

/* ippResponseParser::parseNumber

Returned Value: None.

Called By: ippResponseParser::parseResItems

Errors:
1. If the characters that might form a number include two dots:
   BAD_NUMBER_TWO_DECIMAL_POINTS.
2. If the characters that might form a number include no digits:
   BAD_NUMBER_NO_DIGITS.
3. If the characters that might form a number include more than
   sixteen digits: BAD_NUMBER_MORE_THAN_16_DIGITS.
4. If the number has an exponent and the exponent does not have
   one, two, or three digits:
   BAD_E_NUMBER_EXPONENT_MUST_HAVE_ONE_TWO_OR_THREE_DIGITS.

This is called only if the response item being parsed starts with a
plus sign, minus sign, digit, or [decimal point not followed by an
upper case letter].

If the number is OK, it is stored in the parser's _resDoubles[_itemCount].

Reference pages: (33 - 34)

*/

void ippResponseParser::parseNumber()
{
  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
    sscanf((_inputArray +_arrayIndex), "%lf", &(_resDoubles[_itemCount]));
    _inputArray[k] = save; // put char back
    _arrayIndex = (k - 1); // set arrayIndex to end of number
  }
}

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

/* ippResponseParser::parseResItems

Returned Value: None.

Called By: ippResponseParser::parseResponse

Errors:
1. If the beginning of the response items does not match any allowed
   pattern: BAD_RESPONSE_ITEMS.

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
a response item. In the second case it is part of the number.

*/

void ippResponseParser::parseResItems()
{
  char c;
  char d;

  _arrayIndex = 8;

  for(_itemCount = 0; ((c = _inputArray[_arrayIndex]) != 13); _itemCount++) {
    
    if (_itemCount == _resSize) {
      makeArraysBigger();
    }
    
    d = _inputArray[_arrayIndex + 1];

    if (c == '(') {
        _resTypes[_itemCount] = RESPARENLEFT;

    } else if (c == ')') {
      _resTypes[_itemCount] = RESPARENRIGHT;

    } else if (c == '"') {
      /* open quote */ 
            parseString();
            _resTypes[_itemCount] = RESSTRING;

    } else if (c == ',') {
      _resTypes[_itemCount] = RESCOMMA;

    } else if ((c == '.') && isupper(d) /*(d >= 'A') && (d <= 'Z')*/)  { // dot before upper letter 
             _resTypes[_itemCount] = RESDOT;

    } else if ((c == '-') ||(c == '+') ||(c == '.') || isdigit(c)) {
             parseNumber();
             _resTypes[_itemCount] = RESDOUBLE;

    }  else if (isupper(c)/*(c >= 'A') && (c <= 'Z') */)        { // an upper-case letter
            parseKeyword();
            _resTypes[_itemCount] = RESKEYWORD;

    } else {
        _errorCode = BAD_RESPONSE_ITEMS;
    }

    if (_errorCode != OK) {
      break;
    }
    _arrayIndex++; /* move to character after end of item just parsed */
  }
}

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

/* ippResponseParser::parseResponse

Returned Value: A ippResponse (if the _inputArray holds a valid response)
  of NULL (if not).

Called By:
  external functions
  main (in stand-alone response parser)

Errors:
1. If the response items form an allowed response but are not followed
   in the _inputArray by  ASCII 13   ASCII 10  ASCII 0  :
   BAD_CHARACTER_AFTER_RESPONSE_END.
2. If the seventh character of the response is not one of  & % ! #  :
   BAD_SEVENTH_CHARACTER_IN_RESPONSE.
3. if the response is an error response or a data response, and the eighth
   character of the response is not a space:
   SPACE_MISSING_AT_EIGHTH_CHARACTER_OF_RESPONSE.

The setInput function copies a response string into the parser's
_inputArray, stopping at the first ASCII 0, so the check for ASCII 0 is
reasonable.

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

*/

ippResponsePtr ippResponseParser::parseResponse()
{
  ippResponsePtr aResponse;

  _responseName = ippResponseNameType_ERROR;

  parseTag();

  if (_errorCode == OK) {
    if (_inputArray[6] == '&'){
            if ((_inputArray[7] != 13) ||
                (_inputArray[8] != 10) ||
                (_inputArray[9] != 0)) {
                    _errorCode = BAD_CHARACTER_AFTER_RESPONSE_END;
            } else {
              aResponse = new ippAckResponse(_tag, _tagType);
      }
          } else if (_inputArray[6] == '%') {
            if ((_inputArray[7] != 13) ||
                (_inputArray[8] != 10) ||
                (_inputArray[9] != 0))
                  _errorCode = BAD_CHARACTER_AFTER_RESPONSE_END;
      else {
              aResponse = new ippCompleteResponse(_tag, _tagType);
      }

    } else if ((_inputArray[6] != '!') &&(_inputArray[6] != '#')) {
             _errorCode = BAD_SEVENTH_CHARACTER_IN_RESPONSE;

    } else if (_inputArray[7] != ' ') {
            _errorCode = SPACE_MISSING_AT_EIGHTH_CHARACTER_OF_RESPONSE;

    } else      {
            unSpaceInputArray();
      
      if (_errorCode == OK){
              parseResItems();
      }
            if ((_errorCode == OK) &&
              ((_inputArray[_arrayIndex] != 13) ||
               (_inputArray[_arrayIndex + 1] != 10) ||
         (_inputArray[_arrayIndex + 2] != 0))) {
                _errorCode = BAD_CHARACTER_AFTER_RESPONSE_END;
      }
            if (_errorCode == OK)  {
        if (_inputArray[6] == '!') {
          aResponse = makeErrorResponse();
        } else if (_tag == 0) { // _tag is E0000 and (_inputArray[6] == '#')
                      aResponse = makeServerInitiatedResponse();
        } else  { // (_inputArray[6] == '#')
                      aResponse = makeDataResponse();
        }
            }
          }
  }

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

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

/* ippResponseParser::parseString

Returned Value: None.

Called By: ippResponseParser::parseResItems

Errors:
1. The string being read has an illegal character:
   BAD_STRING.

This is called whenever the first character of a response item is a
double-quote (ASCII 34). Reading the string stops at the second
double-quote.

If the string is OK it is stored in the parser's _resStrings[_itemCount].

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 ippResponseParser::parseString()
{

  _arrayIndex++; // skip starting quote
  int start = _arrayIndex;
  for (; (_inputArray[_arrayIndex] != '"'); _arrayIndex++) {

    if ((_inputArray[_arrayIndex] < 32) || (_inputArray[_arrayIndex] > 126)) {
            _errorCode = BAD_STRING;
            return;
    }
  }
  _inputArray[_arrayIndex] = 0; // set temporary null terminator
  _resStrings.resize(_itemCount+1,"");
  _resStrings[_itemCount]  = _inputArray + start; // hook copy in
  _inputArray[_arrayIndex] = '"'; // restore quote at end
}

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

/* ippResponseParser::parseTag

Returned Value: None.

Called By: ippResponseParser::parseResponse

Errors:
1. If the first character of the response is not E or a digit, or any
   of the next four characters is not a digit: BAD_TAG_CHARACTER.
2. If the sixth character of the response is not a space:
   SPACE_MISSING_AFTER_TAG.
2. If the first character is a digit and the _tag number is zero:
   TAG_NUMBER_OUT_OF_RANGE_FOR_COMMAND_TAG.
4. If the _tag is E0000 and the seventh character is not ! or #
   ZERO_TAG_MUST_BE_SERVER_INITIATED_RESPONSE.

If the _tag is OK, its type (as indicated by the first character) is
stored in the "_tagType" data member of the parser, and the value of
the _tag is stored in the "_tag" data member.

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.

*/

void ippResponseParser::parseTag()
{
  if (!isdigit(_inputArray[1]) ||
      !isdigit(_inputArray[2]) ||
      !isdigit(_inputArray[3]) ||
      !isdigit(_inputArray[4])) {
    _errorCode = BAD_TAG_CHARACTER;

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

  } else if (_inputArray[0] == 'E')  {

      sscanf((_inputArray + 1), "%d", &_tag);

      if ((_tag == 0) && (_inputArray[6] != '!') && (_inputArray[6] != '#')) {
        _errorCode = ZERO_TAG_MUST_BE_SERVER_INITIATED_RESPONSE;
      } else {
              _tagType = EventTag;
              _errorCode = OK;
            }

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

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

/* ippResponseParser::setInput

Returned Value: None.

Called By:
  external functions
  main (in stand-alone response parser)

Errors: None.

This copies the input string into the parser's _inputArray. If the input
string is too long, it is truncated.

*/

void ippResponseParser::setInput(
  const char * input
)
{
  strncpy(_inputArray, input, (IPPSIZE - 1));
}


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

/* ippResponseParser::unSpaceInputArray

Returned Value: None.

Called By: ippResponseParser::parseResponse

Errors:
1. Starting with the ninth position of a response string, if a space is
   found that is not before or after a comma, before or after a left or
   right parenthesis, or in a string:
   ILLEGAL_SPACE.

Reference pages: (33 - 34)

Notes:

Starting at the ninth position (index 8), this removes from the
_inputArray all spaces outside of strings. It does this by moving
characters from right to left as necessary to fill in any spaces.

The n-1 in the termination condition of the "for" loop allows the NULL
to be copied also.

*/

bool UnSpaceInputArray(char* _inputArray,int start);

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


void ippResponseParser::dump_token(int k)
{
  std::cout << "item " << std::setw(3) << k << " ";
  switch(_resTypes[k])
  {
    case RESCOMMA: std::cout << "," ;break;
    case RESDOT: std::cout << "." ;break;
    case RESDOUBLE: std::cout << "#" ;break;
      std::cout <<"( value " << _resDoubles[k]  << ")";
    case RESKEYWORD: 
      std::cout << "K" ;
      std::cout <<" ( keywork " << getKeyString(_resKeywords[k]) << ")";
      break;
    case RESPARENLEFT: std::cout << "(" ;break;
    case RESPARENRIGHT: std::cout << ")" ;break;
    case RESSTRING: std::cout << "s" ;break;
  }
  std::cout << std::endl;
}
/*******************************************************************/

---