TGM_CNC.h

Go to the documentation of this file.

#ifndef TGM_CNC_H_FILE_INCLUDED
#define TGM_CNC_H_FILE_INCLUDED

#define COMM_DLL_VERSION 355

// standard data types
#include <stdint.h>
#include <string.h>
#include <assert.h>

// include usefull math constants
#define _USE_MATH_DEFINES
#include <math.h>

#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-pedantic" // disable warning about nameless structs
#else
#pragma warning(push)
# pragma warning(disable : 4201) // disable warning: nameless struct/union....
# if _MSC_VER < 1800 // below Visual Studio 2013
#  pragma warning(disable: 4480) // Visual Studio 2010 emits warning for enum with type specified
# endif
#endif

//################################### Constants definitions #######################################

#ifndef MAX_FLOAT
# define MAX_FLOAT 3.402823466e+38
#endif

#ifndef INVALID_VALUE
# define INVALID_VALUE (MAX_FLOAT / 2.)
#endif

#ifndef _countof
# define _countof(array) (sizeof(array)/sizeof(array[0]))
#endif

// suppress compiler warning about unreferenced parameter
// (mainly in no-init optimized constructor)
#ifndef UNREFERENCED_PARAM
# define UNREFERENCED_PARAM(P)          \
{ \
  (void)(P); \
}
#endif

#define MAX_FUNC_ADDRESSES ('Z' - 'A' + 1)

// exporting functions from SF_TCh library
#if defined __linux__ && !defined UNDER_RTSS

# if defined(SF_TCH_LIBRARY)
#  define TOOLCHAIN_DLL_EXPORT  __attribute__((visibility("default")))
#  define CNC_CALC_DLL_EXPORT   __attribute__((visibility("default"))) // swapped!
# else
#  define TOOLCHAIN_DLL_EXPORT  __attribute__((visibility("default")))
#  define CNC_CALC_DLL_EXPORT   __attribute__((visibility("default"))) // swapped!
# endif
# define TOOLCHAIN_CALLTYPE

// prevent multiple typedefs by #define trick

# ifndef TGM_LPCTSTR
#  define TGM_LPCTSTR TGM_LPCTSTR
   typedef const char * TGM_LPCTSTR;
# endif

# ifndef TGM_LPTSTR
#  define TGM_LPTSTR TGM_LPTSTR
   typedef char       * TGM_LPTSTR;
# endif

# ifndef TGM_LPCSTR
#  define TGM_LPCSTR TGM_LPCSTR
   typedef const char * TGM_LPCSTR;
# endif

#elif defined WIN32 // !__linux__

# if defined DOXYGEN
#  define TOOLCHAIN_DLL_EXPORT
# elif defined(SF_TCH_LIBRARY)
#  define TOOLCHAIN_DLL_EXPORT __declspec(dllexport)
#  define CNC_CALC_DLL_EXPORT  __declspec(dllimport) // swapped!
# else
#  define TOOLCHAIN_DLL_EXPORT __declspec(dllimport)
#  define CNC_CALC_DLL_EXPORT  __declspec(dllexport) // swapped!
# endif
# define TOOLCHAIN_CALLTYPE    __cdecl

# if !defined _UNICODE
#  error "_UNICODE must be defined for WIN32"
# endif

// prevent multiple typedefs by #define trick

# ifndef TGM_LPCTSTR
#  define TGM_LPCTSTR TGM_LPCTSTR
   typedef const wchar_t * TGM_LPCTSTR;
# endif

# ifndef TGM_LPTSTR
#  define TGM_LPTSTR TGM_LPTSTR
   typedef wchar_t       * TGM_LPTSTR;
# endif

# ifndef TGM_LPCSTR
#  define TGM_LPCSTR TGM_LPCSTR
   typedef const char * TGM_LPCSTR;
# endif

#else // ARM or Xenomai

// on ARM all default strings are ANSI (8bit)
# ifndef TGM_LPCTSTR
#  define TGM_LPCTSTR TGM_LPCTSTR
   typedef const char * TGM_LPCTSTR;
# endif

# ifndef TGM_LPTSTR
#  define TGM_LPTSTR TGM_LPTSTR
   typedef char       * TGM_LPTSTR;
# endif

// explicit ANSI string type
# ifndef TGM_LPCSTR
#  define TGM_LPCSTR TGM_LPCSTR
   typedef const char * TGM_LPCSTR;
# endif

# define TOOLCHAIN_DLL_EXPORT
# define CNC_CALC_DLL_EXPORT
# define TOOLCHAIN_CALLTYPE

#endif // ARM


#define TOOL_CHAIN_BAD_INTR_INDEX  (-2)  
#define TOOL_CHAIN_ERROR           (-1)  
#define TOOL_CHAIN_SUCCESS            0  
#define TOOL_CHAIN_XEXEC              1  
#define TOOL_CHAIN_XBREAK             2  

#define ACTUAL_N_AXES (sizeof(P10DOUBLE) / sizeof(double))

#define START_CNC_SIMULATION           10 
#define START_CNC_TEST                 20 
#define START_CNC_FORWARD              30 
#define START_CNC_FORWARD_NO_MFUNC     31 
#define START_CNC_BACKWARD             32 
#define START_CNC_FORWARD_SKIP_FIRST_M 33 
#define START_CNC_CONNECT              40 
#define START_CNC_CONNECT_MOVE         41 
#define START_CNC_GOTO_POSITION        50 
#define START_CNC_CALCULATING          60 
#define START_CNC_HELP                999 

#define RESET_CNC_NO_G92 1 

#ifndef MAX_DECLARED_PARAMS
# define NUMBER_OF_VARIABLES 100
# define SUB_PARS 50
# define MAX_DECLARED_PARAMS (NUMBER_OF_VARIABLES + SUB_PARS)
# define MAXLABELLENGTH 40
#endif

#define MAX_M_FUNC_IN_G (4)

#ifndef ADDR_IDX
// simplify G-code address indexing
# define ADDR_IDX(w) ((w) - 'A')
# define G_FUNC_IDX ADDR_IDX('G')
# define M_FUNC_IDX ADDR_IDX('M')
# define X_ADDR_IDX ADDR_IDX('X')
# define Y_ADDR_IDX ADDR_IDX('Y')
# define Z_ADDR_IDX ADDR_IDX('Z')
# define C_ADDR_IDX ADDR_IDX('C')
# define F_ADDR_IDX ADDR_IDX('F')
# define S_ADDR_IDX ADDR_IDX('S')
#endif

//################################### Enumerations ################################################

enum cnc_status : int32_t
{
  statusOFFLINE = -2,
  statusSENDING_GCODE_TO_REMOTE_DEVICE = -3,
  statusINVALID = 0,
  statusCOMPILING = 1,
  statusCOMPILE_FINISHED = -1,
  statusSIMULATING = START_CNC_SIMULATION,
  statusSIMULATION_END = -10,
  statusSIMULATION_BREAK = -11,
  statusTEST = START_CNC_TEST,
  statusTEST_END = -20,
  statusTEST_BREAK = -21,

  statusTRAJECTORY_START = -30,
  statusTRAJECTORY_BREAK = -31,
  statusTRAJECTORY_END = -32,
  statusTRAJECTORY_BREAK_M0 = -33,
  statusFORWARD = START_CNC_FORWARD,
  statusFORWARD_NO_MFUNC = START_CNC_FORWARD_NO_MFUNC,
  statusBACKWARD = START_CNC_BACKWARD,
  statusFORWARD_SKIP_FIRST_M = START_CNC_FORWARD_SKIP_FIRST_M,

  statusCONNECTING = 40,
  statusCONNECT_MOVE = 41,

  statusHAND_MOVE = 50,
  statusOUT_OF_TRAJECTORY = -50,
  statusCALCULATING = START_CNC_CALCULATING,
  statusSTART_M_FUNCS = 70,
  statusSTOP_M_FUNCS = 80,
  statusCONNECT_INS_M_FUNCS = 90,

  statusNONSENSE = -1234,
};

enum connect_type : int32_t
{
  connectBY_COORD = 0, 
  connectBY_LINE_START = 1, 
  connectBY_LINE_END = 2, 
  connectBY_COORD_GO = 10,
  connectBY_LINE_START_GO = 11, 
  connectBY_LINE_END_GO = 12,
  connectBY_M_FUNC_COUNT = 20,
  connectBY_M_FUNC_COUNT_REL = 21, 
  connectBY_GCODE_INDEX = 30,              
  connectBY_GCODE_INDEX_ACTUAL_COORD = 31, 
  connectBY_GCODE_INDEX_END = 32,
  connectBY_COORD_GO_BUFFERED = 40,
  connectBY_LINE_START_GO_BUFFERED = 41,
  connectBY_LINE_END_GO_BUFFERED = 42,
};

enum axis_idx : int32_t
{
  AXIS_NONE = -1,  
  AXIS_X = 0,      
  AXIS_Y,          
  AXIS_Z,          
  AXIS_C,          
  AXIS_B,          
  AXIS_U,          
  AXIS_V,          
  AXIS_W,          
  AXIS_A,          
  AXIS_O,          
  AXIS_S = 100,    
  AXIS_T,          
  AXIS_IO,         
  AXIS_S2,         
  AXIS_XY = 200    
};


//################################### Structures declaration ######################################

struct SIMPLE_INFO
{
  uint32_t m_editorLine; 
  int32_t  m_fileIdx;    
  int32_t  m_gCodeIndex; 
};

