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

* Description: interp_namedparams.cc

*

* collect all code related to named parameter handling

*

* Author: mostly K. Lerman

* rewrite by Michael Haberler to use STL containers

* License: GPL Version 2

* System: Linux

*

* Copyright (c) 2004 All rights reserved.

*

* Last change: Juli 2011

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

#ifndef _GNU_SOURCE

#define _GNU_SOURCE

#endif

#include "python_plugin.hh"

#include <boost/python/dict.hpp>

#include <boost/python/extract.hpp>

#include <boost/python/list.hpp>

#include <boost/python/tuple.hpp>

namespace bp = boost::python;

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <string.h>

#include <ctype.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sstream>

#include <map>

#include "rs274ngc.hh"

#include "rs274ngc_return.hh"

#include "interp_internal.hh"

#include "rs274ngc_interp.hh"

#include "inifile.hh"

// for HAL pin variables

#include "hal.h"

#include "hal/hal_priv.h"

enum predefined_named_parameters {

    NP_LINE,

    NP_MOTION_MODE,

    NP_PLANE,

    NP_CCOMP,

    NP_METRIC,

    NP_IMPERIAL,

    NP_ABSOLUTE,

    NP_INCREMENTAL,

    NP_INVERSE_TIME,

    NP_UNITS_PER_MINUTE,

    NP_UNITS_PER_REV,

    NP_COORD_SYSTEM,

    NP_TOOL_OFFSET,

    NP_RETRACT_R_PLANE,

    NP_RETRACT_OLD_Z,

    NP_SPINDLE_RPM_MODE,

    NP_SPINDLE_CSS_MODE,

    NP_IJK_ABSOLUTE_MODE,

    NP_LATHE_DIAMETER_MODE,

    NP_LATHE_RADIUS_MODE,

    NP_SPINDLE_ON,

    NP_SPINDLE_CW,

    NP_MIST,

    NP_FLOOD,

    NP_SPEED_OVERRIDE,

    NP_FEED_OVERRIDE,

    NP_ADAPTIVE_FEED,

    NP_FEED_HOLD,

    NP_FEED,

    NP_RPM,

    NP_CURRENT_TOOL,

    NP_SELECTED_POCKET,

    NP_CURRENT_POCKET,

    NP_X,

    NP_Y,

    NP_Z,

    NP_A,

    NP_B,

    NP_C,

    NP_U,

    NP_V,

    NP_W,

    NP_VALUE,

    NP_CALL_LEVEL,

    NP_REMAP_LEVEL,

    NP_SELECTED_TOOL,

    NP_VALUE_RETURNED,

    NP_TASK,

};

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

/*! read_named_parameter

Returned Value: int

   If read_integer_value returns an error code, this returns that code.

   If any of the following errors occur, this returns the error code shown.

   Otherwise, this returns INTERP_OK.

   1. The first character read is not a <:

      NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED

   2. The named parameter string is not terminated by >:

      NCE_NAMED_PARAMETER_NOT_TERSINATED

   3. The named parameter has not been defined before use:

      NCE_NAMED_PARAMETER_NOT_DEFINED

Side effects:

   The value of the given parameter is put into what double_ptr points at.

   The counter is reset to point to the first character after the

   characters which make up the value.

Called by:  read_parameter

This attempts to read the value of a parameter out of the line,

starting at the index given by the counter.

According to the RS274/NGC manual [NCMS, p. 62], the characters following

# may be any "parameter expression". Thus, the following are legal

and mean the same thing (the value of the parameter whose number is

stored in parameter 2):

  ##2

  #[#2]

ADDED by K. Lerman

Named parameters are now supported.

#<_abcd> is a parameter with name "abcd" of global scope

#<abce> is a named parameter of local scope.

*/

				 char *line,   //!< string: line of RS274/NGC code being processed

				 int *counter, //!< pointer to a counter for position on the line

				 double *double_ptr,   //!< pointer to double to be read

				 double *parameters,   //!< array of system parameters

				 bool check_exists)    //!< test for existence, not value

