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

* Description: rs274ngc_pre.cc

*

*   Derived from a work by Thomas Kramer

*

* Author:

* License: GPL Version 2

* System: Linux

*

* Copyright (c) 2004 All rights reserved.

*

* Last change:

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

/* rs274ngc.cc

This rs274ngc.cc file contains the source code for (1) the kernel of

several rs274ngc interpreters and (2) two of the four sets of interface

functions declared in canon.hh:

1. interface functions to call to tell the interpreter what to do.

   These all return a status value.

2. interface functions to call to get information from the interpreter.

Kernel functions call each other. A few kernel functions are called by

interface functions.

Interface function names all begin with "Interp::".

Error handling is by returning a status value of either a non-error

code (INTERP_OK, INTERP_EXIT, etc.) or some specific error code

from each function where there is a possibility of error.  If an error

occurs, processing is always stopped, and control is passed back up

through the function call hierarchy to an interface function; the

error code is also passed back up. The stack of functions called is

also recorded. The external program calling an interface function may

then handle the error further as it sees fit.

Since returned values are usually used as just described to handle the

possibility of errors, an alternative method of passing calculated

values is required. In general, if function A needs a value for

variable V calculated by function B, this is handled by passing a

pointer to V from A to B, and B calculates and sets V.

There are a lot of functions named read_XXXX. All such functions read

characters from a string using a counter. They all reset the counter

to point at the character in the string following the last one used by

the function. The counter is passed around from function to function

by using pointers to it. The first character read by each of these

functions is expected to be a member of some set of characters (often

a specific character), and each function checks the first character.

This version of the interpreter not saving input lines. A list of all

lines will be needed in future versions to implement loops, and

probably for other purposes.

This version does not use any additional memory as it runs. No

memory is allocated by the source code.

This version does not suppress superfluous commands, such as a command

to start the spindle when the spindle is already turning, or a command

to turn on flood coolant, when flood coolant is already on.  When the

interpreter is being used for direct control of the machining center,

suppressing superfluous commands might confuse the user and could be

dangerous, but when it is used to translate from one file to another,

suppression can produce more concise output. Future versions might

include an option for suppressing superfluous commands.

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

#include "python_plugin.hh"

#include <boost/python/dict.hpp>

#include <boost/python/extract.hpp>

#include <boost/python/import.hpp>

#include <boost/python/list.hpp>

#include <boost/python/scope.hpp>

#include <boost/python/tuple.hpp>

#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 <stdarg.h>

#include <sys/time.h>

#include <time.h>

#include <unistd.h>

#include <libintl.h>

#include <set>

#include <stdexcept>

#include "rtapi.h"

#include "inifile.hh"		// INIFILE

#include "rs274ngc.hh"

#include "rs274ngc_return.hh"

#include "interp_internal.hh"	// interpreter private definitions

#include "interp_queue.hh"

#include "rs274ngc_interp.hh"

#include "units.h"

namespace bp = boost::python;

extern char * _rs274ngc_errors[];

    static char statustext[50];

    static const char *msgs[] = { "INTERP_OK", "INTERP_EXIT",

	    "INTERP_EXECUTE_FINISH", "INTERP_ENDFILE", "INTERP_FILE_NOT_OPEN",

	    "INTERP_ERROR" };

	    <= INTERP_ERROR)) ? msgs[status] : "unknown interpreter error",

}

extern struct _inittab builtin_modules[];

int trace;

static char savedError[LINELEN+1];

    : log_file(stderr),

{

    }

    try {

	// this import will register the C++->Python converter for Interp

	// use a boost::cref to avoid per-call instantiation of the

	// Interp Python wrapper (used for the 'self' parameter in handlers)

	// since interp.init() may be called repeatedly this would create a new

	// wrapper instance on every init(), abandoning the old one and all user attributes

	// tacked onto it, so make sure this is done exactly once

	// alias to 'interpreter.this' for the sake of ';py, .... ' comments

	// besides 'this', eventually use proper instance names to handle

	// several instances

	// make "this" visible without importing interpreter explicitly

    }

    catch (bp::error_already_set) {

	std::string exception_msg;

	if (PyErr_Occurred()) {

	    exception_msg = handle_pyerror();

	} else

	    exception_msg = "unknown exception";

	bp::handle_exception();

	PyErr_Clear();

	Error("PYTHON: exception during 'this' export:\n%s\n",exception_msg.c_str());

    }

}

{

}

    }

		   const char *fmt, ...)

{

    struct timeval tv;

    struct tm *tm;

    va_list ap;

	fprintf(log_file, "%04d%02d%02d-%02d:%02d:%02d.%03ld ",

		tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,

		tm->tm_hour, tm->tm_min, tm->tm_sec,

    }

    }

    }

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

/*

The functions in this section of this file are functions for

external programs to call to tell the rs274ngc interpreter

what to do. They are declared in rs274ngc.hh.

*/

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