struct GM_PARAMS_ENHANCED
{
  double m_setFeed;             
  double m_calcFeed;            
  double m_actFeed;             
  double m_relFeed;             
  double m_actPartLen;          
  double m_actPartRemain;       
  double m_actWorkPartsLen;     
  double m_actG00PartsLen;      
  double m_actPartsLen;         
  int32_t  m_nWorkCounter;      
  int32_t  m_nG00Counter;       
  int32_t  m_nG00ToWorkChanges; 
  int32_t  m_nWorkToG00Changes; 
  int32_t  m_nMCounter;         
  uint32_t m_MasterEditorLine;  
  int32_t  m_MasterFileIdx;     
  int32_t  m_statusCNC;         
  double   m_cncRunTime;        
};

struct P10DOUBLE
{
  // use union -> allow different naming convention or loops
  union
  {
    // using anonymous struct
    struct // all axes as separate members
    {
      double x_axis;   
      double y_axis;   
      double z_axis;   
      double c_axis;   
      double b_axis;   
      double u_axis;   
      double v_axis;   
      double w_axis;   
      double a_axis;   
      double o_axis;   
    };
    struct
    {
      double xyzcbuvwao[10]; 
    };
    struct // legacy variables naming
    {
      double x;         
      double y;         
      double z;         
      double c;         
      double buvwao[6]; 
    };
  };
  // member methods
  // --------------
  P10DOUBLE(double xVal, double yVal, double zVal, double cVal,
            double bVal = 0.0, double uVal = 0.0, double vVal = 0.0,
            double wVal = 0.0, double aVal = 0.0, double oVal = 0.0)
            : x_axis(xVal)
            , y_axis(yVal)
            , z_axis(zVal)
            , c_axis(cVal)
            , b_axis(bVal)
            , u_axis(uVal)
            , v_axis(vVal)
            , w_axis(wVal)
            , a_axis(aVal)
            , o_axis(oVal)
  {
  }
  P10DOUBLE()
  {
    // use optimized memset instead of settings all the parameters to zero
    memset(this, 0, sizeof(P10DOUBLE));
  }
  explicit P10DOUBLE(bool bNoInit) // -V730
  {
    UNREFERENCED_PARAM(bNoInit);
  }
  P10DOUBLE(const P10DOUBLE &n)
  {
    // use c library optimized memcpy instead of setting all the members one-to-one
    memcpy(this, &n, sizeof(P10DOUBLE));
  }
  P10DOUBLE &operator=(const P10DOUBLE &n)
  {
    if (this != &n)
    {
      memcpy(this, &n, sizeof(P10DOUBLE));
    }
    return *this;
  }

  void CopyFrom(const P10DOUBLE &n)
  {
    memcpy(this, &n, sizeof(P10DOUBLE));
  }

  void SetToZero()
  {
    // use optimized memset instead of settings all the parameters to zero
    memset(this, 0, sizeof(P10DOUBLE));
  }
  void SetAllToValue(double val)
  {
    for (size_t i = 0; i < _countof(xyzcbuvwao); i++)
      xyzcbuvwao[i] = val;
  }

  // usefull operators
  P10DOUBLE &operator+=(const P10DOUBLE &n)
  {
    // optimizer might unroll the loop
    for (size_t i = 0; i < _countof(xyzcbuvwao); i++)
      xyzcbuvwao[i] += n.xyzcbuvwao[i];
    return *this;
  }
  P10DOUBLE &operator+=(const double n)
  {
    for (size_t i = 0; i < _countof(xyzcbuvwao); i++)
      xyzcbuvwao[i] += n;
    return *this;
  }
  P10DOUBLE &operator-=(const P10DOUBLE &n)
  {
    for (size_t i = 0; i < _countof(xyzcbuvwao); i++)
      xyzcbuvwao[i] -= n.xyzcbuvwao[i];
    return *this;
  }
  P10DOUBLE &operator-=(const double n)
  {
    for (size_t i = 0; i < _countof(xyzcbuvwao); i++)
      xyzcbuvwao[i] -= n;
    return *this;
  }

  int operator<(const double n) const
  {
    return x_axis < n && y_axis < n && z_axis < n && c_axis < n && 
      b_axis < n && u_axis < n && v_axis < n &&
      w_axis < n && a_axis < n && o_axis < n;
  }

  // divide operator
  P10DOUBLE &operator/=(const double val)
  {
    assert(fabs(val) >= 1e-12);
    double val1x = 1.0;
    if (fabs(val) >= 1e-12)
    {
      val1x /= val;
    }
    for (size_t i = 0; i < _countof(xyzcbuvwao); i++)
      xyzcbuvwao[i] *= val1x;
    return *this;
  }

  // multiply operator
  P10DOUBLE &operator*=(const double val)
  {
    for (size_t i = 0; i < _countof(xyzcbuvwao); i++)
      xyzcbuvwao[i] *= val;
    return *this;
  }

  // Add operator
  friend P10DOUBLE operator+(const P10DOUBLE &a, const P10DOUBLE &b)
  {
    return P10DOUBLE(a.x_axis + b.x_axis, 
                     a.y_axis + b.y_axis, 
                     a.z_axis + b.z_axis, 
                     a.c_axis + b.c_axis, 
                     a.b_axis + b.b_axis,
                     a.u_axis + b.u_axis, 
                     a.v_axis + b.v_axis, 
                     a.w_axis + b.w_axis,
                     a.a_axis + b.a_axis, 
                     a.o_axis + b.o_axis);
  }
  // subtract operator
  friend P10DOUBLE operator-(const P10DOUBLE &a, const P10DOUBLE &b)
  {
    return P10DOUBLE(a.x_axis - b.x_axis,
                     a.y_axis - b.y_axis,
                     a.z_axis - b.z_axis,
                     a.c_axis - b.c_axis,
                     a.b_axis - b.b_axis,
                     a.u_axis - b.u_axis,
                     a.v_axis - b.v_axis,
                     a.w_axis - b.w_axis,
                     a.a_axis - b.a_axis,
                     a.o_axis - b.o_axis);
  }
  // unary minus operator
  friend P10DOUBLE operator-(const P10DOUBLE &a)
  {
    return P10DOUBLE(-a.x_axis,
                     -a.y_axis,
                     -a.z_axis,
                     -a.c_axis,
                     -a.b_axis,
                     -a.u_axis,
                     -a.v_axis,
                     -a.w_axis,
                     -a.a_axis,
                     -a.o_axis);
  }

  friend P10DOUBLE operator*(const P10DOUBLE &a, const double val)
  {
    return P10DOUBLE(a.x_axis * val,
                     a.y_axis * val,
                     a.z_axis * val,
                     a.c_axis * val,
                     a.b_axis * val,
                     a.u_axis * val,
                     a.v_axis * val,
                     a.w_axis * val,
                     a.a_axis * val,
                     a.o_axis * val);
  }

  // internal inline public functions declared in a separate file (CNC_cncpars2005.h)
  // compare to closeness
  intptr_t IsNearToAll(const P10DOUBLE &a, double threshold) const;
  intptr_t IsNearToAllByPlane(const P10DOUBLE &a, double threshold, intptr_t plane) const;
  intptr_t IsNearToAll_CheckInvalidValue(const P10DOUBLE &a, const P10DOUBLE &threshold) const;
  intptr_t IsNearToAll_CheckInvalidValue(const P10DOUBLE &a, double threshold) const;
  intptr_t IsNearToXYZC(const P10DOUBLE &a, double threshold) const;
  intptr_t IsNearToXYZ(const P10DOUBLE &a, double threshold) const;
  intptr_t IsNearToZCBUVWAO(const P10DOUBLE &a, double threshold) const;
  intptr_t IsNearToXY(const P10DOUBLE &a, double threshold) const;
  intptr_t IsOutOfXY(const P10DOUBLE &a, double threshold) const;
  // if any member is larger than INVALID_VALUE (i.e. > 1e-38), reset to zero
  void ResetInvalidPositions();
  // calculate distance to zero
  double Length() const
  {
    double squareLen = 0.0;
    for (size_t i = 0; i < _countof(xyzcbuvwao); i++)
    {
      squareLen += xyzcbuvwao[i] * xyzcbuvwao[i];
    }
    return sqrt(squareLen);
  }
  // calculate length of line
  double Length(const P10DOUBLE &n) const
  {
    double dx = 0.0, dy = 0.0, dz = 0.0, dc = 0.0;
    double d0 = 0.0, d1 = 0.0, d2 = 0.0, d3 = 0.0, d4 = 0.0, d5 = 0.0;
    if (x < INVALID_VALUE)  dx = x;
    if (y < INVALID_VALUE)  dy = y;
    if (z < INVALID_VALUE)  dz = z;
    if (c < INVALID_VALUE)  dc = c;
    if (buvwao[0] < INVALID_VALUE)  d0 = buvwao[0];
    if (buvwao[1] < INVALID_VALUE)  d1 = buvwao[1];
    if (buvwao[2] < INVALID_VALUE)  d2 = buvwao[2];
    if (buvwao[3] < INVALID_VALUE)  d3 = buvwao[3];
    if (buvwao[4] < INVALID_VALUE)  d4 = buvwao[4];
    if (buvwao[5] < INVALID_VALUE)  d5 = buvwao[5];
    if (n.x < INVALID_VALUE)  dx -= n.x;
    if (n.y < INVALID_VALUE)  dy -= n.y;
    if (n.z < INVALID_VALUE)  dz -= n.z;
    if (n.c < INVALID_VALUE)  dc -= n.c;
    if (n.buvwao[0] < INVALID_VALUE)  d0 -= n.buvwao[0];
    if (n.buvwao[1] < INVALID_VALUE)  d1 -= n.buvwao[1];
    if (n.buvwao[2] < INVALID_VALUE)  d2 -= n.buvwao[2];
    if (n.buvwao[3] < INVALID_VALUE)  d3 -= n.buvwao[3];
    if (n.buvwao[4] < INVALID_VALUE)  d4 -= n.buvwao[4];
    if (n.buvwao[5] < INVALID_VALUE)  d5 -= n.buvwao[5];
    return sqrt(dx * dx + dy * dy + dz * dz + dc * dc + d0 * d0 + d1 * d1 + d2 * d2 + d3 * d3 +
                d4 * d4 + d5 * d5);
  }
  // square lengths
  double SquareLength(const P10DOUBLE &n) const;
  double SquareLengthXYZCBU(const P10DOUBLE &n) const;
  double SquareLengthXYZ_BU_NoC(const P10DOUBLE &n) const;
  double SquareLengthXYZC(const P10DOUBLE &n) const;
  double SquareLengthXYZ(const P10DOUBLE &n) const;
  double SquareLengthXY(const P10DOUBLE &n) const;

