ippCommandParser.h

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. 
#pragma once 



#define INITARGS 64

#include "ippdme/ippCommandNameType.h"
#include "ippdme/ippTag.h"
#include "ippdme/ippErrorNameType.h"
#include "ippdme/Command/ippCommand.h"
#include "ippdme/Parser/ippParserCmdErrorId.h"
#include <vector>
#include <string>

/* argItemType

argItemType is an enumeration of the types of component that may be in
an argument list.  Periods, commas, empty parentheses, and parentheses
with doubles in them are included, as well as etags, keywords,
doubles, ints, and strings.  

Example 1. For the command GoTo(X(20), Y(15)), there are five argument
components, and the types are:
ARGKEYWORD, ARGPARENDOUBLE, ARGCOMMA, ARGKEYWORD, ARGPARENDOUBLE.

Example 2. For the command OnPtMeasReport(X(), Y(), Z()) there are eight
argument components, and the types are: ARGKEYWORD, ARGPARENEMPTY, ARGCOMMA,
ARGKEYWORD, ARGPARENEMPTY, ARGCOMMA, ARGKEYWORD, ARGPARENEMPTY.

Example 3. For the command GetProp(Tool.PtMeasPar.Accel()), there are six
argument components, and the types are:
ARGKEYWORD, ARGDOT, ARGKEYWORD, ARGDOT, ARGKEYWORD, ARGPARENEMPTY.

The ARGETAG type appears correctly only as the argument to StopDaemon.

The ARGIJK type appears correctly only as an argument to PtMeas.

The ARGINT type is not defined. Where a number must be an integer (as
in several scan commands), it is read as a double and later checked
for being an integer.

*/

typedef enum ippArgItemType {
  ARGCOMMA      = ',', 
  ARGDOT        = '.',
  ARGDOUBLE     = '#',
  ARGETAG       = 't', 
  ARGIJK        = 'v',
  ARGKEYWORD    = 'k',
  ARGPARENEMPTY = 'E',
  ARGPARENDOUBLE ='D',
  ARGSTRING      ='s',
};

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

/* parserCmd

To use the parser, the setInput() method must first be called to copy an
input string into the parser's inputArray. An alternative would be to
have a string as an argument to the parseXXX methods. Copying to
inputArray takes time, but it prevents the parser from messing up the
original string.

parseTag() parses the tag, and sets the parser's isEvent, tag,
tagType, and errorCode.  It is intended that if getParserErr() is OK
(no error in the tag) following the call to parseTag(), the caller
will:

1. check that the tag returned by getTag() is not in use.
2. call getIsEvent() to determine if the tag is an event tag.
3. put the command string on fast queue or the slow queue of the world.

When it is time to execute a command string (because it is at the head
of a queue), parseCommand() should be called to parse the command
string and build an instance of a command.

After calling parseCommand(), the caller should call getParserErr()
to see if there was an error. If the returned error code is not OK,
the caller can call getErrorMessageString(buffer) to get an error message
that describes the error. The buffer should be at least 100 chars long.
If no error occurs until after the name of the command is parsed, the
name of the command is given at the beginning of the error message.

If the error code is OK, the caller can start processing the ippCommand
instance.

*/
class ippCommand;

EXPIMP_TEMPLATE template class IPPDME_EXT_CLASS std::allocator<ippArgItemType>;
EXPIMP_TEMPLATE template class IPPDME_EXT_CLASS std::vector<ippArgItemType>;
EXPIMP_TEMPLATE template class IPPDME_EXT_CLASS std::allocator<ippOtherKeyType>;
EXPIMP_TEMPLATE template class IPPDME_EXT_CLASS std::vector<ippOtherKeyType>;

class IPPDME_EXT_CLASS ippCommandParser
{
public:
  // constructor
  ippCommandParser();

  // destructor
  virtual ~ippCommandParser();

  // @return  the error message associated with the latest error found during parsing
  std::string getErrorMessageString() const; // might add length argument


  bool getIsEvent() const {return _isEvent;}

  ippParserCmdErrorId getParserErr()const{return _errorCode;}
  
  void parseTag();
  int getTag() const{return _tag;}
  
  // @return the parsed commend or a null pointer if the parsing has failed
  ippCommandPtr  parseCommand();
  
  void setInput(const char * input);

  
private:

  int _argCount;                         //<! number of argument components
  std::vector<double>  _argDoubles;       //<! array of doubles for arguments
  unsigned int _argInt;                  //<! used only for tag numbers
  std::vector<ippOtherKeyType> _argKeywords;         //<! array of keywords for arguments
  int _argSize;                          //<! size of argDoubles, argKeywords, etc. 
  std::vector<std::string> _argStrings;  //<! array of pointers to strings for arguments
  std::vector<ippArgItemType> _argTypes; //<! array of argument types
  int _arrayIndex;                       //<! current index for inputArray
  ippCommandNameType _commandName;       //<! enumeration value of command
  ippParserCmdErrorId   _errorCode;      //<! parser error code
  char _inputArray[IPPSIZE];             //<! array to put command in for parsing
  bool _isEvent;                         //<! flag indicating event command
  int _tag;                              //<! tag number of command being parsed


   void makeArraysBigger();