/*! Interp::close

Returned Value: int (INTERP_OK)

Side Effects:

   The NC-code file is closed if open.

   The _setup world model is reset.

Called By: external programs

*/

{

    // be "lazy" only if we're not aborting a call in progress

    // in which case we need to reset() the call stack

    // this does not reset the filename properly

    {

    }

  }

}

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

/*! Interp::execute

Returned Value: int)

   If execute_block returns INTERP_EXIT, this returns that.

   If execute_block returns INTERP_EXECUTE_FINISH, this returns that.

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

   Otherwise, this returns INTERP_OK.

Side Effects:

   Calls to canonical machining commands are made.

   The interpreter variables are changed.

   At the end of the program, the file is closed.

   If using a file, the active G codes and M codes are updated.

Called By: external programs

This executes a previously parsed block.

*/

{

  int status;

  int n;

  extern const char *call_statenames[];

  extern const char *call_typenames[];

  extern const char *o_ops[];

	// if (status > INTERP_MIN_ERROR)

	//     _setup.remap_level = 0;

	return status;

    }

  }

	   MDImode ? "MDI" : "auto",

	   command ? "command" : "line",

	   command ? command : _setup.linetext,

	    _setup.mdi_interrupt, o_ops[eblock->o_type], eblock->o_name,

	   _setup.call_level,_setup.remap_level,

	   eblock->call_type < 0 ? "*unset*" : call_typenames[eblock->call_type],

	   call_statenames[_setup.call_state]);

  // process control functions -- will skip if skipping

      // let MDI code call subroutines.

      // !!!KL not clear what happens if last execution failed while in

      // !!!KL a subroutine

      // NOTE: the last executed file will still be open, because "close"

      // is really a lazy close.

      // we had an INTERP_OK, so no need to set up another call to finish after sync()

      }

      {

	      }

          }

      }

      return INTERP_OK;

    }

  // skip if skipping

    {

      return INTERP_OK;

    }

  {  // copy parameter settings from parameter buffer into parameter table

  }

  // logDebug("_setup.named_parameter_occurrence = %d",

  //          _setup.named_parameter_occurrence);

  {  // copy parameter settings from parameter buffer into parameter table

                          _setup.named_parameter_values[n]));

  }

      // at this point we have a parsed block

      // if items are to be remapped the flow is as follows:

      //

      // 1. push this block onto the remap stack because this might take several

      //    interp invcocations to finish, while other blocks will be parsed and

      //    executed by the oword subs. The top-of-stack block is the 'current

      //    remapped block' or CONTROLLING_BLOCK.

      //

      // 2. execute the remap stack top level block, ticking off all items which are done.

      //

      // 3. when a remap operation is encountered, this will result in a call like so:

      //   'o<replacement>call'.

      //

      //   this replacement call is parsed with read() into _setup.blocks[0] by the

      //   corresponding routine (see e.g. handling of T in interp_execute.cc)

      //   through calling into convert_remapped_code()

      //

      // 4. The oword call code might execute an optional prologue handler which is called

      //    when the subroutine environment is set up (parameters set, execution of

      //    body to begin). This is the way to set local named parameters e.g. for canned cycles.

      //

      // 5. The oword endsub/return code might call an epilogue handler

      //   which finishes any work at the Python level on endsub/return, and thereafter

      //   calls back into remap_finished().

      //

      // 6. The execution stops after parsing, and returns with an indication of the

      //   execution phase. We use negative values of enum steps to distinguish them

      //   from normal INTERP_* type codes which are all >= 0.

      //

      // 7. In MDI mode, we have to kick execution by replicating code from above

      //   to get the osub call going.

      //

      // 8. In Auto mode, we do an initial execute(0) to get things going, thereafer

      //   task will do it for us.

      //

      // 9. When a replacment sub finishes, remap_finished() continues execution of

      //   the current remapped block until done.

      //

	  std::set<int>::iterator it;

		  next_remap,_setup.blocktext,_setup.call_level,_setup.filename,_setup.sequence_number);

	  // execute up to the first remap including read() of its handler

	  // this also sets cblock->executing_remap