  void Round(double accuracy, double accuracy1x);
  void RoundXY(double accuracy, double accuracy1x);
};


struct P10BOOL
{
  // use union -> allow different naming convention or loops
  union
  {
    struct // all axes as separate members
    {
      int32_t x_axis;   
      int32_t y_axis;   
      int32_t z_axis;   
      int32_t c_axis;   
      int32_t b_axis;   
      int32_t u_axis;   
      int32_t v_axis;   
      int32_t w_axis;   
      int32_t a_axis;   
      int32_t o_axis;   
    };
    struct
    {
      int32_t xyzcbuvwao[10]; 
    };
    struct // legacy variables naming
    {
      int32_t x;         
      int32_t y;         
      int32_t z;         
      int32_t c;         
      int32_t buvwao[6]; 
    };
  };
  P10BOOL(int32_t _x, int32_t _y, int32_t _z, int32_t _c, 
          int32_t _b, int32_t _u, int32_t _v, int32_t _w, int32_t _a, int32_t _o)
    : x_axis(_x)
    , y_axis(_y)
    , z_axis(_z)
    , c_axis(_c)
    , b_axis(_b)
    , u_axis(_u)
    , v_axis(_v)
    , w_axis(_w)
    , a_axis(_a)
    , o_axis(_o)
  {
  }
  P10BOOL() { memset(this, 0, sizeof(P10BOOL)); }
  P10BOOL(const P10BOOL &n) { memcpy(this, &n, sizeof(P10BOOL)); }
  P10BOOL &operator=(const P10BOOL &n)
  {
    if (&n == this)
      return *this;
    memcpy(this, &n, sizeof(P10BOOL));
    return *this;
  }
};


// internal structures
// simplified circle description
struct P4CIRCLE
{
  double x; // circle center X
  double y; // circle center Y
  double z; // circle center Z
  double c; // radius

  // constructor
  P4CIRCLE(double _x, double _y, double _z, double _c) : x(_x), y(_y), z(_z), c(_c) {}
  // default constructor
  P4CIRCLE() { memset(this, 0, sizeof(P4CIRCLE)); }
  // no init contructor
  explicit P4CIRCLE(bool bNoInit) // -V730
  {
    UNREFERENCED_PARAM(bNoInit);
  }
  // copy constructor
  P4CIRCLE(const P4CIRCLE &n) { memcpy(this, &n, sizeof(P4CIRCLE)); }
  // Assign operator
  P4CIRCLE &operator=(const P4CIRCLE &n)
  {
    if (this != &n)
      memcpy(this, &n, sizeof(P4CIRCLE));
    return *this;
  }

  void SetToZero() { memset(this, 0, sizeof(P4CIRCLE)); }

  inline P4CIRCLE &operator+=(const P4CIRCLE &n)
  {
    x += n.x; y += n.y; z += n.z; c += n.c;
    return *this;
  }
  // += operator
  inline P4CIRCLE &operator+=(const double n)
  {
    x += n; y += n; z += n; c += n;
    return *this;
  }
  inline P4CIRCLE &operator-=(const P4CIRCLE &n)
  {
    x -= n.x; y -= n.y; z -= n.z; c -= n.c;
    return *this;
  }
  // += operator
  inline P4CIRCLE &operator-=(const double n)
  {
    x -= n; y -= n; z -= n; c -= n;
    return *this;
  }

  inline int operator<(const double n) { return x < n && y < n && z < n && c < n; }

  // divide operator
  inline P4CIRCLE &operator/=(const double val)
  {
    assert(fabs(val) >= 1e-12);
    if (fabs(val) >= 1e-12)
    {
      double val1x = 1.0 / val;
      x *= val1x; y *= val1x; z *= val1x; c *= val1x;
    }
    return *this;
  }

  // multiply operator
  inline P4CIRCLE &operator*=(const double val)
  {
    x *= val; y *= val; z *= val;c *= val;
    return *this;
  }

  // Add operator
  friend inline P4CIRCLE operator+(const P4CIRCLE &a, const P4CIRCLE &b)
  {
    return P4CIRCLE(a.x + b.x, a.y + b.y, a.z + b.z, a.c + b.c);
  }
  // subtract operator
  friend inline P4CIRCLE operator-(const P4CIRCLE &a, const P4CIRCLE &b)
  {
    return P4CIRCLE(a.x - b.x, a.y - b.y, a.z - b.z, a.c - b.c);
  }
  // unary minus operator
  friend inline P4CIRCLE operator-(const P4CIRCLE &a) 
  { 
    return P4CIRCLE(-a.x, -a.y, -a.z, -a.c); 
  }

  friend inline P4CIRCLE operator*(const P4CIRCLE &a, const double val)
  {
    return P4CIRCLE(a.x * val, a.y * val, a.z * val, a.c * val);
  }

  void SetAllToValue(double val) { x = y = z = c = val; }

  intptr_t IsNearToAll(const P10DOUBLE &a, double threshold) const;
  intptr_t IsNearToAll(const P4CIRCLE &a, double threshold) const;
  intptr_t IsNearToAllByPlane(const P10DOUBLE &a, double threshold, intptr_t plane) const;
  intptr_t IsNearToAll_CheckInvalidValue(const P10DOUBLE &a, const P10DOUBLE &threshold) const;
  intptr_t IsNearToAll_CheckInvalidValue(const P10DOUBLE &a, double threshold) const;
  intptr_t IsNearToXYZC(const P10DOUBLE &a, double threshold) const;
  intptr_t IsNearToXYZ(const P10DOUBLE &a, double threshold) const;
  intptr_t IsNearToXY(const P10DOUBLE &a, double threshold) const;
  intptr_t IsOutOfXY(const P10DOUBLE &a, double threshold) const;
  void ResetInvalidPositions();
  double Length() const { return sqrt(x * x + y * y + z * z + c * c); }
  double Length(const P10DOUBLE &n) const;
  double SquareLength(const P10DOUBLE &n) const;
  double SquareLengthXYZC(const P10DOUBLE &n) const;
  double SquareLengthXYZ(const P10DOUBLE &n) const;
  double SquareLengthXY(const P10DOUBLE &n) const;
  void Round(double accuracy, double accuracy1x);
  void RoundXY(double accuracy, double accuracy1x);

private:
  int64_t roundTo64bitInt(double v)
  {
    return static_cast<int64_t>(v >= 0.0 ? v + 0.5 : v - 0.5); // -V2003
  }
};


struct SIMPLE_GM_PARAMS_BASE
{
  P10DOUBLE m_s;                       
  P10DOUBLE m_e;                       
  P10DOUBLE m_calcS;                   
  P10DOUBLE m_calcE;                   
//  P10DOUBLE m_zero;                    //!< actual zero offset (G54 - G57)
  P4CIRCLE  m_cc;                      
  float m_pars[MAX_FUNC_ADDRESSES];    
  int32_t m_func;                      
  int32_t m_planeTool;
  uint32_t m_reserved;    
  uint32_t m_editorLine;  
  int32_t  m_fileIdx;     
  int32_t  m_gCodeIndex;
  int32_t  m_bFeedIsMin;  
  float m_fp;

#ifdef __cplusplus
  // no init contructor (optimization)
  explicit SIMPLE_GM_PARAMS_BASE(bool bNoInit) // -V730
    : m_s(bNoInit)
    , m_e(bNoInit)
    , m_calcS(bNoInit)
    , m_calcE(bNoInit)
//    , m_zero(bNoInit)
    , m_cc(bNoInit)
  {
    UNREFERENCED_PARAM(bNoInit);
  }
  SIMPLE_GM_PARAMS_BASE() : 
    m_s(), 
    m_e(), 
    m_calcS(), 
    m_calcE(), 
//    m_zero(), 
    m_cc() // -V730
  {
    // optimization: other members MUST initialized in the derived class SIMPLE_GM_PARAMS
  }
  SIMPLE_GM_PARAMS_BASE(const SIMPLE_GM_PARAMS_BASE &n)
    : m_s(false)
    , m_e(false)
    , m_calcS(false)
    , m_calcE(false)
//    , m_zero(false)
    , m_cc(false)
  {
    memcpy(this, &n, sizeof(SIMPLE_GM_PARAMS_BASE));
  }
  SIMPLE_GM_PARAMS_BASE &operator=(const SIMPLE_GM_PARAMS_BASE &n)
  {
    if (this != &n)
      memcpy(this, &n, sizeof(SIMPLE_GM_PARAMS_BASE));
    return *this;
  }
#endif // __cplusplus

};