  ippCommandPtr makeCommand();
  ippCommandPtr makeAbortE();
  ippCommandPtr makeAlignPart();
  ippCommandPtr makeAlignTool();
  ippCommandPtr makeCenterPart();
  ippCommandPtr makeChangeTool();
  ippCommandPtr makeClearAllErrors();
  ippCommandPtr makeDisableUser();
  ippCommandPtr makeEnableUser();
  ippCommandPtr makeEndSession();
  ippCommandPtr makeEnumAllProp();
  ippCommandPtr makeEnumProp();
  ippCommandPtr makeEnumTools();
  ippCommandPtr makeFindTool();
  ippCommandPtr makeGet();
  ippCommandPtr makeGetChangeToolAction();
  ippCommandPtr makeGetCoordSystem();
  ippCommandPtr makeGetCsyTransformation();
  ippCommandPtr makeGetDMEVersion();
  ippCommandPtr makeGetErrorInfo();
  ippCommandPtr makeGetErrStatusE();
  ippCommandPtr makeGetMachineClass();
  ippCommandPtr makeGetProp();
  ippCommandPtr makeGetPropE();
  ippCommandPtr makeGetXtdErrStatus();
  ippCommandPtr makeGoTo();
  ippCommandPtr makeHome();
  ippCommandPtr makeIsHomed();
  ippCommandPtr makeIsUserEnabled();
  ippCommandPtr makeLockAxis();
  ippCommandPtr makeOnMoveReportE();
  ippCommandPtr makeOnPtMeasReport();
  ippCommandPtr makeOnScanReport();
  ippCommandPtr makePtMeas();
  ippCommandPtr makeReQualify();
  ippCommandPtr makeScanInCylEndIsPlane();
  ippCommandPtr makeScanInCylEndIsSphere();
  ippCommandPtr makeScanInPlaneEndIsCyl();
  ippCommandPtr makeScanInPlaneEndIsPlane();
  ippCommandPtr makeScanInPlaneEndIsSphere();
  ippCommandPtr makeScanOnCircle();
  ippCommandPtr makeScanOnCircleHint();
  ippCommandPtr makeScanOnLine();
  ippCommandPtr makeScanOnLineHint();
  ippCommandPtr makeScanUnknownHint();
  ippCommandPtr makeScanUnknownDensity();
  ippCommandPtr makeSetCoordSystem();
  ippCommandPtr makeSetCsyTransformation();
  ippCommandPtr makeSetProp();
  ippCommandPtr makeSetTool();
  ippCommandPtr makeStartSession();
  ippCommandPtr makeStopAllDaemons();
  ippCommandPtr makeStopDaemon();
  ippCommandPtr makeTiltCenterPart();
  ippCommandPtr makeTiltPart();

  ippCommandPtr makeEnumToolCollection();
  ippCommandPtr makeEnumAllToolCollections();
  ippCommandPtr makeOpenToolCollection();
  ippCommandPtr makeSaveActiveCoordSystem();
  ippCommandPtr makeLoadCoordSystem();
  ippCommandPtr makeDeleteCoordSystem();
  ippCommandPtr makeEnumCoordSystems();
  ippCommandPtr makeGetNamedCsyTransformation();
  ippCommandPtr makeSaveNamedCsyTransformation();
  ippCommandPtr makeScanOnCurveDensity();
  ippCommandPtr makeScanOnCurveHint();
  ippCommandPtr makeScanOnCurve();
  ippCommandPtr makeScanOnHelix(); 
  ippCommandPtr makePtMeasSelfCenter(); 
  ippCommandPtr makePtMeasSelfCenterLocked(); 


  void parseCmdArguments();
  void parseCmdName();
  void parseData(); // parse a series of numbers
  void parseKeyword();
  void parseNumber(ippArgItemType type);
  void parseString();
  void unSpaceInputArray();


private:
  bool CheckOptionalArgument(
    int& n,
    bool& hasArgument,
    ippOtherKeyType type1,
    ippOtherKeyType type2,
    ippParserCmdErrorId errorIfDuplicated  
  );
  bool CheckOptionalArgument(
    int& n,
    bool& hasArgument,
    ippOtherKeyType type,
    ippParserCmdErrorId errorIfDuplicated  
  );
  bool CheckOptionalArgumentValue(
    int& n,
    bool& hasArgument,
    ippOtherKeyType type,
    ippParserCmdErrorId errorIfDuplicated,
    ippParserCmdErrorId errorIfNotFollowedByNumberInParens,
    double& value
  );
  bool CheckOptionalArgumentValue(
    int& n,
    bool& hasArgument,
    ippOtherKeyType type1,
    ippOtherKeyType type2,
    ippParserCmdErrorId errorIfDuplicated,
    ippParserCmdErrorId errorIfNotFollowedByNumberInParens,
    double& value
  );
  bool CheckOptionalArgumentValue(
    int& n,
    bool& hasArgument,
    ippOtherKeyType type,
    ippParserCmdErrorId errorIfDuplicated,
    ippParserCmdErrorId errorIfNotFollowedByNumberInParens,
    double& valueI,
    double& valueJ,
    double& valueK
  );
  bool CheckOptionalArgumentValue(
    int& n,
    bool& hasArgument,
    ippOtherKeyType type1,
    ippParserCmdErrorId errorIfDuplicated,
    ippParserCmdErrorId errorIfNotFollowedByBooleanInParens,
    bool& value
  );

  double getValue(int index) const;

private:
  ippCommandParser(const ippCommandParser&);
  void operator=(const ippCommandParser&);
};

---