#if 0

	  // this is too naive a test and needs improving (aka: not segfault).

	  // It needs to kick in only for  new codes, not remapped ones, for which

	  // recursion just means 'use builtin semantics'

	  // add some kind of 'is_remapped_builtin()' macro or test method

	  // detect a remapping recursion.

	  // since each remapped item pushes a new block onto the remap stack, we walk

	  // the remap stack searching for an identical remap below the TOS

	  for (int i = _setup.remap_level - 1; i > 0; i--) {

	      if (_setup.blocks[i].executing_remap == cblock->executing_remap) {

		  ERS("recursive remapping for %s detected", cblock->executing_remap->name);

	      }

	  }

#endif

	  // All items up to the first remap item have been executed.

	  // The remap item procedure call has been parsed into _setup.blocks[0],

	  // the EXECUTING_BLOCK.

	  // after parsing a handler, execute_block() either fails to toplevel or

	  // returns the negative value of phase (to distinguish them from INTERP_* codes which are all >= 0)

	      // the remap phase indicator was returned.

	      // sanity:

	      }

		  // need to trigger execution of parsed _setup.block1 here

		  // replicate MDI oword execution code here

		      (_setup.mdi_interrupt)) {

		      }

		      }

		      // at this point the MDI execution of a remapped block is complete.

		      return INTERP_OK;

		  }

	      } else {

		  // this should get the osub going

		  // when this is done, blocks[0] will be executed as per standard case

		  // on endsub/return and g_codes/m_codes/settings recorded there.

	      }

	  } else {

	  }

      } else {

	  // standard case: unremapped block execution

	      // an M2 was encountered while executing a handler.

		      interp_status(status),_setup.remap_level,_setup.call_level, _setup.blocktext,MDImode);

		      _setup.filename,

		      _setup.sub_context[0].filename,

		      _setup.sub_context[1].filename);

	  }

      }

  } else                        /* blank line is OK */

    status = INTERP_OK;

}

{

    int status;

    }

}

{

}

{

    int status;

    }

	(_setup.mdi_interrupt)) {

    }

}

// when a remapping sub finishes, the oword return/endsub handling code

// calls back in here to continue block execution