{

    static char name[] = "read_named_parameter";

    char paramNameBuf[LINELEN+1];

    int exists;

    double value;

    parameter_map_iterator pi;

	 NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);

    }

    } else {

        // do not require named parameters to be defined during a

        // subroutine definition:

            return INTERP_OK;

	      name, paramNameBuf, (paramNameBuf[0] == '_') ? 0 : _setup.call_level);

    }

    return INTERP_OK;

}

// if the variable is of the form '_ini[section]name', then treat it as

// an inifile  variable. Lookup section/name and cache the value

// as global and read-only.

// the shortest possible ini variable is '_ini[s]n' or 8 chars long .

{

    char *s;

	const char *iniFileName;

	int retval;

	}

	}

	char capName[LINELEN];

	} else {

		nameBuf, iniFileName, retval);

	}

    }

    return INTERP_OK;

}

// if the variable is of the form '_hal[hal_name]', then treat it as

// a HAL pin, signal or param. Lookup value, convert to float, and export as global and read-only.

// do not cache.

// the shortest possible ini variable is '_hal[x]' or 7 chars long .

{

    static int comp_id;

    int retval;

    hal_data_u* ptr;

    char hal_name[LINELEN];

	char hal_comp[LINELEN];

    }

    char *s;

	hal_pin_t *pin;

	hal_sig_t *sig;

	hal_param_t *param;

	}

	// the result of these lookups could be cached in the parameter struct, but I'm not sure

	// this is a good idea - a removed pin/signal will not be noticed

	// I dont think that's needed - no change in pins/sigs/params

	// rtapi_mutex_get(&(hal_data->mutex));

        // rtapi_mutex_give(&(hal_data->mutex));

	    }

	    } else {

	    }

	    goto assign;

	}

	}

	}

    }

    return INTERP_OK;

    assign:

    }

}

    const char *nameBuf, //!< pointer to name to be read

    int *status,    //!< pointer to return status 1 => found

    double *value   //!< pointer to value of found parameter

    )

{

  context_pointer frame;

  parameter_map_iterator pi;

  int level;

      double inivalue;

	      parameter_value param;  // cache the value

	      return INTERP_OK;

	  }

      }

	  }

      }

  } else {

	  bp::list plist;

	       "named param - pycall(%s):\n%s", nameBuf,

	       python_plugin->last_exception().c_str());

	      // returning a string sets the interpreter error message and aborts

	  }

	  }

	  }

	  // ok, that callable returned something botched.

	      NAMEDPARAMS_MODULE, nameBuf,

	      PyString_AsString(res_str),

	      retval.ptr()->ob_type->tp_name);

      } else {

      }

  }

  return INTERP_OK;

}

    const char *nameBuf, //!< pointer to name to be written

    double value,   //!< value to be written

    int override_readonly  //!< set to true to init a r/o parameter

    )

{

  context_pointer frame;

  int level;

  parameter_map_iterator pi;

  } else {

	   "BUG: variable '%s' marked global, but assigned at level %d", nameBuf, level);

      } else {

		level, nameBuf, value);

      }

  }

  return INTERP_OK;

}

    const char *nameBuf, //!< pointer to name to be added

    int attr) //!< see PA_* defs in interp_internal.hh

{

  static char name[] = "add_named_param";

  int findStatus;

  double value;

  int level;

  parameter_value param;

  // look it up to see if already exists

      return INTERP_OK;

  }

  } else {

  }

}

{

}

// just a shorthand

    const char *nameBuf, //!< pointer to name to be added

    double value,  //!< initial value

    int attr)       //!< see PA_* defs in interp_internal.hh

{

    // static char name[] = "init_readonly_param";

	  "adding r/o '%s'", nameBuf);

	 "storing r/o '%s' %f", nameBuf, value);

    return INTERP_OK;

}

			   double index,

			   double *value)