struct SIMPLE_GM_PARAMS_WIN32
{
  P10DOUBLE m_s;                     
  P10DOUBLE m_e;                     
  P10DOUBLE m_calcS;                 
  P10DOUBLE m_calcE;                 
  P10DOUBLE m_zero;                  
  P10DOUBLE m_cc;                    
  float m_pars[MAX_FUNC_ADDRESSES];  

  int32_t m_func;
  int32_t m_planeTool;
  uint32_t m_reserved;   
  uint32_t m_editorLine; 
  int32_t  m_fileIdx;    
  int32_t  m_gCodeIndex; 
  int32_t  m_bFeedIsMin;  
  float m_fp;          
  
  // constructor
  // optimization: uses no-init contructors of P10DOUBLE members
  SIMPLE_GM_PARAMS_WIN32()
    : m_s(false)
    , m_e(false)
    , m_calcS(false)
    , m_calcE(false)
    , m_zero(false)
    , m_cc(false)
  { 
    memset(this, 0, sizeof(SIMPLE_GM_PARAMS_WIN32)); 
  }
  SIMPLE_GM_PARAMS_WIN32(const SIMPLE_GM_PARAMS_WIN32 &n)
    : m_s(false)
    , m_e(false)
    , m_calcS(false)
    , m_calcE(false)
    , m_zero(false)
    , m_cc(false)
  {
    memcpy(this, &n, sizeof(SIMPLE_GM_PARAMS_WIN32));
  }
  SIMPLE_GM_PARAMS_WIN32(const SIMPLE_GM_PARAMS_BASE &n, const P10DOUBLE &zero) 
    : m_s(false)
    , m_e(false)
    , m_calcS(false)
    , m_calcE(false)
    , m_zero(false)
    , m_cc(false)
  {
    CopyFrom(n, zero);
  }
  SIMPLE_GM_PARAMS_WIN32 &operator=(const SIMPLE_GM_PARAMS_WIN32 &n)
  {
    if (this != &n)
      memcpy(this, &n, sizeof(SIMPLE_GM_PARAMS_WIN32));
    return *this;
  }
  // auxiliary methods
  void CopyFrom(const SIMPLE_GM_PARAMS_BASE &n, const P10DOUBLE &zero)
  {
    static_assert(sizeof(m_pars) == sizeof(n.m_pars),
                  "Size of SIMPLE_GM_PARAMS_BASE::m_pars and SIMPLE_GM_PARAMS_WIN32::m_pars must be the same");
    m_s.CopyFrom(n.m_s);
    m_e.CopyFrom(n.m_e);
    m_calcS.CopyFrom(n.m_calcS);
    m_calcE.CopyFrom(n.m_calcE);
    m_zero.CopyFrom(zero);
    m_cc.x = n.m_cc.x;
    m_cc.y = n.m_cc.y;
    m_cc.z = n.m_cc.z;
    m_cc.c = n.m_cc.c;
    memcpy(m_pars, n.m_pars, sizeof(m_pars));
    m_func = n.m_func;
    m_planeTool = n.m_planeTool;
    m_reserved = n.m_reserved;
    m_editorLine = n.m_editorLine;
    m_fileIdx = n.m_fileIdx;
    m_gCodeIndex = n.m_gCodeIndex;
    m_bFeedIsMin = n.m_bFeedIsMin;
    m_fp = n.m_fp;
  }

  void Func(const int32_t f)
  {
    m_func = f;
  }

  void Feed(const double f, const int32_t bIsMin)
  {
    m_pars[F_ADDR_IDX] = static_cast<float>(f);
    if (bIsMin)
      m_bFeedIsMin |= 1;
    else
      m_bFeedIsMin &= ~1;
  }

  void Spindle(const double s)
  {
    m_pars[S_ADDR_IDX] = static_cast<float>(s);
  }

  void AssignmentIdx(const int32_t p)
  {
    m_planeTool = p;
  }

  void GCodeIndex(const int32_t idx)
  {
    m_gCodeIndex = idx;
  }
};


struct CALLBACK_INFO
{
  int32_t stringId;       
  int32_t nLines;         
  int32_t actLine;        
  int32_t fileIdx;        
  TGM_LPCSTR m_fullError; 
  TGM_LPCSTR m_errorArguments;

  CALLBACK_INFO() : stringId(-1), nLines(0), actLine(0), fileIdx(-1)
  {
    m_fullError = nullptr;
    m_errorArguments = nullptr;
  }
  CALLBACK_INFO(int _stringId) : stringId(_stringId), nLines(0), actLine(0), fileIdx(-1)
  {
    m_fullError = nullptr;
    m_errorArguments = nullptr;
  }
};


// G-code parameters:

struct GCODE_FEED
{
  double feed;      
  double acc;       
  double dec;       
  int32_t rampType; 
  int32_t padding1; 
};

struct AXIS_LIMITS
{
  double maxFeed; 
  double maxAcc;  
  double maxDec;  
};

struct GCODE_CORRECTION
{
  double size;      
  int32_t gCode;    
  int32_t padding1; 
};

struct ARC_FEED_TABLE
{
  double m_r;       
  double m_relFeed; 
};

struct INTERNAL_MFUNC_INSERT_TABLE
{
  int32_t mFunc;  
  double relFeed; 
  double distance; 
};

struct GCODE_PARAMETERS
{
  int32_t absMode;

  int32_t swapG2G3;

#define CORR_STRATEGY_G41_ALREADY_CORRECTED 0
#define CORR_STRATEGY_G41_STARTS_CORRECTION 1
#define CORR_STRATEGY_MASK 0xFF

#define CORR_STRATEGY_OLD_VERSION 0x80000000

#define CORR_STRATEGY_G00_WITHOUT_CORR       0x40000000

#define CORR_STRATEGY_FORCE_TO_CONTINUE      0x20000000  

#define CORR_STRATEGY_CHECK_ORIGINAL_GCODE   0x02000000

#define CORR_STRATEGY_REMOVE_LAST_ARC        0x01000000

#define CORR_STRATEGY_REMOVE_FIRST_ARC       0x00800000

#define CORR_STRATEGY_NO_ADD_R               0x00400000 

#define CORR_STRATEGY_REMOVE_SMALL_ARCS      0x00200000

#define CORR_STRATEGY_ALLOW_REVERSE_LINES    0x00100000

#define CORR_STRATEGY_REMOVE_CROSSES         0x00080000

#define CORR_STRATEGY_CONNECT_WRONG_BY_G1    0x00040000

#define CORR_STRATEGY_CONNECT_WRONG_BY_MOVE  0x00020000

#define CORR_STRATEGY_ALLOW_FIRST_LAST_CROSS 0x00010000

#define CORR_STRATEGY_SEARCH_MASK            0x00000700

#define CORR_STRATEGY_SEARCH_DEEP_10         0x00000100
#define CORR_STRATEGY_SEARCH_DEEP_50         0x00000200
#define CORR_STRATEGY_SEARCH_DEEP_100        0x00000300
#define CORR_STRATEGY_SEARCH_DEEP_500        0x00000400
#define CORR_STRATEGY_SEARCH_DEEP_1000       0x00000500
#define CORR_STRATEGY_SEARCH_DEEP_2000       0x00000600
#define CORR_STRATEGY_SEARCH_DEEP_ALL        0x00000700

#define CORR_STRATEGY_DEFAULT_DEEP           1000
#define CORR_STRATEGY_MIN_DEEP               10

  int32_t correctionStrategy;


#define F_BY_GCODE                  0
#define F_BY_PARAMETERS             1
#define F_BY_PARAMETERS_FP_BY_GCODE 2

  int32_t forceMode;

  // indexes to feed table
#define DEF_GCODE_FEED_G00            0
#define DEF_GCODE_FEED_G01            1
#define DEF_GCODE_FEED_REVERSE        2
#define DEF_GCODE_FEED_CONNECT        3
#define DEF_GCODE_FEED_WITHOUT_M      4
#define DEF_GCODE_FEED_GOTO_POSITION  5
#define DEF_GCODE_FEED_NORMAL_STOP    6
#define DEF_GCODE_FEED_EMERGENCY_STOP 7

  GCODE_FEED motion[8];

  GCODE_CORRECTION correction[8];

  double maxConnectionDistance;
  double startAngle;
  double endAngle;
  double minAngleFeed;
  int32_t disableG0FeedOverride;
  int32_t interpolatorConfig0;
  double overrideInc;

  ARC_FEED_TABLE arcFeedTable[5];
  double centripetalAcc;

  INTERNAL_MFUNC_INSERT_TABLE mFuncInsertTable[3];
  int32_t mFuncInsertType;
  int32_t callbackWarningsInvokeMode;

  double reserved;