{

    int next_remap,status;

	  phase, _setup.remap_level,_setup.call_level,_setup.filename);

    // the controlling block had a remapped item, which just finished and the

    // oword return/endsub code called in here.

	// paranoia.

	}

	// done with this phase.

	// check the controlling block for the next remapped item

	    // this will execute up to the next remap, and return

	    // after parsing the handler with read()

	    // so blocks[0] is armed (meaning: a osub call is parsed, but not executed yet)

		// a remap was parsed, get the block going

	    } else

		return status;

	} else {

	    }

	    // execution of controlling block finished executing a remap, and it contains no more

	    // remapped items. Execute any leftover items.

		     _setup.remap_level,_setup.call_level,cblock->remappings.size());

		// status < 0 is a bug; might happen if find_remappings() failed to indicate the next remap

			 status < 0 ? "BUG":"ERROR", interp_status(status),_setup.remap_level,_setup.call_level);

	    } else {

		// we're done with this remapped block.

		// execute_block may return INTERP_EXECUTE_FINISH if a probe, input or toolchange

		// command was executed.

		// not sure what INTERP_ENDFILE & INTERP_EXIT really mean here.

		// if ((status == INTERP_OK) || (status == INTERP_ENDFILE) || (status == INTERP_EXIT) || (status == INTERP_EXECUTE_FINISH)) {

		// leftover items finished. Drop a remapping level.

			 interp_status(status),_setup.remap_level,_setup.call_level,_setup.toolchange_flag,

			_setup.probe_flag,_setup.input_flag,_setup.mdi_interrupt,_setup.sequence_number,

			 cblock->line_number);

	    }

	}

    } else {

	// "should not happen"

	    phase, _setup.remap_level);

    }

    return INTERP_OK;

}

// examine a block for an active items which are remapped

// insert all remapped item phases into block.remapping set

// return number of remaps found

{

	else

    }

	else

    }

	else

    }

    // User defined M-Codes in group 5

    // User defined M-Codes in group 6 (including M6, M61)

    // call the remap procedure if it the code in that group is remapped unless:

    // it's an M6 or M61 and a remap is in progress

    // (recursion case)

    } // else we get the builtin behaviour

    // User defined M-Codes in group 7

    // User defined M-Codes in group 8

    // User defined M-Codes in group 9

    // User defined M-Codes in group 10

    // User-defined motion codes (G0 to G3, G33, G73, G76, G80 to G89)

    // as modified (possibly) by G53.

    // this makes it possible to call remapped codes like cycles:

    // G84.2 x1 y2

    // x3

    // will execute 'G84.2 x1 y2', then 'G84.2 x3 y2'

    // provided the remap function explicitly sets motion_mode like so:

    // def g842(self,**words):

    //     ....

    //     self.motion_mode = 842

    //     return INTERP_OK

    }

    // User defined M-Codes in group 4 (stopping)

	    // these require real work.

	    // remap_in_progress("M2") ||

	    // remap_in_progress("M60")

	} else {

	}

    }

}

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

/*! Interp::exit

Returned Value: int (INTERP_OK)

Side Effects: See below

Called By: external programs

The system parameters are saved to a file and some parts of the world

model are reset. If GET_EXTERNAL_PARAMETER_FILE_NAME provides a

non-empty file name, that name is used for the file that is

written. Otherwise, the default parameter file name is used.

*/

{

  char file_name[LINELEN];

                             0) ?

                            RS274NGC_PARAMETER_FILE_NAME_DEFAULT :

  // interpreter shutdown Python hook

      bp::list plist;

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

	  // this likely wont make it to the UI's any more so bark on stderr

      }

  }

}

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

/*! rs274_ngc_init

Returned Value: int

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

   Otherwise, this returns INTERP_OK.

   1. Interp::restore_parameters returns an error code.

Side Effects:

   Many values in the _setup structure are reset.

   A USE_LENGTH_UNITS canonical command call is made.

   A SET_FEED_REFERENCE canonical command call is made.

   A SET_ORIGIN_OFFSETS canonical command call is made.

   An INIT_CANON call is made.

Called By: external programs

Currently we are running only in CANON_XYZ feed_reference mode.  There

is no command regarding feed_reference in the rs274 language (we

should try to get one added). The initialization routine, therefore,

always calls SET_FEED_REFERENCE(CANON_XYZ).

*/