{

	// some active_g_codes fields

    case NP_LINE: // _line - sequence number

    case NP_MOTION_MODE: // _motion_mode

    case NP_PLANE: // _plane

	case CANON_PLANE_XY:

	case CANON_PLANE_XZ:

	case CANON_PLANE_YZ:

	case CANON_PLANE_UV:

	case CANON_PLANE_UW:

	case CANON_PLANE_VW:

	}

	break;

    case NP_CCOMP: // _ccomp - cutter compensation

	*value =

    case NP_METRIC: // _metric

    case NP_IMPERIAL: // _imperial

    case NP_ABSOLUTE: // _absolute - distance mode

    case NP_INCREMENTAL: // _incremental - distance mode

    case NP_INVERSE_TIME: // _inverse_time - feed mode

    case NP_UNITS_PER_MINUTE: // _units_per_minute - feed mode

    case NP_UNITS_PER_REV: // _units_per_rev - feed mode

    case NP_COORD_SYSTEM: // _coord_system - 0-9

	*value =

    case NP_TOOL_OFFSET: // _tool_offset

    case NP_RETRACT_R_PLANE: // _retract_r_plane - G98

    case NP_RETRACT_OLD_Z: // _retract_old_z - G99

    case NP_SPINDLE_RPM_MODE: // _spindle_rpm_mode G97

    case NP_SPINDLE_CSS_MODE: // _spindle_css_mode G96

    case NP_IJK_ABSOLUTE_MODE: //_ijk_absolute_mode - G90.1

    case NP_LATHE_DIAMETER_MODE: // _lathe_diameter_mode - G7

    case NP_LATHE_RADIUS_MODE: // _lathe_radius_mode - G8

	// some active_m_codes fields

    case NP_SPINDLE_ON: // _spindle_on

    case NP_SPINDLE_CW: // spindle_cw

    case NP_MIST: // mist

    case NP_FLOOD: // flood

    case NP_SPEED_OVERRIDE: // speed override

    case NP_FEED_OVERRIDE: // feed override

    case NP_ADAPTIVE_FEED: // adaptive feed

    case NP_FEED_HOLD: // feed hold

	// from active_settings:

    case NP_FEED: // feed

    case NP_RPM: // speed (rpm)

    case NP_CURRENT_TOOL:

    case NP_SELECTED_POCKET:

    case NP_CURRENT_POCKET:

    case NP_SELECTED_TOOL:

    case NP_X:  // current position

    case NP_Y:  // current position

    case NP_Z:  // current position

    case NP_A:  // current position

    case NP_B:  // current position

    case NP_C:  // current position

    case NP_U:  // current position

    case NP_V:  // current position

    case NP_W:  // current position

	// o-word subs may optionally have an

	// expression after endsub and return

	// this 'function return value' is accessible as '_value'

    case NP_VALUE:

	// predicate: the last NGC procedure did/did not return a value

    case NP_VALUE_RETURNED:

    case NP_CALL_LEVEL:

    case NP_REMAP_LEVEL:

    case NP_TASK:

	extern int _task;  // zero in gcodemodule, 1 in milltask

    default:

	      nameBuf,index);

    }

    return INTERP_OK;

}

{

    double value;

    parameter_value param;

	}

    }

}

{

// version       major   minor      Note

// ------------ -------- ---------- -------------------------------------

// M.N.m         M.N     0.m        normal format

// M.N.m~xxx     M.N     0.m        pre-release format

  // params tagged with PA_USE_LOOKUP will call the lookup_named_param()

  // method. The value is used as a index for the switch() statement.

  // the active_g_codes fields

  // I guess this is the line number

  // any of G1 G2 G3 G5.2 G73 G80 G82 G83 G86 G87 G88 G89

  // value is number after 'G' mutiplied by 10 (10,20,30,52..)

  // G17/18/19/17.1/18.1/19.1 -> return 170/180/190/171/181/191

  // return 400,410,420 depending if (G40,G41,G42) is on

  // 1.0 if G21 is on

  // 1.0 if G20 is on

  //1.0 if G90 is on

  //1.0 if G91 is on

  // 1.0 if G93 is on

  // 1.0 if G94 is on

  // 1.0 if G95 is on

  // 0..9 for G54..G59.3

  // 1.0 if G43 is on

  // 1 if G98 set

  // 1 if G99 set

  // really esoteric

  // init_readonly_param("_control_mode", 110, PA_USE_LOOKUP);

  // 1 if G97 is on

  // 1 if G90.1 is on

  // 1 if G7 is on

  // 1 if G8 is on

  // the active_m_codes fields

  // active_settings

  // tool related

  // current position - alias to #5420-#5429

  // last (optional) endsub/return value

  // predicate: last NGC procedure did return a value on endsub/return

  // predicate: 1 in milltask instance, 0 in UI - control preview behaviour

  // debugging aids