  int32_t M02_programEnd1;
  int32_t M30_programEnd2;
  int32_t M03_startSpindleCW;
  int32_t M04_startSpindleCCW;
  int32_t M05_stopSpindle;
  int32_t M06_changeTool;
  int32_t M07_coolOn;
  int32_t M08_oilOn;
  int32_t M09_coolOilOff;
  int32_t M17_return;
  int32_t M29_print;
  int32_t M80_mirrorOff;
  int32_t M81_mirrorX;
  int32_t M82_mirrorY;
  int32_t M83_mirrorZ;
  int32_t M84_mirrorXY;
  int32_t M85_mirrorXZ;
  int32_t M86_mirrorYZ;
  int32_t M87_mirrorXYZ;
  int32_t M99_defFeed;

  int32_t insertArcMode;

#define DISABLE_OPCODE_CALL             0x00000001
#define DISABLE_ASSIGN_CALL             0x00000002
#define DISABLE_REFRESH_ALL_PARAMS_CALL 0x00000004
  int32_t disableAdditionalProgramFlowInfo;
  double insertArcToleranceRMax;
  double insertArcToleranceRMin;
  double insertArcMaxAngle;
  double insertArcMinAngle;
  int32_t insertArcPlane;
  int32_t reserved1; 
  int32_t calcTime;
  int32_t reserved2;
  double dynamicG41Correction_mm;
  double dynamicG42Correction_mm;
  AXIS_LIMITS axisLimits[ACTUAL_N_AXES];
  double dynamicG41Correction_percent;
  double dynamicG42Correction_percent;

  // indexes to tolerance array
#define GCODE_ALLOWED_CIRC_CENTER_ACCURACY         0
#define GCODE_CROSSING_ACCURACY                    1
#define GCODE_ANGULAR_PRECISION                    2
#define GCODE_ANGULAR_DISTANCE_PRECISION           3
#define GCODE_MINIMAL_ALLOWED_ARC_R                4
#define GCODE_NO_ADD_R_MULTIPLIER                  5
#define GCODE_SOURCE_PRECISION                     6
#define GCODE_MINIMAL_ALLOWED_LINE_LENGTH          7

  double tolerance[10];

#ifdef __cplusplus
  // constructor
  GCODE_PARAMETERS()
  {
    memset(this, 0, sizeof(GCODE_PARAMETERS));
    absMode = 1;
    startAngle = 360.0; // disable angle override by default
    endAngle = 360.0;
    M02_programEnd1 = 2;
    M30_programEnd2 = 30;
    M03_startSpindleCW = 3;
    M04_startSpindleCCW = 4; // -V112
    M05_stopSpindle = 5;
    M06_changeTool = 6;
    M07_coolOn = 7;
    M08_oilOn = 8;
    M09_coolOilOff = 9;
    M17_return = 17;
    M29_print = 29;
    M80_mirrorOff = 80;
    M81_mirrorX = 81;
    M82_mirrorY = 82;
    M83_mirrorZ = 83;
    M84_mirrorXY = 84;
    M85_mirrorXZ = 85;
    M86_mirrorYZ = 86;
    M87_mirrorXYZ = 87;
    M99_defFeed = 99;
    insertArcToleranceRMax = 0.03;
    insertArcToleranceRMin = 0.03;

    tolerance[GCODE_ALLOWED_CIRC_CENTER_ACCURACY] = 0.005;
    tolerance[GCODE_CROSSING_ACCURACY] = 0.001;
    tolerance[GCODE_ANGULAR_PRECISION] = 0.03;
    tolerance[GCODE_ANGULAR_DISTANCE_PRECISION] = 0.005;
    tolerance[GCODE_NO_ADD_R_MULTIPLIER] = 3.0;
    tolerance[GCODE_SOURCE_PRECISION] = 0.01;
  }
#endif // __cplusplus
};


struct P4CIRCLE; // internal struct forward declaration

struct GCODE_SIZE
{
public:
  P10DOUBLE m_startPos;   
  P10DOUBLE m_endPos;     
  P10DOUBLE m_minimalPos; 
  P10DOUBLE m_maximalPos; 
  
  // internal functions
  void SetStartPos(const P10DOUBLE &start);
  void MinMaxLine(const P10DOUBLE &end);
  void MinMaxCirc(const int type, const int plane, const P10DOUBLE &start, const P10DOUBLE &end,
                  const P4CIRCLE &cc);

protected:
  int angleQuadrant(double x, double y, int type) const;
  void getMinMax(const int type, const int plane, double &minX, double &minY, double &minZ,
                 double &maxX, double &maxY, double &maxZ, const P4CIRCLE &cc, int fq,
                 int sq) const;
};

struct GCODE_INFO
{
// indexes to size array
#define GCODE_SIZE_ORIGINAL_IDX      0
#define GCODE_SIZE_CORRECTED_IDX     1
#define GCODE_SIZE_ROTATED_IDX       2
#define GCODE_SIZE_ROTATED_CORRECTED 3

  GCODE_SIZE m_size[4]; 
};


struct DLL_INIT_STRUCT
{
  TGM_LPCTSTR CNC_Dll_Dir;    
  TGM_LPCTSTR Macros_Dir;     
  TGM_LPCTSTR Comm_Int2_Dir;  

#define LOCAL_CORE_MODE_TGM 0      
#define LOCAL_CORE_MODE_DLL 1      
#define LOCAL_CORE_MODE_OFFLINE 2  

  int32_t Local_Core_Mode; 

};


struct MACHINE_PARAMETERS
{
  P10DOUBLE minCoords;          
  P10DOUBLE maxCoords;          
  P10DOUBLE refCoords;          
  P10BOOL   enableMask;         
  P10DOUBLE backlash;           
  P10DOUBLE backlashInc;        
  int32_t backlashValuesSource; 
  uint32_t enhancedInterpolatorParameters; 
  P10DOUBLE axisSpeedRatio;     
};

#define INTERPOLATOR_LINEAR_FUNC     1   // @flag 1 | <f Interpolator_Linear>
#define INTERPOLATOR_ARC_CW_FUNC     2   // @flag 2 | <f Interpolator_Arc> CW
#define INTERPOLATOR_ARC_CCW_FUNC    3   // @flag 3 | Interpolator_Arc CCW
#define INTERPOLATOR_CLEAR_FUNC      4
#define INTERPOLATOR_GENERIC_FUNC    5   // any generic G-function
#define INTERPOLATOR_G0_FUNC         10   // G0
#define INTERPOLATOR_STOP_FUNC       30  // @flag 30 | <f Interpolator_Stop>
#define INTERPOLATOR_START_FUNC      31  // @flag 31 | <f Interpolator_Start>
#define INTERPOLATOR_NORMAL_STOP_FUNC 32  // @flag 32 | <f Interpolator_NormalStop>
#define INTERPOLATOR_SET_COORDS_FUNC 92  // @flag 92 | <f Interpolator_SetCoords>
#define INTERPOLATOR_SET_PARAMS_FUNC 93  // @flag 93 | <f Interpolator_SetParams>
#define INTERPOLATOR_SET_MACHINE_PARAMS_FUNC 94 // @flag 94 | SetMachineParams (called via SetParams)
#define INTERPOLATOR_SET_DOUBLE_INTEGER_PARS  95      // @flag 95
#define INTERPOLATOR_CONTINUOUS_M_FUNC 999   // @flag 999 | prubezna M funkce
#define INTERPOLATOR_M_FUNC          1000    // @flag 1000 | M funkce s cekanim

#define INTERPOLATOR_MAX_N_USER_PARAMS  26  // max supported number of M function addresses

struct INTERPOLATOR_CMD_PARAMS {
  uint32_t nFunc;           
                            //
                            // @flag 1 | Linear  (= G1)
                            // @flag 2 | Arc CW  (= G2)
                            // @flag 3 | Arc CCW (= G3)
                            // @flag 30 | Emergency Stop
                            // @flag 31 | Start
                            // @flag 32 | Normal Stop
                            // @flag 92 | SetCoords (= G92)
                            // @flag 999 | M funkce (prubezna)
                            // @flag 1000 | M funkce (cekaci)
  uint32_t nCoords;         
  int32_t  gCodeIdx;             
  uint32_t editorLine;           

  union {
    struct // commands: 1, 2, 3, 92
    {
      double coords[ACTUAL_N_AXES];  
      double feed;                   
      double arcCenter[3];           
                                     // circCenter[0] a circCenter[1], rezerva pro XYZ souradnici v prostoru
      uint32_t arcAxis[2];           
    } c;

    struct // command: 999, 1000 (M functions)
    {
      int32_t funcNumber;   
      uint32_t timeout;     
      float fltMParams[INTERPOLATOR_MAX_N_USER_PARAMS];   
    } m;

    struct // command: 95
    {
      double acc;
      double dec;
      double start_angle;
      double end_angle;
      double minimal_feed;
      double reserve[8];
      uint32_t feedTypeToolNumber;     
      // @flag 0 | mm/min (minutovy)
      // @flag 1 | mm/ot (otackovy)
      // @flag 2 | otackovy (zavisly na poloze vretene, start podle pozice)
      // @flag 3 | otackovy (zavisly na poloze vretene, start podle pulzu)
      // @flag 4 | minutovy bez override posuvu (G00 plna rychlost)
      // @normal cislo nastroje v hornich 24 bitech

      uint32_t fileIdx;              
      uint32_t correction;           

      int32_t  m_speedPreference;    
      // = 0 | zarucena je vzdy nizsi rychlost
      // = 1 | snazi se zrychlovat tak, aby na zacatku pohybu uz byla pozadovana rychlost, pokud je to mozne
    } p;
  } u;
};


//################################### Function callbacks ###########################################