{

  int k;                        // starting index in parameters of origin offsets

  char filename[LINELEN];

  double *pars;                 // short name for _setup.parameters

  char *iniFileName;

  IniFile::ErrorCode r;

  // the default log file

  // default arc radius tolerances

  // we'll try to override these from the ini file below

      } else {

          const char *inistring;

          }

          }

          }

          {

          }

	  // default the log_file to stderr.

          {

			  getpid(), inistring);

	      }

          } else {

	  }

          {

        	//realpath didn't find the file

            }

          }

          {

	    // found it

            char expandinistring[LINELEN];

            }

        	//realpath didn't find the file

            }

		     inistring, _setup.program_prefix);

          }

          else

          {

          }

          {

            // found it

            int dct;

            char* nextdir;

            char tmpdirs[PATH_MAX+1];

            }

            while (1) {

                char tmp_path[PATH_MAX];

                char expandnextdir[LINELEN];

                }

                   //realpath didn't find the directory

                } else {

                }

                }

          }

          else

          {

          }

          // subroutine to execute on aborts - for instance to retract

          // toolchange HAL pins

          } else {

          }

	  // initialize the Python plugin singleton

	      }

	  }

						   n, &lineno))) {

	  }

          // if exist and within bounds, apply ini file arc tolerances

          // limiting figures are defined in interp_internal.hh

          r = inifile.Find(

              &_setup.center_arc_radius_tolerance_inch,

              MIN_CENTER_ARC_RADIUS_TOLERANCE_INCH,

              CENTER_ARC_RADIUS_TOLERANCE_INCH,

              "CENTER_ARC_RADIUS_TOLERANCE_INCH",

              "RS274NGC"

          }

          r = inifile.Find(

              &_setup.center_arc_radius_tolerance_mm,

              MIN_CENTER_ARC_RADIUS_TOLERANCE_MM,

              CENTER_ARC_RADIUS_TOLERANCE_MM,

              "CENTER_ARC_RADIUS_TOLERANCE_MM",

              "RS274NGC"

          }

	  // ini file g52/g92 offset persistence default setting

	  inifile.Find(&_setup.disable_g92_persistence,

		       "DISABLE_G92_PERSISTENCE",

          // close it

      }

  }

  }

  SET_G5X_OFFSET(_setup.origin_index,

                 _setup.origin_offset_x ,

                 _setup.origin_offset_y ,

                 _setup.origin_offset_z ,

                 _setup.AA_origin_offset,

                 _setup.BB_origin_offset,

                 _setup.CC_origin_offset,

                 _setup.u_origin_offset ,

                 _setup.v_origin_offset ,

  // Restore G92 offset if DISABLE_G92_PERSISTENCE not set in .ini file.

  // This can't be done with the static _required_parameters[], where

  // the .vars file contents would reflect that setting, so instead

  // edit the restored parameters here.

      // Persistence disabled:  clear g92 parameters

  } else {

  }

  SET_G92_OFFSET(_setup.axis_offset_x ,

                 _setup.axis_offset_y ,

                 _setup.axis_offset_z ,

                 _setup.AA_axis_offset,

                 _setup.BB_axis_offset,

                 _setup.CC_axis_offset,

                 _setup.u_axis_offset ,

                 _setup.v_axis_offset ,

//_setup.active_g_codes initialized below

//_setup.active_m_codes initialized below

//_setup.active_settings initialized below

//_setup.block1 does not need initialization

//_setup.current_slot set in Interp::synch

//_setup.current_x set in Interp::synch

//_setup.current_y set in Interp::synch

//_setup.current_z set in Interp::synch

//_setup.feed_override set in Interp::synch

//_setup.feed_rate set in Interp::synch

//_setup.flood set in Interp::synch

//  _setup.tool_offset_index = 1;  // unused - removed, mah

//_setup.length_units set in Interp::synch

//_setup.mist set in Interp::synch

//_setup.origin_index set above

//_setup.parameters set above

//_setup.parameter_occurrence does not need initialization

//_setup.parameter_numbers does not need initialization