#define CALLBACK_CALLTYPE TOOLCHAIN_CALLTYPE  

typedef int32_t CALLBACK_CALLTYPE FuncPrototype(intptr_t dwUserData);

#define DEVICE_ERROR_OUT_TAB 0
#define CNC_OUT_TAB          1
#define M29_OUT_TAB          2
#define STATUS_LINE_ONLY     3
#define ACTIVATE_TAB         0x100
#define PREFIX_TIME          0x200
#define HIDE_OUTPUT_VIEW     0x400

#define APP_AddOutputLogFunc        1
typedef int32_t CALLBACK_CALLTYPE AddOutputLogFunc(intptr_t dwUserData, 
                                                   int32_t tab, 
                                                   TGM_LPCTSTR info, 
                                                   CALLBACK_INFO *callBackInfo);

#define APP_SetStatusBarTextFunc    2
typedef int32_t CALLBACK_CALLTYPE SetStatusBarTextFunc(intptr_t dwUserData, 
                                                       int32_t pane, 
                                                       TGM_LPCTSTR strText, 
                                                       CALLBACK_INFO *callBackInfo);

#define APP_IsDebugModeFunc         3
typedef int32_t CALLBACK_CALLTYPE IsDebugModeFunc(intptr_t dwUserData);

#define APP_IsVerboseModeFunc       4
typedef int32_t CALLBACK_CALLTYPE IsVerboseModeFunc(intptr_t dwUserData);

#define APP_GetLibPathFunc          5
typedef TGM_LPCTSTR CALLBACK_CALLTYPE GetLibPathFunc(intptr_t dwUserData);

#define APP_GetToolPathFunc         6
typedef TGM_LPCTSTR CALLBACK_CALLTYPE GetToolPathFunc(intptr_t dwUserData);

#define APP_GetSystemPathFunc       7
typedef TGM_LPCTSTR CALLBACK_CALLTYPE GetSystemPathFunc(intptr_t dwUserData);  // path for system directory


#define APP_GetFileTimeStampFunc   10
typedef int64_t CALLBACK_CALLTYPE GetFileTimeStampFunc(intptr_t dwUserData, uint32_t fileIdx);

#define APP_DoYieldFunc            11
typedef int32_t CALLBACK_CALLTYPE DoYieldFunc(intptr_t dwUserData, int32_t messageOnly);

#define APP_ReadIniStringFunc      12
typedef void CALLBACK_CALLTYPE ReadIniStringFunc(intptr_t dwUserData, 
                                                 TGM_LPCTSTR section, 
                                                 TGM_LPCTSTR key, 
                                                 TGM_LPCTSTR defValue, 
                                                 TGM_LPTSTR buffer, 
                                                 uint32_t bufferSizeInCharacters);

#define APP_ReadIniDoubleFunc      13
typedef double CALLBACK_CALLTYPE ReadIniDoubleFunc(intptr_t dwUserData, 
                                                   TGM_LPCTSTR section, 
                                                   TGM_LPCTSTR key, 
                                                   double defValue);

#define APP_ReadIniIntFunc         14
typedef int32_t CALLBACK_CALLTYPE ReadIniIntFunc(intptr_t dwUserData, 
                                                 TGM_LPCTSTR section, 
                                                 TGM_LPCTSTR key, 
                                                 int32_t defValue);

#define APP_DispRunInfoAndWaitFunc 15
typedef int32_t CALLBACK_CALLTYPE DispRunInfoAndWaitFunc(intptr_t dwUserData, 
                                                         uint32_t editorLine, 
                                                         int32_t fileIdx, 
                                                         TGM_LPCTSTR statusInfo, 
                                                         int32_t bNoBreakpoints, 
                                                         int32_t bForceToWait, 
                                                         const double *params, 
                                                         const uint32_t maxParams);

#define APP_DispRunInfoFunc        16
typedef int32_t CALLBACK_CALLTYPE DispRunInfoFunc(intptr_t dwUserData, 
                                                  uint32_t editorLine, 
                                                  int32_t fileIdx, 
                                                  TGM_LPCTSTR statusInfo, 
                                                  const SIMPLE_GM_PARAMS_WIN32 *pCmd);

#define APP_IsBreakpointFunc       17
typedef int32_t CALLBACK_CALLTYPE IsBreakpointFunc(intptr_t dwUserData, 
                                                   uint32_t editorLine, 
                                                   int32_t fileIdx);

#define APP_DispAndLocateErrorFunc 18
typedef int32_t CALLBACK_CALLTYPE DispAndLocateErrorFunc(intptr_t dwUserData, 
                                                         uint32_t editorLine, 
                                                         int32_t fileIdx, 
                                                         TGM_LPCTSTR errString, 
                                                         CALLBACK_INFO *callBackInfo);

#define APP_DispLastInfoFunc       19
typedef int32_t CALLBACK_CALLTYPE DispLastInfoFunc(intptr_t dwUserData);

#define APP_IsStepModeFunc         20
typedef int32_t CALLBACK_CALLTYPE IsStepModeFunc(intptr_t dwUserData);

#define APP_IsHandControlFunc      21
typedef int32_t CALLBACK_CALLTYPE IsHandControlFunc(intptr_t dwUserData);

#define APP_SetRegimeFromUserKeyFunc 22
typedef int32_t CALLBACK_CALLTYPE SetRegimeFromUserKeyFunc(intptr_t dwUserData, int32_t key);

#define APP_ExecMenuCommandFromUserKeyFunc 23
typedef int32_t CALLBACK_CALLTYPE ExecMenuCommandFromUserKeyFunc(intptr_t dwUserData, int key);


#define APP_MaxFuncNumber           1000   


#define DRV_InitializeFunc          1001
typedef int32_t CALLBACK_CALLTYPE DriverInitializeFunc(intptr_t dwUserData, 
                                                       double *params, 
                                                       uint32_t nParams, 
                                                       int32_t bTestMode);

#define DRV_GFunc                   1002
typedef int32_t CALLBACK_CALLTYPE DriverGFunc(intptr_t dwUserData, const SIMPLE_GM_PARAMS_WIN32 *v);

#define DRV_MFunc                   1003
typedef int32_t CALLBACK_CALLTYPE DriverMFunc(intptr_t dwUserData, const SIMPLE_GM_PARAMS_WIN32 *v);

#define ConnectPointCalcStartFuncNumber   1004
typedef int32_t CALLBACK_CALLTYPE ConnectPointCalcStartFunc(intptr_t dwUserData,
                                                            const int32_t nType,
                                                            const uint32_t nCoords,
                                                            const double *coords,
                                                            const uint32_t bitCodedAxesForCalc);

#define ConnectPointCalcFunc_UseReturnValues    1

#define ConnectPointCalcFuncNumber    1005


typedef int32_t CALLBACK_CALLTYPE ConnectPointCalcFunc(intptr_t dwUserData,
                                                       const SIMPLE_GM_PARAMS_WIN32 *part,
                                                       double *calcSquareDistanceFromCoords,
                                                       P10DOUBLE *calcConnectPoint);

#define ConnectPointCalcEndFuncNumber    1006
typedef int32_t CALLBACK_CALLTYPE ConnectPointCalcEndFunc(intptr_t dwUserData,
                                                          SIMPLE_GM_PARAMS_WIN32 *partToBeConnectedTo,
                                                          P10DOUBLE *connectPosToBeMovedTo);

#define DRV_MaxFuncNumber           2000

#define MATH_WarningFunc            2001
typedef int32_t CALLBACK_CALLTYPE MathWarningFunc(intptr_t dwUserData, CALLBACK_INFO *pCallbackInfo);


#define MATH_MaxFuncNumber           3000   // last function in DRV group



//################################### Main SF_TCh exported functions ######################################

#ifdef __cplusplus
extern "C" {
#endif 
  
  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_Init(DLL_INIT_STRUCT *pInitValues);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_INIT(DLL_INIT_STRUCT *pInitValues);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_LoadFromIni(int32_t intIdx,
                                                                            TGM_LPCTSTR iniFile,
                                                                            int32_t *pnMaxCores);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_LOADFROMINI(int32_t intIdx,
                                                                            TGM_LPCTSTR iniFile,
                                                                            int32_t *pnMaxCores);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_DestroyCNC(int32_t intIdx);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_DESTROYCNC(int32_t intIdx);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_SetGCodeParameters(int32_t intIdx,
                                                                                   const GCODE_PARAMETERS *params);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_SETGCODEPARAMETERS(int32_t intIdx,
                                                                                   const GCODE_PARAMETERS *params);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_GetGCodeParameters(int32_t intIdx,
                                                                                   GCODE_PARAMETERS *params);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_GETGCODEPARAMETERS(int32_t intIdx,
                                                                                   GCODE_PARAMETERS *params);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_StatusCNC(int32_t intIdx);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_STATUSCNC(int32_t intIdx);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_GetPos(int32_t intIdx,
                                                                       int32_t regime,
                                                                       SIMPLE_GM_PARAMS_WIN32 *pos,
                                                                       GM_PARAMS_ENHANCED *enhParams);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_GETPOS(int32_t intIdx,
                                                                       int32_t regime,
                                                                       SIMPLE_GM_PARAMS_WIN32 *pos,
                                                                       GM_PARAMS_ENHANCED *enhParams);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_CompileFromFile(int32_t intIdx,
                                                                                TGM_LPCTSTR fileName);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_COMPILEFROMFILE(int32_t intIdx,
                                                                                TGM_LPCTSTR fileName);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_CompileFromMemory(int32_t intIdx,
                                                                                  TGM_LPCTSTR fileName, 
                                                                                  TGM_LPCSTR mainCode);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_COMPILEFROMMEMORY(int32_t intIdx,
                                                                                  TGM_LPCTSTR fileName,
                                                                                  TGM_LPCSTR mainCode);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_IsBusy(int32_t intIdx);
  typedef int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_ISBUSY(int32_t intIdx);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_StartCNCEx(int32_t intIdx,
                                                                           int32_t regime,
                                                                           TGM_LPCSTR strAddGCode);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_STARTCNCEX(int32_t intIdx,
                                                                           int32_t regime,
                                                                           TGM_LPCSTR strAddGCode);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_ResetCNC(int32_t intIdx,
                                                                         int32_t regime,
                                                                         const uint32_t nCoords,
                                                                         const double *coords);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_RESETCNC(int32_t intIdx,
                                                                         int32_t regime,
                                                                         const uint32_t nCoords,
                                                                         const double *coords);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_StopCNCEx(int32_t intIdx, TGM_LPCSTR strAddCode);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_STOPCNCEX(int32_t intIdx, TGM_LPCSTR strAddCode);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_ConnectCNCEx_Plane(int32_t intIdx,
                                                                                   int32_t nType,
                                                                                   const uint32_t nCoords,
                                                                                   const double *coords,
                                                                                   TGM_LPCSTR strAddCode,
                                                                                   uint32_t bitCodedAxesForCalc,
                                                                                   uint32_t bitCodedAxesForConnect,
                                                                                   int32_t trajectoryStateAfterConnect);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_CONNECTCNCEX_PLANE(int32_t intIdx,
                                                                                   int32_t nType,
                                                                                   const uint32_t nCoords,
                                                                                   const double *coords,
                                                                                   TGM_LPCSTR strAddCode,
                                                                                   uint32_t bitCodedAxesForCalc,
                                                                                   uint32_t bitCodedAxesForConnect,
                                                                                   int32_t trajectoryStateAfterConnect);


  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_GoToPosition(int32_t intIdx,
                                                                             const uint32_t nCoords,
                                                                             const double *coords);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_GOTOPOSITION(int32_t intIdx,
                                                                             const uint32_t nCoords,
                                                                             const double *coords);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_GoToPositionEx(int32_t intIdx,
                                                                               const SIMPLE_GM_PARAMS_WIN32 *pDest);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_GOTOPOSITIONEX(int32_t intIdx,
                                                                               const SIMPLE_GM_PARAMS_WIN32 *pDest);

  
  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_MFunc(int32_t intIdx,
                                                                      const SIMPLE_GM_PARAMS_WIN32 &fun, 
                                                                      int32_t bDirectToPLC);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_MFUNC(int32_t intIdx, 
                                                                      const SIMPLE_GM_PARAMS_WIN32 &fun, 
                                                                      int32_t bDirectToPLC);


  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_FileToIdx(int32_t intIdx,
                                                                          TGM_LPCTSTR fileName);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_FILETOIDX(int32_t intIdx,
                                                                          TGM_LPCTSTR fileName);

  TOOLCHAIN_DLL_EXPORT TGM_LPCTSTR TOOLCHAIN_CALLTYPE ToolChainCore_IdxToFile(int32_t intIdx,
                                                                              int32_t fileIdx);
  typedef              TGM_LPCTSTR TOOLCHAIN_CALLTYPE TOOLCHAINCORE_IDXTOFILE(int32_t intIdx,
                                                                              int32_t fileIdx);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_SetRelFeed(int32_t intIdx,
                                                                           double relFeed);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_SETRELFEED(int32_t intIdx,
                                                                           double relFeed);


  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_SetCallBack(int32_t intIdx,
                                                                            int32_t fceNo,
                                                                            intptr_t dwUserData,
                                                                            FuncPrototype *funcPtr);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_SETCALLBACK(int32_t intIdx,
                                                                            int32_t fceNo,
                                                                            intptr_t dwUserData,
                                                                            FuncPrototype *funcPtr);


  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_GetLastError(int32_t intIdx,
                                                                             CALLBACK_INFO *pLastErrorInfo);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_GETLASTERROR(int32_t intIdx,
                                                                             CALLBACK_INFO *pLastErrorInfo);


  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_SetBreakpoint(int32_t intIdx,
                                                                              uint32_t editorLine,
                                                                              int32_t fileIdx);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_SETBREAKPOINT(int32_t intIdx,
                                                                              uint32_t editorLine,
                                                                              int32_t fileIdx);


  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_GetGCodeSizeInfo(int32_t intIdx,
                                                                                 GCODE_INFO *pInfo);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_GETGCODESIZEINFO(int32_t intIdx,
                                                                                 GCODE_INFO *pInfo);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_GetStructuresSize(int32_t intIdx,
                                                                                  uint32_t nItems,
                                                                                  uint32_t *items);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_GETSTRUCTURESSIZE(int32_t intIdx,
                                                                                  uint32_t nItems,
                                                                                  uint32_t *items);


  TOOLCHAIN_DLL_EXPORT TGM_LPCTSTR TOOLCHAIN_CALLTYPE ToolChainCore_GetVersionString(int32_t intIdx);
  typedef              TGM_LPCTSTR TOOLCHAIN_CALLTYPE TOOLCHAINCORE_GETVERSIONSTRING(int32_t intIdx);


  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_GetMachineParameters(int32_t intIdx,
                                                                                     MACHINE_PARAMETERS *pParameters);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_GETMACHINEPARAMETERS(int32_t intIdx,
                                                                                     MACHINE_PARAMETERS *pParameters);

  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_SetMachineParameters(int32_t intIdx,
                                                                                     const MACHINE_PARAMETERS *pParameters);

  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_SETMACHINEPARAMETERS(int32_t intIdx,
                                                                                     const MACHINE_PARAMETERS *pParameters);

#define CNC_CALC_LOAD_ALL      0   
#define CNC_CALC_LOAD_DLL_ONLY 1   
#define CNC_CALC_LOAD_TGM_ONLY 2   


  TOOLCHAIN_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE ToolChainCore_LoadCNCCalcPlugIn(TGM_LPCTSTR fileName, uint32_t loadFlags, int64_t userValue);
  typedef              int32_t TOOLCHAIN_CALLTYPE TOOLCHAINCORE_LOADCNCCALCPLUGIN(TGM_LPCTSTR fileName, uint32_t loadFlags, int64_t userValue);


//################################### Exported functions for CNC Calc plug-in DLL ##########################

#ifdef __GNUC__
#define TGM_COM_CALLTYPE
#else
#define TGM_COM_CALLTYPE __cdecl
#endif

#ifdef WIN32

# if !defined(_UNICODE)
# error "_UNICODE must be defined for WIN32"
# endif

typedef const wchar_t * CNC_CONST_STRING;

#else // WIN32

#include <stdlib.h>

typedef const char * CNC_CONST_STRING;

// mark text as ANSI/UNICODE compatible
#ifndef _T
# define _T(a)    (a)
#endif

#endif

  // read/write functions from TGM_Comm_Int_2
typedef int32_t TGM_COM_CALLTYPE TGM_COM_READ_I32(uint32_t memoryType, uint32_t offset, int32_t *pValue);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_READ_I64(uint32_t memoryType, uint32_t offset, int64_t *pValue);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_READ_double(uint32_t memoryType, uint32_t offset, double *pValue);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_READ_BLOCK(uint32_t memoryType, uint32_t offset, void *buffer, uint32_t bufferLength);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_WRITE_I32(uint32_t memoryType, uint32_t offset, int32_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_WRITE_I64(uint32_t memoryType, uint32_t offset, int64_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_WRITE_double(uint32_t memoryType, uint32_t offset, double Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_WRITE_BLOCK(uint32_t memoryType, uint32_t offset, const void *buffer, uint32_t bufferLength);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_SET_BIT_I32(uint32_t memoryType, uint32_t offset, int32_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_SET_BIT_I64(uint32_t memoryType, uint32_t offset, int64_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_CLR_BIT_I32(uint32_t memoryType, uint32_t offset, int32_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_CLR_BIT_I64(uint32_t memoryType, uint32_t offset, int64_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_TGL_BIT_I32(uint32_t memoryType, uint32_t offset, int32_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_TGL_BIT_I64(uint32_t memoryType, uint32_t offset, int64_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_READ_I32_DIRECT(uint32_t memoryType, uint32_t offset, int32_t *pValue);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_READ_I64_DIRECT(uint32_t memoryType, uint32_t offset, int64_t *pValue);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_READ_double_DIRECT(uint32_t memoryType, uint32_t offset, double *pValue);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_READ_BLOCK_DIRECT(uint32_t memoryType, uint32_t offset, void *buffer, uint32_t bufferLength);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_WRITE_I32_DIRECT(uint32_t memoryType, uint32_t offset, int32_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_WRITE_I64_DIRECT(uint32_t memoryType, uint32_t offset, int64_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_WRITE_double_DIRECT(uint32_t memoryType, uint32_t offset, double Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_WRITE_BLOCK_DIRECT(uint32_t memoryType, uint32_t offset, const void *buffer, uint32_t bufferLength);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_SET_BIT_I32_DIRECT(uint32_t memoryType, uint32_t offset, int32_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_SET_BIT_I64_DIRECT(uint32_t memoryType, uint32_t offset, int64_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_CLR_BIT_I32_DIRECT(uint32_t memoryType, uint32_t offset, int32_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_CLR_BIT_I64_DIRECT(uint32_t memoryType, uint32_t offset, int64_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_TGL_BIT_I32_DIRECT(uint32_t memoryType, uint32_t offset, int32_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_TGL_BIT_I64_DIRECT(uint32_t memoryType, uint32_t offset, int64_t Value);
typedef int32_t TGM_COM_CALLTYPE TGM_COM_FLUSH_BUFFER();
// debug output function
typedef int32_t TGM_COM_CALLTYPE TGM_RTWPRINTF_EX(int32_t severity, CNC_CONST_STRING strFormat, ...);

struct CNC_CALC_INIT_DATA
{
  uint32_t structSize;                  
  TGM_COM_READ_I32     *pReadI32;                     
  TGM_COM_READ_I64     *pReadI64;                     
  TGM_COM_READ_double  *pReadDouble;                  
  TGM_COM_READ_BLOCK   *pReadBlock;                   
  TGM_COM_WRITE_I32    *pWriteI32;                    
  TGM_COM_WRITE_I64    *pWriteI64;                    
  TGM_COM_WRITE_double *pWriteDouble;                 
  TGM_COM_WRITE_BLOCK  *pWriteBlock;                  
  TGM_COM_SET_BIT_I32  *pSetBitI32;                   
  TGM_COM_SET_BIT_I64  *pSetBitI64;                   
  TGM_COM_CLR_BIT_I32  *pClrBitI32;                   
  TGM_COM_CLR_BIT_I64  *pClrBitI64;                   
  TGM_COM_TGL_BIT_I32  *pTglBitI32;                   
  TGM_COM_TGL_BIT_I64  *pTglBitI64;                   
  TGM_COM_READ_I32_DIRECT     *pReadI32Direct;        
  TGM_COM_READ_I64_DIRECT     *pReadI64Direct;        
  TGM_COM_READ_double_DIRECT  *pReadDoubleDirect;     
  TGM_COM_READ_BLOCK_DIRECT   *pReadBlockDirect;      
  TGM_COM_WRITE_I32_DIRECT    *pWriteI32Direct;       
  TGM_COM_WRITE_I64_DIRECT    *pWriteI64Direct;       
  TGM_COM_WRITE_double_DIRECT *pWriteDoubleDirect;    
  TGM_COM_WRITE_BLOCK_DIRECT  *pWriteBlockDirect;     
  TGM_COM_SET_BIT_I32_DIRECT  *pSetBitI32Direct;      
  TGM_COM_SET_BIT_I64_DIRECT  *pSetBitI64Direct;      
  TGM_COM_CLR_BIT_I32_DIRECT  *pClrBitI32Direct;      
  TGM_COM_CLR_BIT_I64_DIRECT  *pClrBitI64Direct;      
  TGM_COM_TGL_BIT_I32_DIRECT  *pTglBitI32Direct;      
  TGM_COM_TGL_BIT_I64_DIRECT  *pTglBitI64Direct;      
  TGM_COM_FLUSH_BUFFER        *pFlushBuffer;  
  TGM_RTWPRINTF_EX            *pPrintf;  
  int64_t              userValue;        
};

 

#define CNC_CALC_MFUNC_OFFSET     10000 

#define CNC_CALC_DISABLE_AUTOMATIC_GCODEINDEX_UPDATE_BIT 0x01 

#define CNC_CALC_MAX_STATIC_RETURNED_PARTS 8 

struct CNC_CALC_RETURN_VALUE
{
  double   dblFeed;         
  int32_t  options;         
  uint32_t nEntriesInPart0; 
  SIMPLE_GM_PARAMS_BASE sParts0[CNC_CALC_MAX_STATIC_RETURNED_PARTS];
  int32_t  reserved2;       
  uint32_t nDynamicEntriesInPart1; 
  SIMPLE_GM_PARAMS_BASE *dParts1;  
};

#define CNC_CALC_RETURN_ERROR    (-1) 

#define CNC_CALC_RETURN_IGNORE    0   

#define CNC_CALC_RETURN_USE       1   

#define CNC_CALC_RETURN_OK        1   

#define CNC_CALC_RETURN_FEED_ONLY 2   

CNC_CALC_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE CNC_Calc_Load(const CNC_CALC_INIT_DATA *pInitData);
typedef int32_t TOOLCHAIN_CALLTYPE CNC_CALC_LOAD(const CNC_CALC_INIT_DATA *pInitData);

CNC_CALC_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE CNC_Calc_Unload();
typedef int32_t TOOLCHAIN_CALLTYPE CNC_CALC_UNLOAD();

#define CNC_CALC_IDX_INIT_DATA_STRUCT             0
#define CNC_CALC_IDX_SIMPLE_GM_PARAMS_BASE_STRUCT 1
#define CNC_CALC_IDX_RETURN_VALUE_STRUCT          2

CNC_CALC_DLL_EXPORT uint32_t TOOLCHAIN_CALLTYPE CNC_Calc_Get_Structures_Size(uint32_t structureIdx);
typedef uint32_t TOOLCHAIN_CALLTYPE CNC_CALC_GET_STRUCTURES_SIZE(uint32_t structureIdx);

CNC_CALC_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE CNC_Calc_Get_Compatibility_IDs(uint32_t *pID_COMPATIBILITY,
                                                                  uint32_t *pID_MEMORY_COMPATIBILITY,
                                                                  uint32_t *pID_CNC_COMPATIBILITY);
typedef int32_t TOOLCHAIN_CALLTYPE CNC_CALC_GET_COMPATIBILITY_IDS(uint32_t *pID_COMPATIBILITY,
                                                                  uint32_t *pID_MEMORY_COMPATIBILITY,
                                                                  uint32_t *pID_CNC_COMPATIBILITY);


CNC_CALC_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE CNC_Calc_Start(uint32_t intIdx,
                                                              int32_t regime,
                                                              const SIMPLE_GM_PARAMS_BASE *pInitPos,
                                                              CNC_CALC_RETURN_VALUE *pChangedParts);
typedef int32_t TOOLCHAIN_CALLTYPE CNC_CALC_START(uint32_t intIdx,
                                                  int32_t regime,
                                                  const SIMPLE_GM_PARAMS_BASE *pInitPos,
                                                  CNC_CALC_RETURN_VALUE *pChangedParts);


CNC_CALC_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE CNC_Calc_GFunc(uint32_t intIdx,
                                                              const SIMPLE_GM_PARAMS_BASE *pGFunc,
                                                              CNC_CALC_RETURN_VALUE *pChangedParts);

typedef int32_t TOOLCHAIN_CALLTYPE CNC_CALC_GFUNC(uint32_t intIdx,
                                                  const SIMPLE_GM_PARAMS_BASE *pGFunc,
                                                  CNC_CALC_RETURN_VALUE *pChangedParts);

CNC_CALC_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE CNC_Calc_MFunc(uint32_t intIdx,
                                                              const SIMPLE_GM_PARAMS_BASE *pMFunc,
                                                              CNC_CALC_RETURN_VALUE *pChangedParts);

typedef int32_t TOOLCHAIN_CALLTYPE CNC_CALC_MFUNC(uint32_t intIdx,
                                                  const SIMPLE_GM_PARAMS_BASE *pMFunc,
                                                  CNC_CALC_RETURN_VALUE *pChangedParts);

CNC_CALC_DLL_EXPORT int32_t TOOLCHAIN_CALLTYPE CNC_Calc_Finish(uint32_t intIdx,
                                                               const SIMPLE_GM_PARAMS_BASE *pFinishMFunc,
                                                               CNC_CALC_RETURN_VALUE *pChangedParts);

typedef int32_t TOOLCHAIN_CALLTYPE CNC_CALC_FINISH(uint32_t intIdx,
                                                   const SIMPLE_GM_PARAMS_BASE *pFinishMFunc,
                                                   CNC_CALC_RETURN_VALUE *pChangedParts);


#ifdef __cplusplus
}  // extern "C"
#endif 

#define G_FUNC_SETTINGS                     900

#define G_FUNC_SETTINGS_PUSH                1
#define G_FUNC_SETTINGS_POP                 2
#define G_FUNC_SETTINGS_SET_AXIS_LIMITS     7
#define G_FUNC_SETTINGS_SET_MUTUAL_ANGLES   9
#define G_FUNC_SETTINGS_ENA_MUTUAL_ANGLES   10
#define G_FUNC_SETTINGS_ENA_FEED_CALC       11
#define G_FUNC_SETTINGS_SET_ANGLE_MODE      12
#define G_FUNC_SETTINGS_IGNORE_ARC_FEED_TBL 13
#define G_FUNC_SETTINGS_FEED_G00            20
#define G_FUNC_SETTINGS_FEED_FORWARD        30
#define G_FUNC_SETTINGS_FEED_FORWARD_NO_M   31
#define G_FUNC_SETTINGS_FEED_BACKWARD       32
#define G_FUNC_SETTINGS_FEED_CONNECT        40
#define G_FUNC_SETTINGS_FEED_GOTO           50
#define G_FUNC_SETTINGS_FEED_NORMAL_STOP    60
#define G_FUNC_SETTINGS_FEED_EMERGENCY_STOP 70






#ifdef __GNUC__
# pragma GCC diagnostic pop
#else
# pragma warning(pop)
#endif


#endif // TGM_CNC_H_FILE_INCLUDED