---

rs274ngc.cc

Go to the documentation of this file.

/*
  rs274ngc.cc

  Interpreter for Next Generation Controller (NGC) dialect of RS-274.

  Modification history:

  7-Aug-2000  FMP took 'static' off _interpreter_settings for non-
  standalone EMC also, since we want access to these for viewing.
  3-Aug-2000  FMP removed CANON_UPDATE_POSITION(), and accomplished the same
  thing in the canonical interface implementation directly, where it belonged.
  24-Feb-2000  FMP added call to CANON_UPDATE_POSITION() in rs274ngc_synch()
  20-Dec-1999  FMP made fix to convert_straight_comp2 to handle problem
  with atan2(0,0).
  17-Nov-1999  FMP fixed argument reversal in one call to ERROR_MACRO;
  removed two redundant sections of code in rs274ngc_init().
  10-Jun-1999  FMP added TOLERANCE_CONCAVE_CORNER instead of hard-coded
  0.001, the angle in radians above which a corner is flagged as concave.
  The value in rs274ngc.hh was made 0.01, half a degree, since the smaller
  value was invisible to programmers and they complained.
  14-May-1999  FMP added printing of _interpreter_linetext in error
  macros; moved globals to top of file since _interpreter_linetext is
  now referenced in many functions.
  19-Feb-1999  FMP added setting of parameters 5211-5213 in
  convert_axis_offsets() and rs274ngc_init()
  17-Feb-1999  FMP took axis_offset_x,y,z out of origin resetting in
  convert_stop(), so that the G92 axis offsets persist after a program end.
  Previously they were cleared, and since they were not recorded in the
  parameters there was no way to recover them.
  12-Feb-1999  TRK fixed convert_stop so that offsets were set to zero,
  fixing a bug in G92; FMP checked into RCS; added this header and the
  RCS ident tag.
  */

/* code header

ABOUT THE rs274ngc.cc FILE:

The rs274ngc.cc file contains the source code for the rs274ngc
interpreter, excluding a main routine and initialization routines.
The file has two sections: the kernel functions (which are not
intended to be called by programs using the interpreter), and
the interface functions (which are intended to be called).
The names of the interface functions start with "rs274ngc".

Error handling throughout the system is by returning a status value of
RS274NGC_OK or RS274NGC_ERROR from each function where there is a
possibility of error.  An appropriate error message will be printed
for each error.  If an error occurs, processing is always stopped, and
control is passed back up through the function call hierarchy to the
highest level function called which is defined in this file. Error
reporting is handled by the CANON_ERROR function defined externally.

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 is does not use any noticeable additional memory as it
runs. Only comments in the NC code are malloc'ed, and that memory is
freed when the next line of code is read. There should not be any
memory leaks.

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 <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <ctype.h>              // for read_text CR, LF removal
#include "canon.hh"
#include "rs274ngc.hh"

// ident tag
static char ident[] = "$Id: rs274ngc.cc,v 1.4 2000/10/27 20:34:44 terrylr Exp $";

/* the current interpreter settings */

#ifdef STAND_ALONE_INTERP

#define DEBUG_EMC
setup _interpreter_settings;

#else

#define DEBUG_EMC
setup _interpreter_settings;

#endif

/*

The following two function prototypes are for two functions which are
used recursively by each other and therefore have forward references
regardless of the order in which they are defined.

*/

int read_real_value(char * line, int * counter,
                    double * double_ptr, double * parameters);
int read_real_expression(char * line, int * counter,
                            double * hold2, double * parameters);

/* Interpreter global arrays for g_codes and m_codes. The nth entry
in each array is the modal group number corresponding to the nth
code. Entries which are -1 represent illegal codes. Remember g_codes
in this interpreter are multiplied by 10.

The modal g groups and group numbers defined in [NCMS, pages 71 - 73]
are used here, except the canned cycles (g80 - g89), which comprise
modal g group 9 in [NCMS], are treated here as being in the same modal
group (group 1) with the straight moves and arcs (g0, g1, g2,g3).
The straight_probe move, g38.2, is in group 1; it is not defined in
[NCMS].

Some g_codes (g4, g10, g53, g92, and g92.2 here - many more in [NCMS])
are non-modal. [NCMS] puts all these in the same group 0.  Logically,
there are two subgroups, those which require coordinate values and
those which do not. Here we are using separate groups for these two.
In group 0 we have put the ones that take coordinate values (g10,
g92), and g92.2, which cancels g92.  In group 4 (which is not
otherwise being used) we have put the ones that do not use coordinate
values (g4, g53). We are allowing only one g_code from the combined
groups 0 and 4 on a line. Those in group 0 may not be on the same line
as those in group 1 (except g80) because they would be competing for
the axis values. Those in group 4 may be used on the same line as
those in group 1.

There is no evident reason why only one of our modal group 4 should be
allowed on a line, and it is not clear what the intent of [NCMS] is
regarding how many of these may be on the same line. We are following
the rule given above, however.

The groups are:
group  0 = {g10,g92,g92.2} - setup, set axis offsets (non-modal)
group  1 = {g0,g1,g2,g3,g38.2,g80,g81,g82,g83,g84,g85,g86,g87,g88,g89} - motion
group  2 = {g17,g18,g19}   - plane selection
group  3 = {g90,g91}       - distance mode
group  4 = {g4, g53}       - dwell, motion in abs coords (non-modal)
group  5 = {g93,g94}       - spindle speed mode
group  6 = {g20,g21}       - units
group  7 = {g40,g41,g42}   - cutter diameter compensation
group  8 = {g43,g49}       - tool length offset
group 10 = {g98,g99}       - return mode in canned cycles
group 12 = {g54,g55,g56,g57,g58,g59,g59.1,g59.2,g59.3} - coordinate system
group 13 = {g61,g64}       - motion mode (exact stop or cutting)

*/

static int gees[] SET_TO {
/*   0 */   1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*  20 */   1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*  40 */   4,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*  60 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*  80 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 100 */   0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 120 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 140 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 160 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 2,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 180 */   2,-1,-1,-1,-1,-1,-1,-1,-1,-1, 2,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 200 */   6,-1,-1,-1,-1,-1,-1,-1,-1,-1, 6,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 220 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 240 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 260 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 280 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 300 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 320 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 340 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 360 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 380 */  -1,-1, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 400 */   7,-1,-1,-1,-1,-1,-1,-1,-1,-1, 7,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 420 */   7,-1,-1,-1,-1,-1,-1,-1,-1,-1, 8,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 440 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 460 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 480 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 8,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 500 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 520 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 4,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 540 */  12,-1,-1,-1,-1,-1,-1,-1,-1,-1,12,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 560 */  12,-1,-1,-1,-1,-1,-1,-1,-1,-1,12,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 580 */  12,-1,-1,-1,-1,-1,-1,-1,-1,-1,12,12,12,12,-1,-1,-1,-1,-1,-1,
/* 600 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,13,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 620 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 640 */  13,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 660 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 680 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 700 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 720 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 740 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 760 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 780 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 800 */   1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 820 */   1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 840 */   1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 860 */   1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 880 */   1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 900 */   3,-1,-1,-1,-1,-1,-1,-1,-1,-1, 3,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 920 */   0,-1, 0,-1,-1,-1,-1,-1,-1,-1, 5,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 940 */   5,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 960 */  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/* 980 */  10,-1,-1,-1,-1,-1,-1,-1,-1,-1,10,-1,-1,-1,-1,-1,-1,-1,-1,-1};

/*

Modal groups and modal group numbers for M codes are described in [NCMS,
page 7]. We have added M60 as an extension of the language
so the language can be used to control the K&T 800 machine.

The groups are:
group 4 = {m0,m1,m2,m30,m60} - stopping
group 6 = {m6}               - tool change
group 7 = {m3,m4,m5}         - spindle turning
group 8 = {m7,m8,m9}         - coolant
group 9 = {m48,m49}          - feed and speed override switch bypass

*/

static int ems[] SET_TO {
   4,  4,  4,  7,  7,  7,  6,  8,  8,  8,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
   4, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1,  9,  9,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
   4, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};

/*

This is the list of error messages that may be generated. Messages
numbered 0 through 199 result from errors in the input to the interpreter.
Messages numbered 200 and above result from bugs in the interpreter and
should never be received.

*/

char * interp_errors[] SET_TO {
/*   0 */ "Unspecified error", /*  see note above */
/*   1 */ "All axes missing with G92", /* check_g_codes */
/*   2 */ "Arc radius too small to reach end point", /* arc_data_r */
/*   3 */ "Argument to acos out of range", /* execute_unary */
/*   4 */ "Argument to asin out of range", /* execute_unary */
/*   5 */ "Attempt to divide by zero", /* execute_binary1 */
/*   6 */ "Bad character used", /* read_one_item */
/*   7 */ "Bad format unsigned integer", /* read_integer_unsigned */
/*   8 */ "Bad number format", /* read_real_number */
/*   9 */ "Bad tool radius value with cutter radius comp",
        /* convert_arc_comp1, convert_arc_comp2, convert_straight_comp1,
           convert_straight_comp2 */
/*  10 */ "Cannot change axis offsets with cutter radius comp",
        /* convert_axis_offsets */
/*  11 */ "Cannot change units with cutter radius comp",
        /* convert_length_units */
/*  12 */ "Cannot create backup file", /* rs274ngc_save_parameters */
/*  13 */ "Cannot do G1 with zero feed rate", /* convert_straight */
/*  14 */ "Cannot do zero repeats of cycle", /* convert_cycle */
/*  15 */ "Cannot have concave corner with cutter radius comp",
        /* convert_straight_comp2 */
/*  16 */ "Cannot make arc with zero feed rate", /* convert_arc */
/*  17 */ "Cannot open backup file", /* rs274ngc_save_parameters */
/*  18 */ "Cannot open file", /* rs274ngc_restore_parameters */
/*  19 */ "Cannot open variable file", /* rs274ngc_save_parameters */
/*  20 */ "Cannot probe in inverse time feed mode", /* convert_motion */
/*  21 */ "Cannot probe with cutter radius compensation on",
        /* convert_motion */
/*  22 */ "Cannot probe with zero feed rate", /* convert_motion */
/*  23 */ "Cannot put an M code for stopping with G38.2", /* check_items */
/*  24 */ "Cannot raise negative number to non-integer power",
        /* execute_binary1 */
/*  25 */ "Cannot turn cutter radius comp on out of XY-plane",
        /* convert_cutter_compensation_on */
/*  26 */ "Cannot turn cutter radius comp on when already on",
        /* convert_cutter_compensation_on */
/*  27 */ "Cannot use G0 with cutter radius comp", /* convert_straight */
/*  28 */ "Cannot use G53 in incremental distance mode", /* check_g_codes */
/*  29 */ "Cannot use G53 with cutter radius comp", /* convert_straight */
/*  30 */ "Cannot use XZ plane with cutter radius comp",
        /* convert_set_plane */
/*  31 */ "Cannot use YZ plane with cutter radius comp",
        /* convert_set_plane */
/*  32 */ "Cannot use a G code for motion with G10", /* check_g_codes */
/*  33 */ "Cannot use a G motion with G92", /* check_g_codes */
/*  34 */ "Cannot use axis commands with G4", /* check_g_codes */
/*  35 */ "Cannot use axis commands with G80", /* check_g_codes */
/*  36 */ "Cannot use inverse time feed with cutter radius comp",
        /* convert_straight */
/*  37 */ "Cannot use two G codes from group 0", /* check_g_codes */
/*  38 */ "Command too long", /* close_and_downcase, rs274ngc_execute */
/*  39 */ "Concave corner with cutter radius comp", /* convert_arc_comp2 */
/*  40 */ "Coordinate setting given with G80", /* convert_motion */
/*  41 */ "Current point same as end point of arc",
        /* arc_data_comp_r, arc_data_r */
/*  42 */ "Cutter gouging with cutter radius comp",
        /* convert_straight_comp1 */
/*  43 */ "D word missing with cutter radius comp on",
        /* convert_cutter_compensation_on */
/*  44 */ "D word on line with no cutter comp on (G41 or G42) command",
        /* check_other_codes */
/*  45 */ "Dwell time missing with G4", /* check_g_codes */
/*  46 */ "Equal sign missing in parameter setting",
        /* read_parameter_setting */
/*  47 */ "F word missing with inverse time G1 move", /* convert_straight */
/*  48 */ "F word missing with inverse time arc move", /* convert_motion */
/*  49 */ "File ended with no stopping command given", /* rs274ngc_read */
/*  50 */ "G code out of range", /* read_g */
/*  51 */ "H word on line with no tool length comp (G43) command",
        /* check_other_codes */
/*  52 */ "I word given for arc in YZ-plane", /* convert_arc */
/*  53 */ "I word missing with G87", /* convert_cycle */
/*  54 */ "I word on line with no G code (G2, G3, G87) that uses it",
        /* check_other_codes */
/*  55 */ "J word given for arc in XZ-plane", /* convert_arc */
/*  56 */ "J word missing with G87", /* convert_cycle */
/*  57 */ "J word on line with no G code (G2, G3, G87) that uses it",
        /* check_other_codes */
/*  58 */ "K word given for arc in XY-plane", /* convert_arc */
/*  59 */ "K word missing with G87", /* convert_cycle */
/*  60 */ "K word on line with no G code (G2, G3, G87) that uses it",
        /* check_other_codes */
/*  61 */ "L word on line with no canned cycle or G10 to use it",
        /* check_other_codes */
/*  62 */ "Left bracket missing after slash with atan operator",
        /* read_atan */
/*  63 */ "Left bracket missing after unary operation name", /* read_unary */
/*  64 */ "Line number greater than 99999", /* read_line_number */
/*  65 */ "Line with G10 does not have L2", /* check_g_codes */
/*  66 */ "M code greater than 99", /* read_m */
/*  67 */ "Mixed radius-ijk format for arc", /* convert_arc */
/*  68 */ "Multiple D words on one line", /* read_d */
/*  69 */ "Multiple F words on one line", /* read_f */
/*  70 */ "Multiple I words on one line", /* read_i */
/*  71 */ "Multiple J words on one line", /* read_j */
/*  72 */ "Multiple K words on one line", /* read_k */
/*  73 */ "Multiple L words on one line", /* read_l */
/*  74 */ "Multiple P words on one line", /* read_p */
/*  75 */ "Multiple Q words on one line", /* read_q */
/*  76 */ "Multiple R words on one line", /* read_r */
/*  77 */ "Multiple S word spindle speed settings on one line",
        /* read_spindle_speed */
/*  78 */ "Multiple T words (tool ids) on one line", /* read_tool */
/*  79 */ "Multiple X words on one line", /* read_x */
/*  80 */ "Multiple Y words on one line", /* read_y */
/*  81 */ "Multiple Z words on one line", /* read_z */
/*  82 */ "Multiple tool length offsets on one line", /* read_tool_length_offset */
/*  83 */ "Must use G0 or G1 with G53", /* check_g_codes */
/*  84 */ "Negative D code used", /* read_d */
/*  85 */ "Negative F word found", /* read_f */
/*  86 */ "Negative G code used", /* read_g */
/*  87 */ "Negative L word used", /* read_l */
/*  88 */ "Negative M code used", /* read_m */
/*  89 */ "Negative P value used", /* read_p */
/*  90 */ "Negative Q value used", /* read_q */
/*  91 */ "Negative argument to sqrt", /* execute_unary */
/*  92 */ "Negative spindle speed found", /* read_spindle_speed */
/*  93 */ "Negative tool id used", /* read_tool */
/*  94 */ "Negative tool length offset used", /* read_tool_length_offset */
/*  95 */ "Nested comment found", /* close_and_downcase */
/*  96 */ "No characters found in reading real value", /* read_real_value */
/*  97 */ "No digits found where real number should be", /* read_real_number */
/*  98 */ "Non-integer value for integer", /* read_integer_value */
/*  99 */ "Null missing after newline", /* close_and_downcase */
/* 100 */ "Offset index missing", /* convert_tool_length_offset */
/* 101 */ "P value not an integer with G10 L2", /* check_g_codes */
/* 102 */ "P value out of range with G10 L2", /* check_g_codes */
/* 103 */ "P word (dwell time) missing with G82", /* convert_cycle */
/* 104 */ "P word (dwell time) missing with G86", /* convert_cycle */
/* 105 */ "P word (dwell time) missing with G88", /* convert_cycle */
/* 106 */ "P word (dwell time) missing with G89", /* convert_cycle */
/* 107 */"P word on line with no G code (G4 G10 G82 G86 G88 G89) that uses it",
        /* check_other_codes */
/* 108 */ "Parameter number out of range",
        /* read_parameter, read_parameter_setting, rs274ngc_restore_parameters,
           rs274ngc_save_parameters */
/* 109 */ "Q word (depth increment) missing with G83", /* convert_cycle */
/* 110 */ "Q word on line with no G83 cycle that uses it",
        /* check_other_codes */
/* 111 */ "Queue is not empty after probing",
        /* rs274ngc_execute, rs274ngc_read */
/* 112 */ "R clearance plane unspecified in canned cycle", /* convert_cycle */
/* 113 */ "R value less than Z value in canned cycle", /* convert_cycle */
/* 114 */ "R word on line with no G code (arc or cycle) that uses it",
        /* check_other_codes */
/* 115 */ "R, I, J, and K words all missing for arc", /* convert_arc */
/* 116 */ "Radius to end of arc differs from radius to start of arc",
        /* arc_data_comp_ijk, arc_data_ijk */
/* 117 */ "Radius too small to reach end point", /* arc_data_comp_r */
/* 118 */ "Selected tool slot number too large", /* convert_tool_select */
/* 119 */ "Slash missing", /* read_atan */
/* 120 */ "Spindle not turning clockwise in G84 canned cycle",
        /* convert_cycle_g84 */
/* 121 */ "Spindle not turning in G86 canned cycle", /* convert_cycle_g86 */
/* 122 */ "Spindle not turning in G87 canned cycle", /* convert_cycle_g87 */
/* 123 */ "Spindle not turning in G88 canned cycle", /* convert_cycle_g88 */
/* 124 */ "Too many G codes on line", /* check_g_codes */
/* 125 */ "Too many M codes on line", /* check_m_codes */
/* 126 */ "Tool index out of bounds", /* convert_tool_length_offset */
/* 127 */ "Tool radius not less than arc radius with cutter radius comp",
        /* arc_data_comp_r, convert_arc_comp2 */
/* 128 */ "Two G codes used from same modal group", /* read_g */
/* 129 */ "Two M codes used from same modal group", /* read_m */
/* 130 */ "Unable to open file", /* rs274ngc_open */
/* 131 */ "Unclosed comment found", /* close_and_downcase */
/* 132 */ "Unclosed expression", /* read_operation */
/* 133 */ "Unknown G code used", /* read_g */
/* 134 */ "Unknown M code used", /* read_m */
/* 135 */ "Unknown operation name starting with A", /* read_operation */
/* 136 */ "Unknown operation name starting with M", /* read_operation */
/* 137 */ "Unknown operation name starting with O", /* read_operation */
/* 138 */ "Unknown operation name starting with X", /* read_operation */
/* 139 */ "Unknown operation", /* read_operation */
/* 140 */ "Unknown word starting with A", /* read_operation_unary */
/* 141 */ "Unknown word starting with C", /* read_operation_unary */
/* 142 */ "Unknown word starting with E", /* read_operation_unary */
/* 143 */ "Unknown word starting with F", /* read_operation_unary */
/* 144 */ "Unknown word starting with L", /* read_operation_unary */
/* 145 */ "Unknown word starting with R", /* read_operation_unary */
/* 146 */ "Unknown word starting with S", /* read_operation_unary */
/* 147 */ "Unknown word starting with T", /* read_operation_unary */
/* 148 */ "Unknown word where unary operation could be",
        /* read_operation_unary */
/* 149 */ "X and Y words missing for arc in XY-plane", /* convert_arc */
/* 150 */ "X and Z words missing for arc in XZ-plane", /* convert_arc */
/* 151 */ "X, Y, and Z words all missing with G0 or G1", /* convert_straight */
/* 152 */ "X, Y, and Z words all missing with G38.2", /* convert_probe */
/* 153 */ "Y and Z words missing for arc in YZ-plane", /* convert_arc */
/* 154 */ "Z value unspecified in canned cycle", /* convert_cycle */
/* 155 */ "Zero or negative argument to ln", /* execute_unary */


"", "", "", "",
"", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "",

/* 200 */ "Bad setting of g_mode in check_g_codes",
/* 201 */ "Code is not G0 or G1 in convert_straight",
/* 202 */ "Code is not G0 to G3 or G80 to G89 in convert_motion",
/* 203 */ "Code is not G10, G92, or G92.2 in convert_modal_0",
/* 204 */ "Code is not G17, G18, or G19 in convert_set_plane",
/* 205 */ "Code is not G2 or G3 in arc_data_comp",
/* 206 */ "Code is not G2 or G3 in arc_data_ijk",
/* 207 */ "Code is not G20 or G21 in convert_length_units",
/* 208 */ "Code is not G40, G41, or G42 in convert_cutter_compensation",
/* 209 */ "Code is not G43 or G49 in convert_tool_length_offset",
/* 210 */ "Code is not G54 to G59.3 in convert_coordinate_system",
/* 211 */ "Code is not G61 or G64 in convert_control_mode",
/* 212 */ "Code is not G90 or G91 in convert_distance_mode",
/* 213 */ "Code is not G92 or G92.2 in convert_axis_offsets",
/* 214 */ "Code is not G93 or G94 in convert_feed_mode",
/* 215 */ "Code is not G98 or G99 in convert_retract_mode",
/* 216 */ "Code is not M0, M1, M2, M30 or M60 in convert_stop",
/* 217 */ "Convert_cycle should not have been called",
/* 218 */ "Distance mode is neither absolute nor incremental in convert_cycle",
/* 219 */ "Plane is not XY, YZ, or XZ in convert_arc",
/* 220 */ "Read_comment should not have been called",
/* 221 */ "Read_d should not have been called",
/* 222 */ "Read_f should not have been called",
/* 223 */ "Read_g should not have been called",
/* 224 */ "Read_i should not have been called",
/* 225 */ "Read_j should not have been called",
/* 226 */ "Read_k should not have been called",
/* 227 */ "Read_l should not have been called",
/* 228 */ "Read_line_number should not have been called",
/* 229 */ "Read_m should not have been called",
/* 230 */ "Read_p should not have been called",
/* 231 */ "Read_parameter should not have been called",
/* 232 */ "Read_parameter_setting should not have been called",
/* 233 */ "Read_q should not have been called",
/* 234 */ "Read_r should not have been called",
/* 235 */ "Read_real_expression should not have been called",
/* 236 */ "Read_spindle_speed should not have been called",
/* 237 */ "Read_tool should not have been called",
/* 238 */ "Read_tool_length_offset should not have been called",
/* 239 */ "Read_x should not have been called",
/* 240 */ "Read_y should not have been called",
/* 241 */ "Read_z should not have been called",
/* 242 */ "Side fails to be right or left in convert_straight_comp1",
/* 243 */ "Side fails to be right or left in convert_straight_comp2",
/* 244 */ "Sscanf failure in read_integer_unsigned",
/* 245 */ "Sscanf failure in read_real_number",
/* 246 */ "Unknown operation in execute_binary1",
/* 247 */ "Unknown operation in execute_binary2",
/* 248 */ "Unknown operation in execute_unary",

/* 249 */ ""};

/* these globals are used to implement the external interface and
   are referenced by the error macros */

#ifdef STAND_ALONE_INTERP

int _textline SET_TO 0;         /* set to 1 in rs274ngc_open */
char _interpreter_filename[INTERP_TEXT_SIZE];   /* file name */
char _interpreter_linetext[INTERP_TEXT_SIZE];    /* raw text */
char _interpreter_blocktext[INTERP_TEXT_SIZE]; /*parsed text */
block _interpreter_block SET_TO {0};    /* parsed next block */
FILE *_interpreter_fp SET_TO NULL;           /* file pointer */
int _interpreter_status SET_TO 0;

#else

static int _textline SET_TO 0;         /* set to 1 in rs274ngc_open */
static char _interpreter_filename[INTERP_TEXT_SIZE];   /* file name */
static char _interpreter_linetext[INTERP_TEXT_SIZE];    /* raw text */
static char _interpreter_blocktext[INTERP_TEXT_SIZE]; /*parsed text */
static block _interpreter_block SET_TO {0};    /* parsed next block */
static FILE *_interpreter_fp SET_TO NULL;           /* file pointer */
static int _interpreter_status SET_TO 0;

#endif

static int _interpreter_length SET_TO 0;    /* length of next line */
static int _interpreter_active_g_codes[RS274NGC_ACTIVE_G_CODES];
static int _interpreter_active_m_codes[RS274NGC_ACTIVE_M_CODES];
static double _interpreter_active_settings[RS274NGC_ACTIVE_SETTINGS];

// the file to use for storing params
char RS274NGC_PARAMETER_FILE[INTERP_TEXT_SIZE] =
                         DEFAULT_RS274NGC_PARAMETER_FILE;

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

/* utility_error_number

Returned Value: int (index number of error message in error_array)

Side effects: (none)

Called by: ERROR_MACRO, BUG_MACRO

This reads through the error message array until it finds one that
matches the given error message; then it returns the index of that
message in the array.  If the error message is not found, this returns
zero, the index of a string that says "Unspecified error". If zero
is ever returned, that indicates a bug in the error message array,
because all error messages in the system are supposed to be in that
array.

The initial value of index is always either 0 or 200 when this is
called, since the input error messages start at index 0 and the
internal error messages start at index 200 in the array.

This is a slow way to report errors, but all of these errors stop
the show, anyway, so an extra millisecond or two is not significant.

*/

int utility_error_number(/* ARGUMENT VALUES           */
 char * message,         /* string: the message text  */
 char * error_array[],   /* array of error messages   */
 int index)              /* index to start at         */
{
  for (;error_array[index][0] ISNT 0; index++)
    {
      if (strcmp(message, error_array[index]) IS 0)
        return index;
    }
  return 0;
}

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

/* execute_binary1

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. the operation is unknown.
   2. An attempt is made to divide by zero.
   3. An attempt is made to raise a negative number to a non-integer power.

Side effects:
   The result from performing the operation is put into what left points at.

Called by: read_real_expression.

This executes the operations: DIVIDED_BY, MODULO, POWER, TIMES.

*/

int execute_binary1( /* ARGUMENT VALUES                 */
 double * left,      /* pointer to the left operand     */
 int operation,      /* integer code for the operation  */
 double * right)     /* pointer to the right operand    */
{
  static char name[] SET_TO "execute_binary1";
  switch (operation)
    {
    case DIVIDED_BY:
      if (*right IS 0.0)
        ERROR_MACRO(_interpreter_linetext, name, "Attempt to divide by zero");
      else
        {
          *left SET_TO (*left / *right);
          return RS274NGC_OK;
        }
    case MODULO: /* always calculates a positive answer */
      *left SET_TO fmod(*left, *right);
      if (*left < 0.0)
        {
          *left SET_TO (*left + fabs(*right));
        }
      return RS274NGC_OK;
    case POWER:
      if ((*left < 0.0) AND (floor(*right) ISNT *right))
        ERROR_MACRO(_interpreter_linetext, name, "Cannot raise negative number to non-integer power");
      *left SET_TO pow(*left, *right);
      return RS274NGC_OK;
    case TIMES:
      *left SET_TO (*left * *right);
      return RS274NGC_OK;
    default:
      BUG_MACRO(name, "Unknown operation in execute_binary1");
    }
}

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

/* execute_binary2

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If the operation is unknown, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.

Side effects:
   The result from performing the operation is put into what left points at.

Called by: read_real_expression.

This executes the operations: AND2, EXCLUSIVE_OR, MINUS,
NON_EXCLUSIVE_OR, PLUS. The manual [NCMS] does not say what
the calculated value of the three logical operations should be. This
function calculates either 1.0 (meaning true) or 0.0 (meaning false).
Any non-zero input value is taken as meaning true, and only 0.0 means
false.


*/

int execute_binary2( /* ARGUMENT VALUES                 */
 double * left,      /* pointer to the left operand     */
 int operation,      /* integer code for the operation  */
 double * right)     /* pointer to the right operand    */
{
  static char name[] SET_TO "execute_binary2";
  switch (operation)
    {
    case AND2:
      *left SET_TO ((*left IS 0.0) OR (*right IS 0.0)) ? 0.0 : 1.0;
      return RS274NGC_OK;
    case EXCLUSIVE_OR:
      *left SET_TO (((*left IS 0.0) AND (*right ISNT 0.0)) OR
                    ((*left ISNT 0.0) AND (*right IS 0.0))) ? 1.0 : 0.0;
      return RS274NGC_OK;
    case MINUS:
      *left SET_TO (*left - *right);
      return RS274NGC_OK;
    case NON_EXCLUSIVE_OR:
      *left SET_TO ((*left ISNT 0.0) OR (*right ISNT 0.0)) ? 1.0 : 0.0;
      return RS274NGC_OK;
    case PLUS:
      *left SET_TO (*left + *right);
      return RS274NGC_OK;
    default:
      BUG_MACRO(name, "Unknown operation in execute_binary2");
    }
}

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

/* execute_unary

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. the operation is unknown
   2. the argument to acos or asin is not between minus and plus one
   3. the argument to the natural logarithm is not positive
   4. the argument to square root is negative

Side effects:
   The result from performing the operation on the value in double_ptr
   is put into what double_ptr points at.

Called by: read_unary.

This executes the operations: ABS, ACOS, ASIN, COS, EXP, FIX, FUP, LN
ROUND, SIN, SQRT, TAN

All angle measures in the input or output are in degrees.

*/

int execute_unary (   /* ARGUMENT VALUES                 */
 double * double_ptr, /* pointer to the operand          */
 int operation)       /* integer code for the operation  */
{
  static char name[] SET_TO "execute_unary";
  switch (operation)
    {
    case ABS:
      if (*double_ptr < 0.0)
          *double_ptr SET_TO (-1.0 * *double_ptr);
      return RS274NGC_OK;
    case ACOS:
      if ((*double_ptr < -1.0) OR (*double_ptr > 1.0))
        ERROR_MACRO(_interpreter_linetext, name, "Argument to acos out of range");
      else
        {
          *double_ptr SET_TO acos(*double_ptr);
          *double_ptr SET_TO ((*double_ptr * 180.0)/ PI);
          return RS274NGC_OK;
        }
    case ASIN:
      if ((*double_ptr < -1.0) OR (*double_ptr > 1.0))
        ERROR_MACRO(_interpreter_linetext, name, "Argument to asin out of range");
      else
        {
          *double_ptr SET_TO asin(*double_ptr);
          *double_ptr SET_TO ((*double_ptr * 180.0)/ PI);
          return RS274NGC_OK;
        }
    case COS:
      *double_ptr SET_TO cos((*double_ptr * PI)/180.0);
      return RS274NGC_OK;
    case EXP:
      *double_ptr SET_TO exp(*double_ptr);
      return RS274NGC_OK;
    case FIX:
      *double_ptr SET_TO floor(*double_ptr);
      return RS274NGC_OK;
    case FUP:
      *double_ptr SET_TO ceil(*double_ptr);
      return RS274NGC_OK;
    case LN:
      if (*double_ptr <= 0.0)
        ERROR_MACRO(_interpreter_linetext, name, "Zero or negative argument to ln");
      else
        {
          *double_ptr SET_TO log(*double_ptr);
          return RS274NGC_OK;
        }
    case ROUND:
      *double_ptr SET_TO (double)
        ((int) (*double_ptr + ((*double_ptr < 0.0) ? -0.5 : 0.5)));
      return RS274NGC_OK;
    case SIN:
      *double_ptr SET_TO sin((*double_ptr * PI)/180.0);
      return RS274NGC_OK;
    case SQRT:
      if (*double_ptr < 0.0)
        ERROR_MACRO(_interpreter_linetext, name, "Negative argument to sqrt");
      else
        {
          *double_ptr SET_TO sqrt(*double_ptr);
          return RS274NGC_OK;
        }
    case TAN:
      *double_ptr SET_TO tan((*double_ptr * PI)/180.0);
      return RS274NGC_OK;
    default:
      BUG_MACRO(name, "Unknown operation in execute_unary");
    }
}

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

/* read_atan

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. the first character to read is not a slash
   2. the second character to read is not a left bracket
   3. read_real_expression returns RS274NGC_ERROR while reading
      the second expression

Side effects:
   The computed value 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_unary

When this function is called, the characters "atan" and the first
argument have already been read, and the value of the first argument
is stored in double_ptr.  This function attempts to read a slash and
the second argument to the atan function, starting at the index given
by the counter and then to compute the value of the atan operation
applied to the two arguments.  The computed value is inserted into
what double_ptr points at.

The computed value is in the range from -180 degrees to +180 degrees.
The range is not specified in the manual [NCMS, page 51],
although using degrees (not radians) is specified.

*/

int read_atan(        /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274/NGC code being processed */
 int * counter,       /* pointer to a counter for position on line      */
 double * double_ptr, /* pointer to double to be read                   */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_atan";
  double argument2;

  if (line [*counter] ISNT '/')
    ERROR_MACRO(_interpreter_linetext, name, "Slash missing");

  *counter SET_TO (*counter + 1);

  if(line[*counter] ISNT '[')
    ERROR_MACRO(_interpreter_linetext, name, "Left bracket missing after slash with atan operator");

  if (read_real_expression (line, counter, &argument2, parameters)
      IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);

  *double_ptr SET_TO atan2(*double_ptr, argument2); /* value in radians */
  *double_ptr SET_TO ((*double_ptr * 180.0)/PI);    /* convert to degrees */
  return RS274NGC_OK;
}

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

/* read_integer_value

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If read_real_value returns RS274NGC_ERROR or if the returned value is not
   close to an integer, this returns RS274NGC_ERROR. Otherwise, it
   returns RS274NGC_OK.

Side effects:
   The number read from the line is put into what integer_ptr points at.

Called by:
   read_d
   read_l
   read_m
   read_parameter
   read_parameter_setting
   read_tool
   read_tool_length_offset

This reads an integer (positive, negative or zero) from a string,
starting from the position given by *counter. The value being
read may be written with a decimal point or it may be an expression
involving non-integers, as long as the result comes out within 0.0001
of an integer.

This proceeds by calling read_real_value and checking that it is
close to an integer, then returning the integer it is close to.

*/

int read_integer_value(   /* ARGUMENT VALUES                                */
 char * line,             /* string: line of RS274/NGC code being processed */
 int * counter,           /* pointer to a counter for position on the line  */
 int * integer_ptr,       /* pointer to the value being read                */
 double * parameters)     /* array of system parameters                     */
{
  static char name[] SET_TO "read_integer_value";
  double float_value;

  if (read_real_value(line, counter, &float_value, parameters)
      IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  *integer_ptr SET_TO (int)floor(float_value);
  if ((float_value - *integer_ptr) > 0.9999)
    {
      *integer_ptr SET_TO (int)ceil(float_value);
    }
  else if ((float_value - *integer_ptr) > 0.0001)
    ERROR_MACRO(_interpreter_linetext, name, "Non-integer value for integer");
  return RS274NGC_OK;
}

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

/* read_operation

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If the operation is unknown or if the line ends without closing the
   expression, this returns RS274NGC_ERROR. Otherwise, it returns RS274NGC_OK.

Side effects:
   An integer representing the operation is put into what operation points at.
   The counter is reset to point to the first character after the operation.

Called by: read_real_expression

*/

int read_operation(   /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274/NGC code being processed */
 int * counter,       /* pointer to a counter for position on the line  */
 int * operation)     /* pointer to operation to be read                */
{
  static char name[] SET_TO "read_operation";
  char c;

  c SET_TO line[*counter];
  *counter SET_TO (*counter + 1);
  switch(c)
    {
    case '+':
      *operation SET_TO PLUS;
      return RS274NGC_OK;
    case '-':
      *operation SET_TO MINUS;
      return RS274NGC_OK;
    case '/':
      *operation SET_TO DIVIDED_BY;
      return RS274NGC_OK;
    case '*':
      if(strncmp((line + *counter), "*", 1) IS 0)
        {
          *operation SET_TO POWER;
          *counter SET_TO (*counter + 1);
          return RS274NGC_OK;
        }
      else
        {
          *operation SET_TO TIMES;
          return RS274NGC_OK;
        }
    case ']':
      *operation SET_TO RIGHT_BRACKET;
      return RS274NGC_OK;
    case 'a':
      if(strncmp((line + *counter), "nd", 2) IS 0)
        {
          *operation SET_TO AND2;
          *counter SET_TO (*counter + 2);
          return RS274NGC_OK;
        }
      else
        ERROR_MACRO(_interpreter_linetext, name, "Unknown operation name starting with A");
    case 'm':
      if(strncmp((line + *counter), "od", 2) IS 0)
        {
          *operation SET_TO MODULO;
          *counter SET_TO (*counter + 2);
          return RS274NGC_OK;
        }
      else
        ERROR_MACRO(_interpreter_linetext, name, "Unknown operation name starting with M");
    case 'o':
      if(strncmp((line + *counter), "r", 1) IS 0)
        {
          *operation SET_TO NON_EXCLUSIVE_OR;
          *counter SET_TO (*counter + 1);
          return RS274NGC_OK;
        }
      else
        ERROR_MACRO(_interpreter_linetext, name, "Unknown operation name starting with O");
    case 'x':
      if(strncmp((line + *counter), "or", 2) IS 0)
        {
          *operation SET_TO EXCLUSIVE_OR;
          *counter SET_TO (*counter + 2);
          return RS274NGC_OK;
        }
      else
        ERROR_MACRO(_interpreter_linetext, name, "Unknown operation name starting with X");
    case 0:
      ERROR_MACRO(_interpreter_linetext, name, "Unclosed expression");
    default:
      ERROR_MACRO(_interpreter_linetext, name, "Unknown operation");
    }
}

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

/* read_operation_unary

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If the operation is not a known operation, this returns RS274NGC_ERROR.
   Otherwise, this returns RS274NGC_OK.

Side effects:
   An integer code for the name of the operation read from the
   line is put into what operation points at.
   The counter is reset to point to the first character after the
   characters which make up the operation name.

Called by:
   read_unary

This attempts to read the name of a unary operation out of the line,
starting at the index given by the counter.

*/

int read_operation_unary( /* ARGUMENT VALUES                                */
 char * line,             /* string: line of RS274/NGC code being processed */
 int * counter,           /* pointer to a counter for position on the line  */
 int * operation)         /* pointer to operation to be read                */
{
  static char name[] SET_TO "read_operation_unary";
  char c;

  c SET_TO line[*counter];
  *counter SET_TO (*counter + 1);
  switch (c)
    {
    case 'a':
      if(strncmp((line + *counter), "bs", 2) IS 0)
        {
          *operation SET_TO ABS;
          *counter SET_TO (*counter + 2);
          return RS274NGC_OK;
        }
      else if(strncmp((line + *counter), "cos", 3) IS 0)
        {
          *operation SET_TO ACOS;
          *counter SET_TO (*counter + 3);
          return RS274NGC_OK;
        }
      else if(strncmp((line + *counter), "sin", 3) IS 0)
        {
          *operation SET_TO ASIN;
          *counter SET_TO (*counter + 3);
          return RS274NGC_OK;
        }
      else if(strncmp((line + *counter), "tan", 3) IS 0)
        {
          *operation SET_TO ATAN;
          *counter SET_TO (*counter + 3);
          return RS274NGC_OK;
        }
      else
        ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with A");
    case 'c':
      if(strncmp((line + *counter), "os", 2) IS 0)
        {
          *operation SET_TO COS;
          *counter SET_TO (*counter + 2);
          return RS274NGC_OK;
        }
      else
        ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with C");
    case 'e':
      if(strncmp((line + *counter), "xp", 2) IS 0)
        {
          *operation SET_TO EXP;
          *counter SET_TO (*counter + 2);
          return RS274NGC_OK;
        }
      else
        ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with E");
    case 'f':
      if(strncmp((line + *counter), "ix", 2) IS 0)
        {
          *operation SET_TO FIX;
          *counter SET_TO (*counter + 2);
          return RS274NGC_OK;
        }
      else if(strncmp((line + *counter), "up", 2) IS 0)
        {
          *operation SET_TO FUP;
          *counter SET_TO (*counter + 2);
          return RS274NGC_OK;
        }
      else
        ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with F");
    case 'l':
      if(strncmp((line + *counter), "n", 1) IS 0)
        {
          *operation SET_TO LN;
          *counter SET_TO (*counter + 1);
          return RS274NGC_OK;
        }
      else
        ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with L");
    case 'r':
      if(strncmp((line + *counter), "ound", 4) IS 0)
        {
          *operation SET_TO ROUND;
          *counter SET_TO (*counter + 4);
          return RS274NGC_OK;
        }
      else
        ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with R");
    case 's':
      if(strncmp((line + *counter), "in", 2) IS 0)
        {
          *operation SET_TO SIN;
          *counter SET_TO (*counter + 2);
          return RS274NGC_OK;
        }
      else if(strncmp((line + *counter), "qrt", 3) IS 0)
        {
          *operation SET_TO SQRT;
          *counter SET_TO (*counter + 3);
          return RS274NGC_OK;
        }
      else
        ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with S");
    case 't':
      if(strncmp((line + *counter), "an", 2) IS 0)
        {
          *operation SET_TO TAN;
          *counter SET_TO (*counter + 2);
          return RS274NGC_OK;
        }
      else
        ERROR_MACRO(_interpreter_linetext, name, "Unknown word starting with T");
    default:
      ERROR_MACRO(_interpreter_linetext, name, "Unknown word where unary operation could be");
    }
}

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

/* utility_find_turn

Returned Value: double (angle between two radii of a circle)

Side effects: none

Called by:
   utility_find_arc_length
   convert_arc_comp1
   convert_arc_comp2
   convert_arc_xy
   convert_arc_yz
   convert_arc_zx

*/

double utility_find_turn( /* ARGUMENT VALUES            */
 double x1,       /* X-coordinate of start point        */
 double y1,       /* Y-coordinate of start point        */
 double center_x, /* X-coordinate of arc center         */
 double center_y, /* Y-coordinate of arc center         */
 int turn,        /* no. of full or partial circles CCW */
 double x2,       /* X-coordinate of end point          */
 double y2)       /* Y-coordinate of end point          */
{
  double alpha;
  double beta;
  double theta;  /* amount of turn of arc CCW - negative if CW */

  if (turn IS 0)
    return 0.0;
  alpha SET_TO atan2((y1 - center_y), (x1 - center_x));
  beta SET_TO atan2((y2 - center_y), (x2 - center_x));
  if (turn > 0)
    {
      if (beta <= alpha)
        beta SET_TO (beta + TWO_PI);
      theta SET_TO ((beta - alpha) + ((turn - 1) * TWO_PI));
    }
  else /* turn < 0 */
    {
      if (alpha <= beta)
        alpha SET_TO (alpha + TWO_PI);
      theta SET_TO ((beta - alpha) + ((turn + 1) * TWO_PI));
    }
  return (theta);
}

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

/* arc_data_comp_ijk

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. The two calculable values of the radius differ by more than
      tolerance.
   2. BUG - move is not G_2 or G_3.

Side effects:
   This finds and sets the values of center_x, center_y, and turn.

Called by: convert_arc_comp1

This finds the center coordinates and number of full or partial turns
counterclockwise of a helical or circular arc (call it arc1) in
ijk-format in the XY plane.  Arc2 is constructed so that it is tangent
to a circle whose radius is tool_radius and whose center is at the
point (current_x, current_y) and passes through the point (end_x,
end_y). Arc1 has the same center as arc2. The radius of arc1 is one
tool radius larger or smaller than the radius of arc2.

*/

int arc_data_comp_ijk(  /* ARGUMENT VALUES                               */
 int move,           /* either G_2 (cw arc) or G_3 (ccw arc)             */
 int side,           /* either RIGHT or LEFT                             */
 double tool_radius, /* radius of the tool                               */
 double current_x,   /* first coordinate of current point                */
 double current_y,   /* second coordinate of current point               */
 double end_x,       /* first coordinate of arc end point                */
 double end_y,       /* second coordinate of arc end point               */
 double i_number,    /* first coordinate offset of center from current   */
 double j_number,    /* second coordinate offset of center from current  */
 double * center_x,  /* pointer to first coordinate of center of arc     */
 double * center_y,  /* pointer to second coordinate of center of arc    */
 int * turn,         /* pointer to number of full or partial circles CCW */
 double tolerance)   /* tolerance of differing radii                     */
{
  static char name[] SET_TO "arc_data_comp_ijk";
  double arc_radius;
  double radius2;
  *center_x SET_TO (current_x + i_number);
  *center_y SET_TO (current_y + j_number);
  arc_radius SET_TO hypot((*center_x - current_x), (*center_y - current_y));
  radius2 SET_TO hypot((*center_x - end_x), (*center_y - end_y));
  radius2 SET_TO
    (((side IS LEFT ) AND (move IS 30)) OR
     ((side IS RIGHT) AND (move IS 20))) ?
       (radius2 - tool_radius): (radius2 + tool_radius);
  if (fabs(arc_radius - radius2) > tolerance)
    ERROR_MACRO(_interpreter_linetext, name,
                "Radius to end of arc differs from radius to start of arc");
    /* This catches an arc too small for the tool, also */
  if (move IS G_2)
    *turn SET_TO -1;
  else if (move IS G_3)
    *turn SET_TO 1;
  else
    BUG_MACRO(name, "Code is not G2 or G3 in arc_data_comp");
  return RS274NGC_OK;
}

/****************************************************************************/
/* arc_data_comp_r

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. The arc radius is too small to reach the end point.
   2. The current point is the same as the end point of the arc (so that
      it is not possible to locate the center of the circle).
   3. The arc radius is not greater than the tool_radius.

Side effects:
   This finds and sets the values of center_x, center_y, and turn.

Called by: convert_arc_comp1

This finds the center coordinates and number of full or partial turns
counterclockwise of a helical or circular arc (call it arc1) in
r-format in the XY plane.  Arc2 is constructed so that it is tangent
to a circle whose radius is tool_radius and whose center is at the
point (current_x, current_y) and passes through the point (end_x,
end_y). Arc1 has the same center as arc2. The radius of arc1 is one
tool radius larger or smaller than the radius of arc2.

If the value of the big_radius argument is negative, that means [NCMS,
page 21] that an arc larger than a semicircle is to be made.
Otherwise, an arc of a semicircle or less is made.

The algorithm implemented here is to construct a line L from the
current point to the end point, and a perpendicular to it from the
center of the arc which intersects L at point P. Since the distance
from the end point to the center and the distance from the current
point to the center are known, two equations for the length of the
perpendicular can be written. The right sides of the equations can be
set equal to one another and the resulting equation solved for the
length of the line from the current point to P. Then the location of
P, the length of the perpendicular, the angle of the perpendicular,
and the location of the center, can be found in turn.

*/

int arc_data_comp_r( /* ARGUMENT VALUES                                  */
 int move,           /* either G_2 (cw arc) or G_3 (ccw arc)             */
 int side,           /* either RIGHT or LEFT                             */
 double tool_radius, /* radius of the tool                               */
 double current_x,   /* first coordinate of current point                */
 double current_y,   /* second coordinate of current point               */
 double end_x,       /* first coordinate of arc end point                */
 double end_y,       /* second coordinate of arc end point               */
 double big_radius,  /* radius of arc                                    */
 double * center_x,  /* pointer to first coordinate of center of arc     */
 double * center_y,  /* pointer to second coordinate of center of arc    */
 int * turn)         /* pointer to number of full or partial circles CCW */
{
  static char name[] SET_TO "arc_data_comp_r";
  double abs_radius; /* absolute value of big_radius */
  double radius2;    /* distance from center to current point */
  double distance;   /* length of line L from current to end */
  double mid_length; /* length from current point to point P */
  double offset;     /* length of line from P to center */
  double alpha;      /* direction of line from current to end */
  double theta;      /* direction of line from P to center */
  double mid_x;      /* x-value of point P */
  double mid_y;      /* y-value of point P */

  if ((end_x IS current_x) AND (end_y IS current_y))
    ERROR_MACRO(_interpreter_linetext, name, "Current point same as end point of arc");
  abs_radius SET_TO fabs(big_radius);
  if ((abs_radius < tool_radius) AND (((side IS LEFT ) AND (move IS G_3)) OR
                                      ((side IS RIGHT) AND (move IS G_2))))
    ERROR_MACRO(_interpreter_linetext, name,
     "Tool radius not less than arc radius with cutter radius comp");

  distance SET_TO hypot((end_x - current_x), (end_y - current_y));
  alpha SET_TO atan2 ((end_y - current_y), (end_x - current_x));
  theta SET_TO (((move IS G_3) AND (big_radius > 0)) OR
                ((move IS G_2) AND (big_radius < 0))) ?
                  (alpha + PI2) : (alpha - PI2);
  radius2 SET_TO (((side IS LEFT ) AND (move IS G_3)) OR
                  ((side IS RIGHT) AND (move IS G_2))) ?
                    (abs_radius - tool_radius) : (abs_radius + tool_radius);
  if (distance > (radius2 + abs_radius))
    ERROR_MACRO(_interpreter_linetext, name, "Radius too small to reach end point");
  mid_length SET_TO (((radius2 * radius2) + (distance * distance) -
                      (abs_radius * abs_radius)) / (2.0 * distance));
  mid_x SET_TO (current_x + (mid_length * cos(alpha)));
  mid_y SET_TO (current_y + (mid_length * sin(alpha)));
  offset SET_TO sqrt((radius2 * radius2) - (mid_length * mid_length));
  *center_x SET_TO mid_x + (offset * cos(theta));
  *center_y SET_TO mid_y + (offset * sin(theta));
  *turn SET_TO (move IS G_2) ? -1 : 1;

  return RS274NGC_OK;
}

/****************************************************************************/
/* arc_data_ijk

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. The two calculable values of the radius differ by more than
      tolerance.
   2. BUG - The move code is not G_2 or G_3.

Side effects:
   This finds and sets the values of center_x, center_y, and turn.

Called by:
   convert_arc_xy
   convert_arc_xz
   convert_arc_yz
   convert_arc_comp2

This finds the center coordinates and number of full or partial turns
counterclockwise of a helical or circular arc in ijk-format. This
function is used by the arc functions for all three planes, so "x" and
"y" really mean "first_coordinate" and "second_coordinate" wherever
they are used here as suffixes of variable names. The i and j prefixes
are handled similarly.

*/

int arc_data_ijk(   /* ARGUMENT VALUES                                 */
 int move,          /* either G_2 (cw arc) or G_3 (ccw arc)            */
 double current_x,  /* first coordinate of current point               */
 double current_y,  /* second coordinate of current point              */
 double end_x,      /* first coordinate of arc end point               */
 double end_y,      /* second coordinate of arc end point              */
 double i_number,   /* first coordinate offset of center from current  */
 double j_number,   /* second coordinate offset of center from current */
 double * center_x, /* pointer to first coordinate of center of arc    */
 double * center_y, /* pointer to second coordinate of center of arc   */
 int * turn,        /* pointer to no. of full or partial circles CCW   */
 double tolerance)  /* tolerance of differing radii                    */
{
  static char name[] SET_TO "arc_data_ijk";
  double radius;    /* radius to current point */
  double radius2;   /* radius to end point     */
  *center_x SET_TO (current_x + i_number);
  *center_y SET_TO (current_y + j_number);
  radius SET_TO hypot((*center_x - current_x), (*center_y - current_y));
  radius2 SET_TO hypot((*center_x - end_x), (*center_y - end_y));
  if (fabs(radius - radius2) > tolerance)
    ERROR_MACRO(_interpreter_linetext, name,
                "Radius to end of arc differs from radius to start of arc");
  if (move IS G_2)
    *turn SET_TO -1;
  else if (move IS G_3)
    *turn SET_TO 1;
  else
    BUG_MACRO(name, "Code is not G2 or G3 in arc_data_ijk");
  return RS274NGC_OK;
}

/****************************************************************************/
/* arc_data_r

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. The radius is too small to reach the end point.
   2. The current point is the same as the end point of the arc
      (so that it is not possible to locate the center of the circle).

Side effects:
   This finds and sets the values of center_x, center_y, and turn.

Called by:
   convert_arc_xy
   convert_arc_xz
   convert_arc_yz
   convert_arc_comp2

This finds the center coordinates and number of full or partial turns
counterclockwise of a helical or circular arc in the r format. This
function is used by the arc functions for all three planes, so "x" and
"y" really mean "first_coordinate" and "second_coordinate" wherever
they are used here as suffixes of variable names.

If the value of the radius argument is negative, that means [NCMS,
page 21] that an arc larger than a semicircle is to be made.
Otherwise, an arc of a semicircle or less is made.

The algorithm used here is based on finding the midpoint M of the line
L between the current point and the end point of the arc. The center
of the arc lies on a line through M perpendicular to L.

*/

int arc_data_r(     /* ARGUMENT VALUES                               */
 int move,          /* either G_2 (cw arc) or G_3 (ccw arc)          */
 double current_x,  /* first coordinate of current point             */
 double current_y,  /* second coordinate of current point            */
 double end_x,      /* first coordinate of arc end point             */
 double end_y,      /* second coordinate of arc end point            */
 double radius,     /* radius of arc                                 */
 double * center_x, /* pointer to first coordinate of center of arc  */
 double * center_y, /* pointer to second coordinate of center of arc */
 int * turn)        /* pointer to no. of full or partial circles CCW */
{
  static char name[] SET_TO "arc_data_r";
  double abs_radius; /* absolute value of given radius */
  double half_length;
  double turn2;  /* absolute value of half of turn */
  double offset; /* distance from M to center */
  double theta;  /* angle of line from M to center */
  double mid_x;  /* first coordinate of M */
  double mid_y;  /* second coordinate of M */

  if ((end_x IS current_x) AND (end_y IS current_y))
    ERROR_MACRO(_interpreter_linetext, name, "Current point same as end point of arc");
  abs_radius SET_TO fabs(radius);
  mid_x SET_TO (end_x + current_x)/2.0;
  mid_y SET_TO (end_y + current_y)/2.0;
  half_length SET_TO hypot((mid_x - end_x), (mid_y - end_y));
  if ((half_length/abs_radius) > (1+TINY))
    ERROR_MACRO(_interpreter_linetext, name, "Arc radius too small to reach end point");
  else if ((half_length/abs_radius) > (1-TINY))
    half_length SET_TO abs_radius; /* allow a small error for semicircle */
                                   /* check needed before calling asin   */
  if (((move IS G_2) AND (radius > 0)) OR
      ((move IS G_3) AND (radius < 0)))
    theta SET_TO atan2((end_y - current_y), (end_x - current_x)) - PI2;
  else
    theta SET_TO atan2((end_y - current_y), (end_x - current_x)) + PI2;

  turn2 SET_TO asin (half_length/abs_radius);
  offset SET_TO abs_radius * cos(turn2);
  *center_x SET_TO mid_x + (offset * cos(theta));
  *center_y SET_TO mid_y + (offset * sin(theta));
  *turn SET_TO (move IS G_2) ? -1 : 1;

  return RS274NGC_OK;
}

/****************************************************************************/
/* read_parameter

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, this returns RS274NGC_OK.
   1. BUG - The first character read is not # .
   2. The characters following the # do not form an integer.
   3. The parameter number is out of bounds

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_real_value

This attempts to read the value of a parameter out of the line,
starting at the index given by the counter.

According to the 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]

*/

int read_parameter(   /* ARGUMENT VALUES                                */
 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                     */
{
  static char name[] SET_TO "read_parameter";
  int index;

  if (line[*counter] ISNT '#')
    BUG_MACRO(name, "Read_parameter should not have been called");
  *counter SET_TO (*counter + 1);
  if (read_integer_value(line, counter, &index, parameters) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else if ((index < 1) OR (index >= RS274NGC_MAX_PARAMETERS))
    ERROR_MACRO(_interpreter_linetext, name, "Parameter number out of range");
  else
    {
      *double_ptr SET_TO parameters[index];
      return RS274NGC_OK;
    }
}

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

/* read_real_expression

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character is not [ .
   2. The call back to read_real_value does not return RS274NGC_OK.
   3. read_operation does not return RS274NGC_OK.
   4. execute_binary1 or execute_binary2 does not return RS274NGC_OK.

Side effects:
   The number read from the line is put into what value_ptr points at.
   The counter is reset to point to the first character after the real
   expression.

Called by: read_real_value.

Example 1: [2 - 3 * 4 / 5] means [2 - [[3 * 4] / 5]] and equals -0.4.

Segmenting Expressions -

The manual [NCMS, section 3.5.1.1, page 50] provides for
using square brackets to segment expressions.

Binary Operations -

The manual [NCMS section 3.5.1.1] discusses expression evaluation.
The manual provides for eight binary operations: the four basic
mathematical operations (addition, subtraction, multiplication,
division), three logical operations (non-exclusive OR, exclusive OR,
and AND2) and the modulus operation. The manual does not explicitly call
these "binary" operations, but implicitly recognizes that they are
binary. We have added the "power" operation of raising the number
on the left of the operation to the power on the right; this is
needed for many basic machining calculations.

There are two groups of binary operations given in the manual. If
operations are strung together as shown in Example 1, operations in
the first group are to be performed before operations in the second
group. If an expression contains more than one operation from the same
group (such as * and / in Example 1), the operation on the left is
performed first. The first group is: multiplication (*), division (/),
modulus (MOD), and power (**). We added power. The second group is:
addition(+), subtraction (-), logical non-exclusive OR (OR), logical
exclusive OR (XOR), and logical AND (AND2).

The logical operations and modulus are apparently to be performed on
any real numbers, not just on integers or on some other data type.

Unary Operations -

The manual [NCMS, section 3.5.1.2] provides for fifteen unary
mathematical operations. Two of these, BIN and BCD, are apparently for
converting between decimal and hexadecimal number representation,
although the text is not clear. These have not been implemented, since
we are not using any hexadecimal numbers. The other thirteen unary
operations have been implemented: absolute_value, arc_cosine, arc_sine,
arc_tangent, cosine, e_raised_to, fix_down, fix_up, natural_log_of,
round, sine, square_root, tangent .

The manual [NCMS, section 3.5.1.2, page 51] requires the argument to
all unary operations (except atan) to be in square brackets.  Thus,
for example "sin[90]" is allowed in the interpreter, but "sin 90" is
not. The atan operation must be in the format "atan[..]/[..]".

Production Rule Definitions in Terms of Tokens -

The following is a production rule definition of what this RS274NGC
interpreter recognizes as valid combinations of symbols which form a
recognized real_value (the top of this production hierarchy).

The notion of "integer_value" is used in the interpreter. Below it is
defined as a synonym for real_value, but in fact a constraint is added
which cannot be readily written in a production language.  An
integer_value is a real_value which is very close to an integer.
Integer_values are needed for array and table indices and (when
divided by 10) for the values of M codes and G codes. All numbers
(including integers) are read as real numbers and stored as doubles.
If an integer_value is required in some situation, a test for being
close to an integer is applied to the number after it is read.


arc_tangent_combo = arc_tangent expression divided_by expression .

binary_operation1 = divided_by | modulo | power | times .

binary_operation2 = and | exclusive_or | minus |  non_exclusive_or | plus .

combo1 = real_value { binary_operation1 real_value } .

digit = zero | one | two | three | four | five | six | seven |eight | nine .

expression =
   left_bracket
   (unary_combo | (combo1 { binary_operation2 combo1 }))
   right_bracket .

integer_value = real_value .

ordinary_unary_combo =  ordinary_unary_operation expression .

ordinary_unary_operation =
   absolute_value | arc_cosine | arc_sine | cosine | e_raised_to |
   fix_down | fix_up | natural_log_of | round | sine | square_root | tangent .

parameter_index = integer_value .

parameter_value = parameter_sign  parameter_index .

real_number =
   [ plus | minus ]
   (( digit { digit } decimal_point {digit}) | ( decimal_point digit {digit})).

real_value =
   real_number | expression | parameter_value | unary_combo.

unary_combo = ordinary_unary_combo | arc_tangent_combo .


Production Tokens in Terms of Characters -

absolute_value   = 'abs'
and              = 'and'
arc_cosine       = 'acos'
arc_sine         = 'asin'
arc_tangent      = 'atan'
cosine           = 'cos'
decimal_point    = '.'
divided_by       = '/'
eight            = '8'
exclusive_or     = 'xor'
e_raised_to      = 'exp'
five             = '5'
fix_down         = 'fix'
fix_up           = 'fup'
four             = '4'
left_bracket     = '['
minus            = '-'
modulo           = 'mod'
natural_log_of   = 'ln'
nine             = '9'
non_exclusive_or = 'or'
one              = '1'
parameter_sign   = '#'
plus             = '+'
power            = '**'
right_bracket    = ']'
round            = 'round'
seven            = '7'
sine             = 'sin'
six              = '6'
square_root      = 'sqrt'
tangent          = 'tan'
three            = '3'
times            = '*'
two              = '2'
zero             = '0'

How the Function Works -

When this function is called, the counter should be set at a left
bracket. The function reads up to and including the right bracket
which closes the expression.

In this explanation we will use "bop1" to mean "binary_operation1"
as defined above, and "bop2" to mean "binary_operation2". "bop"
will mean an operation that is either a bop1 or a bop2.

The basic form of an expression is: [v1 bop v2 bop ... vn], where
the vi are real_values. Because bop1's are to be evaluated before
bop2's, it is useful to rewrite the general form collecting any
subsequences of bop1's. For example, suppose the expression is:
[9+8*7/6+5-4*3*2+1]. It may be rewritten as: [9+(8*7/6)+5-(4*3*2)+1].

The manual provides that operations of the same type should be processed
left to right. The algorithm implemented here works through the
expression left to right performing bop2's one at time and collecting
the results in a buffer named hold2. When a subsequence of the
expression containing bop1's is encountered, the bop1's in the
subsequence are performed one at a time and the results are collected
in a buffer named hold1, until the subsequence ends, at which point
the hold1 buffer is combined with the hold2 buffer using the bop1
that immediately preceeded the subsequence.

An expression may be processed left to right by using a loop that
reads one more real_value and one more bop each time around the loop.
It is necessary for the reading to be ahead of the execution of bop's
by one step in order to tell when subsequences of bop1's start and end.
This algorithm implements such a loop. It keeps track of the following
information.

1. the value accumulated so far in hold2 (initialized to 0).
2. the bop2 waiting to be executed (called waiting_operation
   and initialized to PLUS).
3. the value accumulated so far in hold1.
4. the bop which was read the last time around the loop
   (called last_operation and initialized to PLUS).
5. the value read this time around the loop (called value).
6. the bop read this time around the loop (called next_operation).

The function terminates when the next_operation is found to be a right
bracket and not a bop. When the function is ready to return, hold2
has been set to the value of the expression, and RS274NGC_OK is returned.

Without the initializations, special steps would have to be taken
the first time around the loop, and special steps would have to
be taken if the expression were simply a number in brackets (e.g. [5]).

The algorithm (ignoring all the error detection) is:

A. Initialize.
B. Loop
  B1. Read the next operation into next_operation and the next
      real_value into value.
  B2. Check for one of three possibilities regarding next_operation:
      B2a. If next_operation is a right bracket:
          B2a(i). If last_operation was a bop1, a subsequence
                  of bop1's has just ended, so set hold1
                  to (hold1 last_operation value) and then
                  set hold2 to (hold2 waiting_operation hold1).
          B2a(ii). Otherwise, last_operation must have been a bop2,
                  so set hold2 to (hold2 waiting_operation value).
          B2a(iii). Return RS274NGC_OK.
      B2b. Otherwise, if next_operation is a bop1:
          B2b(i). If last_operation was a bop2, a subsequence of
                  bop1's is just starting, so reinitialize hold1
                  by setting it to value.
          B2b(ii). Otherwise, last operation must have been a bop1,
                  implying a subsequence of bop1's has already been
                  started, so set hold1 to (hold1 last_operation value).
      B2c. Otherwise, next_operation must have been a bop2, so:
          B2c(i). If last_operation was a bop1, a subsequence of
                  bop1's has just ended, so set hold1 to
                  (hold1 last_operation value), set hold2 to
                  (hold2 waiting_operation hold1), and set
                  waiting_operation to next_operation.
          B2c(ii). Otherwise, last_operation was also a bop2, so
                  set hold2 to (hold2 last_operation value), and
                  set waiting_operation to next_operation.
  B3. Set last_operation to next_operation, and go back to the top of
      the loop.

The expression [2 - 3 * 4 / 5] given in Example 1 is processed as
follows by this procedure:

- initialize hold2 to 0.0, last_operation to PLUS, and
  waiting_operation to PLUS.

LOOP1
- read 2 into value and MINUS into next_operation.
- since next_operation is a bop2, and last_operation is a bop2,
  set hold2 to the result of applying the waiting_operation
  to hold2 and value (i.e. set hold2 to 0+2 = 2)
- reset last_operation to MINUS and waiting_operation to MINUS.

LOOP2
- read 3 into value and TIMES into next_operation.
- since next_operation is a bop1 and last_operation is a bop2,
  set hold1 to 3.
- set last_operation to TIMES (but do not change waiting_operation).

LOOP3
- read 4 into value and DIVIDED_BY into next_operation.
- since next_operation is a bop1 and last operation is a bop1,
  set hold1 to the result of applying last operation to
  hold1 and value (i.e. set hold1 to 3*4 = 12)
- reset last operation to DIVIDED_BY

LOOP4
- read 5 into value and RIGHT_BRACKET into next_operation
- since next_operation is RIGHT_BRACKET and last operation was a bop1,
  o set hold1 to the result of applying the last_operation
    to hold1 and value (i.e. set hold1 to 12/5 = 2.4)
  o set hold2 to the result of applying the waiting_operation
    to hold2 and hold1 (i.e. set hold2 to 2-2.4 = -0.4)
  o return RS274NGC_OK

The following table shows the settings of the variables at the end
of initialization and the end of each loop.

       hold2  hold1  value  waiting_     last_     next_      unread part
                            operation  operation  operation  of expression
      _____________________________________________________________________

INIT    0       ?      ?     PLUS       PLUS         ?       2 - 3 * 4 / 5]

LOOP1   2.0     ?      2.0   MINUS      MINUS      MINUS         3 * 4 / 5]

LOOP2   2.0     3.0    3.0   MINUS      TIMES      TIMES             4 / 5]

LOOP3   2.0    12.0    4.0   MINUS    DIVIDED_BY  DIVIDED_BY             5]

LOOP4  -0.4     2.4    5.0   MINUS    DIVIDED_BY  RIGHT_BRACKET


A reasonable alternative to the algorithm here would be to have
read_real_expression deal with only bop2's and have it call a separate
function to handle any subsequences of bop1's that might be found.
(or the two functions could be written to call each other
recursively). In either case, the read-ahead would still be necessary,
so the functions would have either to pass the read-ahead information
back and forth (OK) or to read things twice (bad).

*/

int read_real_expression( /* ARGUMENT VALUES                                */
 char * line,             /* string: line of RS274/NGC code being processed */
 int * counter,           /* pointer to a counter for position on the line  */
 double * hold2,          /* pointer to double to be read                   */
 double * parameters)     /* array of system parameters                     */
{
  static char name[] SET_TO "read_real_expression";
  double value;
  double hold1;
  int waiting_operation;  /* always a bop2 */
  int last_operation;
  int next_operation;

  if (line[*counter] ISNT '[')
    BUG_MACRO(name, "Read_real_expression should not have been called");
  *counter SET_TO (*counter + 1);
  waiting_operation SET_TO PLUS;
  *hold2 SET_TO 0.0;
  last_operation SET_TO PLUS;

  for (;;)
    {
      if (read_real_value(line, counter, &value, parameters) ISNT RS274NGC_OK)
        ERROR_MACRO_PASS(name);
      if (read_operation(line, counter, &next_operation) ISNT RS274NGC_OK)
        ERROR_MACRO_PASS(name);
      if (next_operation IS RIGHT_BRACKET)
        {
          if (last_operation < AND2)
            {
              if (execute_binary1(&hold1,last_operation, &value)
                  ISNT RS274NGC_OK)
                ERROR_MACRO_PASS(name);
              if (execute_binary2(hold2, waiting_operation, &hold1)
                  ISNT RS274NGC_OK)
                ERROR_MACRO_PASS(name);
            }
          else if (execute_binary2(hold2, waiting_operation, &value)
                   ISNT RS274NGC_OK)
            ERROR_MACRO_PASS(name);
          else {}
          return RS274NGC_OK;
        }
      else if (next_operation < AND2)  /* next operation is a bop1 */
        {
          if (last_operation >= AND2)
            {
              hold1 SET_TO value;
            }
          else if (execute_binary1(&hold1, last_operation, &value)
                   ISNT RS274NGC_OK)
            ERROR_MACRO_PASS(name);
        }
      else                            /* next operation is a bop2 */
        {
          if (last_operation < AND2)
            {
              if (execute_binary1(&hold1, last_operation, &value)
                  ISNT RS274NGC_OK)
                ERROR_MACRO_PASS(name);
              if (execute_binary2(hold2, waiting_operation, &hold1)
                  ISNT RS274NGC_OK)
                ERROR_MACRO_PASS(name);
            }
          else
            {
              if (execute_binary2(hold2, waiting_operation, &value)
                  ISNT RS274NGC_OK)
                ERROR_MACRO_PASS(name);
            }
          waiting_operation SET_TO next_operation;
        }
      last_operation SET_TO next_operation;
    }
}

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

/* read_real_number

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. The first character is not "+", "-", "." or a digit.
   2. No digits are found after the first character and before the
      end of the line or the next character that cannot be part of a real.
   3. BUG - sscanf fails.

Side effects:
   The number read from the line is put into what double_ptr points at.
   The counter is reset to point to the first character after the real.

Called by:
   read_real_value

This attempts to read a number out of the line, starting at the index
given by the counter. It stops when the first character that cannot
be part of the number is found.

The first character may be a digit, "+", "-", or "."
Every following character must be a digit or "." up to anything
that is not a digit or "." (a second "." terminates reading).

This function is not called if the first character is NULL, so it is
not necessary to check that.

The temporary insertion of a NULL character on the line is to avoid
making a format string like "%3lf" which the LynxOS compiler cannot
handle.

*/

int read_real_number( /* ARGUMENT VALUES                                */
 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                   */
{
  static char name[] SET_TO "read_real_number";
  int n;
  char c;
  int flag_point;  /* set to ON if decimal point found */
  int flag_digit; /* set to ON if digit found */

  n SET_TO *counter;
  flag_point SET_TO OFF;
  flag_digit SET_TO OFF;

/* check first character */
  c SET_TO line[n];
  if (c IS '+')
    {
      *counter SET_TO (*counter + 1); /* skip plus sign */
      n++;
    }
  else if (c IS '-')
    {
      n++;
    }
  else if ((c ISNT '.') AND ((c < 48) OR (c > 57)))
    ERROR_MACRO(_interpreter_linetext, name, "Bad number format");

/* check out rest of characters (must be digit or decimal point) */
  for (; (c SET_TO line[n]) ISNT (char) NULL; n++)
    {
      if (( 47 < c) AND ( c < 58))
        {
          flag_digit SET_TO ON;
        }
      else if (c IS '.')
        {
          if (flag_point IS OFF)
            {
              flag_point SET_TO ON;
            }
          else
            break;
        }
      else
        break;
    }

  if (flag_digit IS OFF)
    ERROR_MACRO(_interpreter_linetext, name, "No digits found where real number should be");

  line[n] SET_TO (char) NULL; /* temporary string termination for sscanf */
  if (sscanf(line + *counter, "%lf", double_ptr) IS 0)
    {
      line[n] SET_TO c;
      BUG_MACRO(name, "Sscanf failure in read_real_number");
    }
  else
    {
      line[n] SET_TO c;
      *counter SET_TO n;
      return RS274NGC_OK;
    }
}

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

/* read_unary

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. read_operation_unary returns RS274NGC_ERROR,
   2. the name of the unary operation is not followed by a left bracket,
   3. read_real_expression returns RS274NGC_ERROR,
   4. read_atan or execute_unary returns RS274NGC_ERROR,

Side effects:
   The value read from the line 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_real_value

This attempts to read the value of a unary operation out of the line,
starting at the index given by the counter. The atan operation is
handled specially because it is followed by two arguments.

*/

int read_unary(       /* ARGUMENT VALUES                                */
 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                     */
{
  static char name[] SET_TO "read_unary";
  int operation;

  if (read_operation_unary (line, counter, &operation) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  if (line[*counter] ISNT '[')
    ERROR_MACRO(_interpreter_linetext, name, "Left bracket missing after unary operation name");
  if (read_real_expression (line, counter, double_ptr, parameters)
      IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);

  if (operation IS ATAN)
    return read_atan(line, counter, double_ptr, parameters);
  else
    return execute_unary (double_ptr, operation);
}

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

/* utility_find_arc_length

Returned Value: double (length of path between start and end points)

Side effects: none

Called by:
   convert_arc_xy
   convert_arc_yz
   convert_arc_zx

This calculates the length of the path that will be made relative to
the XYZ axes for a motion in which the X,Y,Z, motion is a circular or
helical arc with its axis parallel to the Z-axis. If tool length
compensation is on, this is the path of the tool tip; if off, the
length of the path of the spindle tip.

If the arc is helical, it is coincident with the hypotenuse of a right
triangle wrapped around a cylinder. If the triangle is unwrapped, its
base is [the radius of the cylinder times the number of radians in the
helix] and its height is [z2 - z1], and the path length can be found
by the Pythagorean theorem.

This is written as though it is only for arcs whose axis is parallel to
the Z-axis, but it will serve also for arcs whose axis is parallel
to the X-axis or Y-axis, with suitable permutation of the arguments.

*/

double utility_find_arc_length( /* ARGUMENT VALUES      */
 double x1,       /* X-coordinate of start point        */
 double y1,       /* Y-coordinate of start point        */
 double z1,       /* Z-coordinate of start point        */
 double center_x, /* X-coordinate of arc center         */
 double center_y, /* Y-coordinate of arc center         */
 int turn,        /* no. of full or partial circles CCW */
 double x2,       /* X-coordinate of end point          */
 double y2,       /* Y-coordinate of end point          */
 double z2)       /* Z-coordinate of end point          */
{
  double radius;
  double theta;  /* amount of turn of arc */

  if (turn IS 0)
    return 0.0;
  radius SET_TO hypot((center_x - x1), (center_y - y1));
  theta SET_TO utility_find_turn(x1, y1, center_x, center_y, turn, x2, y2);
  if (z2 IS z1)
    return (radius * fabs(theta));
  else
    return hypot((radius * theta), (z2 - z1));
}

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

/* utility_find_straight_length

Returned Value: double (length of path between start and end points)

Side effects: none

Called by:
   convert_straight

This calculates a number to use in feed rate calculations when inverse
time feed mode is used, for a motion in which X,Y, and Z, each change
linearly or not at all from their initial value to their end value.

This is used when the feed_reference mode is CANON_XYZ, which is
always in rs274kt.

This is the length of the path relative to the XYZ axes from the first
point to the second. The length is the simple Euclidean distance.

*/

double utility_find_straight_length( /* ARGUMENT VALUES  */
 double x2,    /* X-coordinate of end point              */
 double y2,    /* Y-coordinate of end point              */
 double z2,    /* Z-coordinate of end point              */
 double x1,    /* X-coordinate of start point            */
 double y1,    /* Y-coordinate of start point            */
 double z1)    /* Z-coordinate of start point            */
{
    return sqrt(pow((x2 - x1),2) + pow((y2 - y1),2) + pow((z2 - z1),2));
}

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

/* convert_arc_comp1

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. arc_data_comp_ijk or arc_data_comp_r returns RS274NGC_ERROR.
   2. The tool radius is not positive.

Side effects:
   This executes an arc command at
   feed rate. It also updates the setting of the position of
   the tool point to the end point of the move.

Called by: convert_arc.

This function converts a helical or circular arc, generating only one
arc. The axis must be parallel to the z-axis. This is called when
cutter radius compensation is on and this is the first cut after the
turning on.

The arc which is generated is derived from second arc which passes
through the programmed end point and is tangent to the cutter at its
current location. The generated arc moves the tool so that it stays
tangent to the second arc throughout the move.

*/

int convert_arc_comp1(   /* ARGUMENT VALUES                              */
 int move,               /* either G_2 (cw arc) or G_3 (ccw arc)         */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings, /* pointer to machine settings                  */
 double end_x,           /* x-value at end of arc                        */
 double end_y,           /* y-value at end of arc                        */
 double end_z)           /* z-value at end of arc                        */
{
  static char name[] SET_TO "convert_arc_comp1";
  double center_x;
  double center_y;
  int turn;     /* 1 for counterclockwise, -1 for clockwise */
  double gamma; /* direction of perpendicular to arc at end */
  double tolerance;
  double tool_radius;
  int side;
  int status;

  side SET_TO settings->cutter_radius_compensation;
  tool_radius SET_TO
    (settings->tool_table[settings->tool_table_index].diameter)/2.0;
  if (tool_radius <= 0.0)
    ERROR_MACRO(_interpreter_linetext, name, "Bad tool radius value with cutter radius comp");
  tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ?
    TOLERANCE_INCH : TOLERANCE_MM;

  if (block->r_flag)
    {
      status SET_TO
        arc_data_comp_r(move, side, tool_radius, settings->current_x,
                        settings->current_y, end_x, end_y, block->r_number,
                        &center_x, &center_y, &turn);
    }
  else
    {
      status SET_TO
        arc_data_comp_ijk(move, side, tool_radius, settings->current_x,
                          settings->current_y, end_x, end_y,
                          block->i_number, block->j_number,
                          &center_x, &center_y, &turn, tolerance);
    }

  if (status IS RS274NGC_ERROR)
   ERROR_MACRO_PASS(name);

  gamma SET_TO
    (((side IS LEFT) AND (move IS G_3)) OR
     ((side IS RIGHT) AND (move IS G_2))) ?
       atan2 ((center_y - end_y), (center_x - end_x)) :
       atan2 ((end_y - center_y), (end_x - center_x));

  settings->program_x SET_TO end_x;
  settings->program_y SET_TO end_y;
  end_x SET_TO (end_x + (tool_radius * cos(gamma)));
  end_y SET_TO (end_y + (tool_radius * sin(gamma)));
  ARC_FEED(end_x, end_y, center_x, center_y, turn, end_z);
  settings->current_x SET_TO end_x;
  settings->current_y SET_TO end_y;
  settings->current_z SET_TO end_z;

  return RS274NGC_OK;
}

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

/* convert_arc_comp2

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occurs, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. arc_data_ijk or arc_data_r returns RS274NGC_ERROR.
   2. A concave corner is found.
   3. The tool will not fit inside an arc.
   4. The tool radius is zero or negative

Side effects:
   This executes an arc command feed rate. If needed, at also generates
   an arc to go around a convex corner. It also updates the setting of
   the position of the tool point to the end point of the move.

Called by: convert_arc.

This function converts a helical or circular arc. The axis must be
parallel to the z-axis. This is called when cutter radius compensation
is on and this is not the first cut after the turning on.

If the Z-axis is moved in this block and an extra arc is required to
go around a sharp corner, all the Z-axis motion occurs on the main arc
and none on the extra arc.  An alternative might be to distribute the
Z-axis motion over the extra arc and the main arc in proportion to
their lengths.

*/

int convert_arc_comp2(   /* ARGUMENT VALUES                                */
 int move,               /* either G_2 (cw arc) or G_3 (ccw arc)           */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions   */
 setup_pointer settings, /* pointer to machine settings                    */
 double end_x,           /* x-value at end of programmed (then actual) arc */
 double end_y,           /* y-value at end of programmed (then actual) arc */
 double end_z)           /* z-value at end of arc                          */
{
  static char name[] SET_TO "convert_arc_comp2";
  double center_x; /* center of arc */
  double center_y;
  double start_x;
  double start_y;
  int turn;     /* number of full or partial circles CCW */
  double theta; /* direction of tangent to last cut */
  double delta; /* direction of radius from start of arc to center of arc */
  double alpha; /* direction of tangent to start of arc */
  double beta;  /* angle between two tangents above */
  double gamma; /* direction of perpendicular to arc at end */
  double arc_radius;
  double tool_radius;
  /* small angle in radians for testing corners */
  double small SET_TO TOLERANCE_CONCAVE_CORNER;
  int side;
  int status;
  double tolerance;

/* find basic arc data: center_x, center_y, and turn */

  start_x SET_TO settings->program_x;
  start_y SET_TO settings->program_y;
  tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ?
    TOLERANCE_INCH : TOLERANCE_MM;

  if (block->r_flag)
    {
      status SET_TO arc_data_r(move, start_x, start_y, end_x, end_y,
                               block->r_number, &center_x, &center_y, &turn);
    }
  else
    {
      status SET_TO
        arc_data_ijk(move, start_x, start_y, end_x, end_y,
                     block->i_number, block->j_number,
                     &center_x, &center_y, &turn, tolerance);
    }

  if (status IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);

/* compute other data */
  side SET_TO settings->cutter_radius_compensation;
  tool_radius SET_TO
    (settings->tool_table[settings->tool_table_index].diameter)/2.0;
  if (tool_radius <= 0.0)
    ERROR_MACRO(_interpreter_linetext, name, "Bad tool radius value with cutter radius comp");
  arc_radius SET_TO hypot((center_x - end_x), (center_y - end_y));
  theta SET_TO
    atan2(settings->current_y - start_y, settings->current_x - start_x);
  theta SET_TO (side IS LEFT) ? (theta - PI2) : (theta + PI2);
  delta SET_TO atan2(center_y - start_y, center_x - start_x);
  alpha SET_TO (move IS G_3) ? (delta - PI2) : (delta + PI2);
  beta SET_TO (side IS LEFT) ? (theta - alpha) : (alpha - theta);
  beta SET_TO (beta > (1.5 * PI))  ? (beta - TWO_PI) :
              (beta < -PI2) ? (beta + TWO_PI) : beta;

  if (((side IS LEFT)  AND (move IS G_3)) OR
      ((side IS RIGHT) AND (move IS G_2)))
    {
      gamma SET_TO atan2 ((center_y - end_y), (center_x - end_x));
      if (arc_radius <= tool_radius)
        ERROR_MACRO(_interpreter_linetext, name,
           "Tool radius not less than arc radius with cutter radius comp");
    }
  else
    {
      gamma SET_TO atan2 ((end_y - center_y), (end_x - center_x));
      delta SET_TO (delta + PI);
    }

  settings->program_x SET_TO end_x;
  settings->program_y SET_TO end_y;

/* check if extra arc needed and insert if so */

  if ((beta < -small) OR (beta > (PI + small)))
    ERROR_MACRO(_interpreter_linetext, name, "Concave corner with cutter radius comp");
  else if (beta > small) /* TWO ARCS NEEDED */
    ARC_FEED((start_x + (tool_radius * cos(delta))),
             (start_y + (tool_radius * sin(delta))),
             start_x, start_y, (side IS LEFT) ? -1 : 1,
             settings->current_z);

  end_x SET_TO (end_x + (tool_radius * cos(gamma))); /* end_x reset actual */
  end_y SET_TO (end_y + (tool_radius * sin(gamma))); /* end_y reset actual */

/* insert main arc */
  ARC_FEED(end_x, end_y, center_x, center_y, turn, end_z);

  settings->current_x SET_TO end_x;
  settings->current_y SET_TO end_y;
  settings->current_z SET_TO end_z;

  return RS274NGC_OK;
}

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

/* convert_arc_xy

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If arc_data_ijk or arc_data_r returns RS274NGC_ERROR, this
   returns RS274NGC_ERROR. Otherwise, it returns RS274NGC_OK.

Side effects:
   This executes an arc command at feed rate. It also updates the
   setting of the position of the tool point to the end point of the move.
   If inverse time feed rate is in effect, it also resets the feed rate.

Called by: convert_arc.

This converts a helical or circular arc. The axis must be parallel to
the z-axis.

*/

int convert_arc_xy(      /* ARGUMENT VALUES                          */
 int move,               /* either G_2 (cw arc) or G_3 (ccw arc)     */
 block_pointer block,    /* pointer to a block of RS274 instructions */
 setup_pointer settings, /* pointer to machine settings              */
 double end_x,           /* x-value at end of arc                    */
 double end_y,           /* y-value at end of arc                    */
 double end_z)           /* z-value at end of arc                    */
{
  static char name[] SET_TO "convert_arc_xy";
  double center_x;
  double center_y;
  double length;
  double rate;
  int turn;
  int status;
  double tolerance;

  tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ?
    TOLERANCE_INCH : TOLERANCE_MM;

  if (block->r_flag)
    {
      status SET_TO
        arc_data_r(move, settings->current_x, settings->current_y, end_x,
                   end_y, block->r_number, &center_x, &center_y, &turn);
    }
  else
    {
      status SET_TO
        arc_data_ijk(move, settings->current_x, settings->current_y,
                     end_x, end_y, block->i_number, block->j_number,
                     &center_x, &center_y, &turn, tolerance);
    }

  if (status IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);

  if (settings->feed_mode IS INVERSE_TIME)
    {
      length SET_TO utility_find_arc_length
        (settings->current_x, settings->current_y, settings->current_z,
         center_x, center_y, turn, end_x, end_y, end_z);
      rate SET_TO MAX(0.1, (length * block->f_number));
      SET_FEED_RATE (rate);
      settings->feed_rate SET_TO rate;
    }

  ARC_FEED(end_x, end_y, center_x, center_y, turn, end_z);
  settings->current_x SET_TO end_x;
  settings->current_y SET_TO end_y;
  settings->current_z SET_TO end_z;
  return RS274NGC_OK;
}

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

/* convert_arc_yz

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If arc_data_ijk or arc_data_r returns RS274NGC_ERROR, this
   returns RS274NGC_ERROR. Otherwise, it returns RS274NGC_OK.

Side effects:
   This executes an arc command at feed rate. It also updates the
   setting of the position of the tool point to the end point of the move.
   If inverse time feed rate is in effect, it also resets the feed rate.

Called by: convert_arc.

This converts a helical or circular arc. The axis must be parallel to
the x-axis.

*/

int convert_arc_yz(      /* ARGUMENT VALUES                          */
 int move,               /* either G_2 (cw arc) or G_3 (ccw arc)     */
 block_pointer block,    /* pointer to a block of RS274 instructions */
 setup_pointer settings, /* pointer to machine settings              */
 double end_y,           /* y-value at end of arc                    */
 double end_z,           /* z-value at end of arc                    */
 double end_x)           /* x-value at end of arc                    */
{
  static char name[] SET_TO "convert_arc_yz";
  double center_y;
  double center_z;
  double length;
  double rate;
  int turn;
  int status;
  double tolerance;

  tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ?
    TOLERANCE_INCH : TOLERANCE_MM;

  if (block->r_flag)
    {
      status SET_TO
        arc_data_r(move, settings->current_y, settings->current_z, end_y,
                   end_z, block->r_number, &center_y, &center_z, &turn);
    }
  else
    {
      status SET_TO
        arc_data_ijk(move, settings->current_y, settings->current_z,
                     end_y, end_z, block->j_number, block->k_number,
                     &center_y, &center_z, &turn, tolerance);
    }

  if (status IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);

  if (settings->feed_mode IS INVERSE_TIME)
    {
      length SET_TO utility_find_arc_length
        (settings->current_y, settings->current_z, settings->current_x,
         center_y, center_z, turn, end_y, end_z, end_x);
      rate SET_TO MAX(0.1, (length * block->f_number));
      SET_FEED_RATE (rate);
      settings->feed_rate SET_TO rate;
    }

  ARC_FEED(end_y, end_z, center_y, center_z, turn, end_x);
  settings->current_y SET_TO end_y;
  settings->current_z SET_TO end_z;
  settings->current_x SET_TO end_x;

  return RS274NGC_OK;
}

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

/* convert_arc_zx

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If arc_data_ijk or arc_data_r returns RS274NGC_ERROR, this
   returns RS274NGC_ERROR. Otherwise, it returns RS274NGC_OK.

Side effects:
   This executes an arc command at feed rate. It also updates the
   setting of the position of the tool point to the end point of the move.
   If inverse time feed rate is in effect, it also resets the feed rate.

Called by: convert_arc.

This converts a helical or circular arc. The axis must be parallel to
the y-axis.

*/

int convert_arc_zx(      /* ARGUMENT VALUES                          */
 int move,               /* either G_2 (cw arc) or G_3 (ccw arc)     */
 block_pointer block,    /* pointer to a block of RS274 instructions */
 setup_pointer settings, /* pointer to machine settings              */
 double end_z,           /* z-value at end of arc                    */
 double end_x,           /* x-value at end of arc                    */
 double end_y)           /* y-value at end of arc                    */
{
  static char name[] SET_TO "convert_arc_zx";
  double center_z;
  double center_x;
  double length;
  double rate;
  int turn;
  int status;
  double tolerance;

  tolerance SET_TO (settings->length_units IS CANON_UNITS_INCHES) ?
    TOLERANCE_INCH : TOLERANCE_MM;

  if (block->r_flag)
    {
      status SET_TO
        arc_data_r(move, settings->current_z, settings->current_x, end_z,
                   end_x, block->r_number, &center_z, &center_x, &turn);
    }
  else
    {
      status SET_TO
        arc_data_ijk(move, settings->current_z, settings->current_x,
                     end_z, end_x, block->k_number, block->i_number,
                     &center_z, &center_x, &turn, tolerance);
    }

  if (status IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);

  if (settings->feed_mode IS INVERSE_TIME)
    {
      length SET_TO utility_find_arc_length
        (settings->current_z, settings->current_x, settings->current_y,
         center_z, center_x, turn, end_z, end_x, end_y);
      rate SET_TO MAX(0.1, (length * block->f_number));
      SET_FEED_RATE (rate);
      settings->feed_rate SET_TO rate;
    }

  ARC_FEED(end_z, end_x, center_z, center_x, turn, end_y);
  settings->current_z SET_TO end_z;
  settings->current_x SET_TO end_x;
  settings->current_y SET_TO end_y;

  return RS274NGC_OK;
}

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

/* convert_cycle_g81

Returned Value: int (RS274NGC_OK)

Side effects:
   A number of moves are made as described below.

Called by: convert_cycle

This implements the following cycle, which is usually drilling:
1. Move the z-axis only at the current feed rate to the specified bottom_z.
2. Retract the z-axis at traverse rate to clear_z.

See [NCMS, page 99].

convert_cycle has positioned the tool at (x, y, r) when this starts.

*/

int convert_cycle_g81( /* ARGUMENT VALUES                  */
 double x,             /* x-value where cycle is executed  */
 double y,             /* y-value where cycle is executed  */
 double clear_z,       /* z-value of clearance plane       */
 double bottom_z)      /* value of z at bottom of cycle    */
{
  static char name[] SET_TO "convert_cycle_g81";

  STRAIGHT_FEED(x, y, bottom_z);
  STRAIGHT_TRAVERSE(x, y, clear_z);

  return RS274NGC_OK;
}

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

/* convert_cycle_g82

Returned Value: int (RS274NGC_OK)

Side effects:
   A number of moves are made as described below.

Called by: convert_cycle

This implements the following cycle, which is usually drilling:
1. Move the z_axis only at the current feed rate to the specified z-value.
2. Dwell for the given number of seconds.
3. Retract the z-axis at traverse rate to the clear_z.

convert_cycle has positioned the tool at (x, y, r) when this starts.

*/

int convert_cycle_g82( /* ARGUMENT VALUES                  */
 double x,             /* x-value where cycle is executed  */
 double y,             /* y-value where cycle is executed  */
 double clear_z,       /* z-value of clearance plane       */
 double bottom_z,      /* value of z at bottom of cycle    */
 double dwell)         /* dwell time                       */
{
  static char name[] SET_TO "convert_cycle_g82";

  STRAIGHT_FEED(x, y, bottom_z);
  DWELL(dwell);
  STRAIGHT_TRAVERSE(x, y, clear_z);

  return RS274NGC_OK;
}

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

/* convert_cycle_g83

Returned Value: int (RS274NGC_OK)

Side effects:
   A number of moves are made as described below.

Called by: convert_cycle

This implements the following cycle, which is usually
deep drilling or milling with chipbreaking:
1. Move the z-axis only at the current feed rate downward by delta or
   to the specified bottom_z, whichever is less deep.
2. Dwell for 0.25 second.
3. Rapid back out to the clear_z.
4. Rapid back down to the current hole bottom, backed off a bit.
5. Repeat steps 1 and 2 until the specified bottom_z is reached.
6. Retract the z-axis at traverse rate to clear_z.

convert_cycle has positioned the tool at (x, y, r) when this starts.

The dwell causes any long stringers (which are common when drilling
in aluminum) to be cut off, and pulls out the chips.

*/

#define G83_RAPID_DELTA 0.010   /* how far above hole bottom for rapid
                                   return, in inches */
int convert_cycle_g83( /* ARGUMENT VALUES                  */
 double x,             /* x-value where cycle is executed  */
 double y,             /* y-value where cycle is executed  */
 double r,             /* initial z-value                  */
 double clear_z,       /* z-value of clearance plane       */
 double bottom_z,      /* value of z at bottom of cycle    */
 double delta)         /* size of z-axis feed increment    */
{
  static char name[] SET_TO "convert_cycle_g83";
  double current_depth;
  double rapid_delta;

  rapid_delta SET_TO G83_RAPID_DELTA;
  if (_interpreter_settings.length_units IS CANON_UNITS_MM)
    rapid_delta *= 25.4;

  for (current_depth SET_TO (r - delta);
       current_depth > bottom_z;
       current_depth SET_TO (current_depth - delta))
    {
      STRAIGHT_FEED(x, y, current_depth);
      DWELL(0.25);
      STRAIGHT_TRAVERSE(x, y, clear_z);
      STRAIGHT_TRAVERSE(x, y, current_depth + rapid_delta);
    }
  STRAIGHT_FEED(x, y, bottom_z);
  DWELL(0.25);
  STRAIGHT_TRAVERSE(x, y, clear_z);

  return RS274NGC_OK;
}

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

/* convert_cycle_g84

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If the spindle is not turning clockwise, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.

Side effects:
   A number of moves are made as described below. This is for right-hand
   tapping.

Called by: convert_cycle

This implements the following cycle, which is right-hand tapping:
1. Start speed-feed synchronization.
2. Move the z-axis only at the current feed rate to the specified bottom_z.
3. Stop the spindle.
4. Start the spindle counterclockwise.
5. Retract the z-axis at current feed rate to clear_z.
6. If speed-feed synch was not on before the cycle started, stop it.
7. Stop the spindle.
8. Start the spindle clockwise.

convert_cycle has positioned the tool at (x, y, r) when this starts.
The direction argument must be clockwise.

*/

int convert_cycle_g84(       /* ARGUMENT VALUES                     */
 double x,                   /* x-value where cycle is executed     */
 double y,                   /* y-value where cycle is executed     */
 double clear_z,             /* z-value of clearance plane          */
 double bottom_z,            /* value of z at bottom of cycle       */
 CANON_DIRECTION direction,  /* direction spindle turning at outset */
 CANON_SPEED_FEED_MODE mode) /* the speed-feed mode at outset       */
{
  static char name[] SET_TO "convert_cycle_g84";

  if (direction ISNT CANON_CLOCKWISE)
    ERROR_MACRO(_interpreter_linetext, name, "Spindle not turning clockwise in G84 canned cycle");
  START_SPEED_FEED_SYNCH();
  STRAIGHT_FEED(x, y, bottom_z);
  STOP_SPINDLE_TURNING();
  START_SPINDLE_COUNTERCLOCKWISE();
  STRAIGHT_FEED(x, y, clear_z);
  if (mode ISNT CANON_SYNCHED)
    STOP_SPEED_FEED_SYNCH();
  STOP_SPINDLE_TURNING();
  START_SPINDLE_CLOCKWISE();

  return RS274NGC_OK;
}

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

/* convert_cycle_g85

Returned Value: int (RS274NGC_OK)

Side effects:
   A number of moves are made as described below.

Called by: convert_cycle

This implements the following cycle, which is usually boring or reaming:
1. Move the z-axis only at the current feed rate to the specified z-value.
2. Retract the z-axis at the current feed rate to clear_z.

convert_cycle has positioned the tool at (x, y, r) when this starts.

*/

int convert_cycle_g85( /* ARGUMENT VALUES                  */
 double x,             /* x-value where cycle is executed  */
 double y,             /* y-value where cycle is executed  */
 double clear_z,       /* z-value of clearance plane       */
 double bottom_z)      /* value of z at bottom of cycle    */
{
  static char name[] SET_TO "convert_cycle_g85";

  STRAIGHT_FEED(x, y, bottom_z);
  STRAIGHT_FEED(x, y, clear_z);

  return RS274NGC_OK;
}

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

/* convert_cycle_g86

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If the spindle is not turning clockwise or counterclockwise,
   this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.

Side effects:
   A number of moves are made as described below.

Called by: convert_cycle

This implements the following cycle, which is usually boring:
1. Move the z-axis only at the current feed rate to bottom_z.
2. Dwell for the given number of seconds.
3. Stop the spindle turning.
4. Retract the z-axis at traverse rate to clear_z.
5. Restart the spindle in the direction it was going.

convert_cycle has positioned the tool at (x, y, r) when this starts.

*/

int convert_cycle_g86(      /* ARGUMENT VALUES                     */
 double x,                  /* x-value where cycle is executed     */
 double y,                  /* y-value where cycle is executed     */
 double clear_z,            /* z-value of clearance plane          */
 double bottom_z,           /* value of z at bottom of cycle       */
 double dwell,              /* dwell time                          */
 CANON_DIRECTION direction) /* direction spindle turning at outset */
{
  static char name[] SET_TO "convert_cycle_g86";

  if ((direction ISNT CANON_CLOCKWISE) AND
      (direction ISNT CANON_COUNTERCLOCKWISE))
    ERROR_MACRO(_interpreter_linetext, name, "Spindle not turning in G86 canned cycle");

  STRAIGHT_FEED(x, y, bottom_z);
  DWELL(dwell);
  STOP_SPINDLE_TURNING();
  STRAIGHT_TRAVERSE(x, y, clear_z);
  if (direction IS CANON_CLOCKWISE)
    START_SPINDLE_CLOCKWISE();
  else
    START_SPINDLE_COUNTERCLOCKWISE();

  return RS274NGC_OK;
}

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

/* convert_cycle_g87

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If the spindle is not turning clockwise or counterclockwise,
   this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.

Side effects:
   A number of moves are made as described below. This cycle is a
   modified version of [Monarch, page 5-24] since [NCMS, pages 98 - 100]
   gives no clue as to what the cycle is supposed to do.

Called by: convert_cycle

This implements the following cycle, which is usually back
boring.  The situation is that you have a through hole and you want to
counterbore the bottom of hole. To to this you put an L-shaped tool in
the spindle with a cutting surface on the UPPER side of its base. You
stick it carefully through the hole when it is not spinning and is
oriented so it fits through the hole, then you move it so the stem of
the L is on the axis of the hole, start the spindle, and feed the tool
upward to make the counterbore. Then you get the tool out of the hole.

1. Move at traverse rate parallel to the XY-plane to the point
   with x-value offset_x and y-value offset_y.
2. Stop the spindle in a specific orientation.
3. Move the z-axis only at traverse rate downward to the bottom_z.
4. Move at traverse rate parallel to the XY-plane to the x,y location.
5. Start the spindle in the direction it was going before.
6. Move the z-axis only at the given feed rate upward to the middle_z.
7. Move the z-axis only at the given feed rate back down to bottom_z.
8. Stop the spindle in the same orientation as before.
9. Move at traverse rate parallel to the XY-plane to the point
   with x-value offset_x and y-value offset_y.
10. Move the z-axis only at traverse rate to the clear z value.
11. Move at traverse rate parallel to the XY-plane to the specified x,y
    location.
12. Restart the spindle in the direction it was going before.

convert_cycle has positioned the tool at (x, y, r) before this starts.

It might be useful to add a check that clear_z > middle_z > bottom_z.
Without the check, however, this can be used to counterbore a hole in
material that can only be accessed through a hole in material above it.

*/

int convert_cycle_g87(       /* ARGUMENT VALUES                     */
 double x,                   /* x-value where cycle is executed     */
 double offset_x,            /* x-axis offset position              */
 double y,                   /* y-value where cycle is executed     */
 double offset_y,            /* y-axis offset position              */
 double r,                   /* z_value of r_plane                  */
 double clear_z,             /* z-value of clearance plane          */
 double middle_z,            /* z-value of top of back bore         */
 double bottom_z,            /* value of z at bottom of cycle       */
 CANON_DIRECTION direction)  /* direction spindle turning at outset */
{
  static char name[] SET_TO "convert_cycle_g87";

  if ((direction ISNT CANON_CLOCKWISE) AND
      (direction ISNT CANON_COUNTERCLOCKWISE))
    ERROR_MACRO(_interpreter_linetext, name, "Spindle not turning in G87 canned cycle");

  STRAIGHT_TRAVERSE(offset_x, offset_y, r);
  STOP_SPINDLE_TURNING();
  ORIENT_SPINDLE(0.0, direction);
  STRAIGHT_TRAVERSE(offset_x, offset_y, bottom_z);
  STRAIGHT_TRAVERSE(x, y, bottom_z);
  if (direction IS CANON_CLOCKWISE)
    START_SPINDLE_CLOCKWISE();
  else
    START_SPINDLE_COUNTERCLOCKWISE();
  STRAIGHT_FEED(x, y, middle_z);
  STRAIGHT_FEED(x, y, bottom_z);
  STOP_SPINDLE_TURNING();
  ORIENT_SPINDLE(0.0, direction);
  STRAIGHT_TRAVERSE(offset_x, offset_y, bottom_z);
  STRAIGHT_TRAVERSE(offset_x, offset_y, clear_z);
  STRAIGHT_TRAVERSE(x, y, clear_z);
  if (direction IS CANON_CLOCKWISE)
    START_SPINDLE_CLOCKWISE();
  else
    START_SPINDLE_COUNTERCLOCKWISE();

  return RS274NGC_OK;
}

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

/* convert_cycle_g88

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If the spindle is not turning clockwise or counterclockwise, this
   returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.

Side effects:
   A number of moves are made as described below.

Called by: convert_cycle

This implements the following cycle, which is usually boring:
1. Move the z-axis only at the current feed rate to the specified z-value.
2. Dwell for the given number of seconds.
3. Stop the spindle turning.
4. Stop the program so the operator can retract the spindle manually.
5. Restart the spindle.

convert_cycle has positioned the tool at (x, y, r) when this starts.

*/

int convert_cycle_g88(      /* ARGUMENT VALUES                     */
 double x,                  /* x-value where cycle is executed     */
 double y,                  /* y-value where cycle is executed     */
 double bottom_z,           /* value of z at bottom of cycle       */
 double dwell,              /* dwell time                          */
 CANON_DIRECTION direction) /* direction spindle turning at outset */
{
  static char name[] SET_TO "convert_cycle_g88";

  if ((direction ISNT CANON_CLOCKWISE) AND
      (direction ISNT CANON_COUNTERCLOCKWISE))
    ERROR_MACRO(_interpreter_linetext, name, "Spindle not turning in G88 canned cycle");

  STRAIGHT_FEED(x, y, bottom_z);
  DWELL(dwell);
  STOP_SPINDLE_TURNING();
  PROGRAM_STOP(); /* operator retracts the spindle here */
  if (direction IS CANON_CLOCKWISE)
    START_SPINDLE_CLOCKWISE();
  else
    START_SPINDLE_COUNTERCLOCKWISE();

  return RS274NGC_OK;
}

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

/* convert_cycle_g89

Returned Value: int (RS274NGC_OK)

Side effects:
   A number of moves are made as described below.

Called by: convert_cycle

This implements the following cycle, which is intended for boring:
1. Move the z-axis only at the current feed rate to the specified z-value.
2. Dwell for the given number of seconds.
3. Retract the z-axis at the current feed rate to clear_z.

*/

int convert_cycle_g89(      /* ARGUMENT VALUES                     */
 double x,                  /* x-value where cycle is executed     */
 double y,                  /* y-value where cycle is executed     */
 double clear_z,            /* z-value of clearance plane          */
 double bottom_z,           /* value of z at bottom of cycle       */
 double dwell)              /* dwell time                          */
{
  static char name[] SET_TO "convert_cycle_g89";

  STRAIGHT_FEED(x, y, bottom_z);
  DWELL(dwell);
  STRAIGHT_FEED(x, y, clear_z);

  return RS274NGC_OK;
}

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

/* convert_straight_comp1

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The side is not RIGHT or LEFT.
   2. The destination tangent point is not more than a tool radius
      away (indicating gouging).
   3. The tool radius is less than or equal to zero.

Side effects:
   This executes a straight move command at cutting feed rate.
   It also updates the setting of the position of the tool point
   to the end point of the move and updates the programmed point.

Called by: convert_straight.

This is called if cutter radius compensation is on and
settings->program_x is UNKNOWN, indicating that this is the first move
after cutter radius compensation is turned on.

The algorithm used here for determining the path is to draw a straight
line from the destination point which is tangent to a circle whose
center is at the current point and whose radius is the radius of the
cutter. The destination point of the cutter tip is then found as the
center of a circle of the same radius tangent to the tangent line at
the destination point.

*/

int convert_straight_comp1( /* ARGUMENT VALUES                         */
 setup_pointer settings,    /* pointer to machine settings             */
 double px,                 /* X coordinate of end point               */
 double py,                 /* Y coordinate of end point               */
 double end_z)              /* Z coordinate of end point               */
{
  static char name[] SET_TO "convert_straight_comp1";
  double radius;
  double cx, cy;
  double distance;
  double theta;
  double alpha;
  int side;

  side SET_TO settings->cutter_radius_compensation;
  cx SET_TO settings->current_x;
  cy SET_TO settings->current_y;

  radius SET_TO
    (settings->tool_table[settings->tool_table_index].diameter)/2.0;
  if (radius <= 0.0)
    ERROR_MACRO(_interpreter_linetext, name, "Bad tool radius value with cutter radius comp");
  distance SET_TO hypot((px - cx), (py -cy));

  if ((side ISNT LEFT) AND (side ISNT RIGHT))
    BUG_MACRO(name,
              "Side fails to be right or left in convert_straight_comp1");
  else if (distance <= radius)
    ERROR_MACRO(_interpreter_linetext, name, "Cutter gouging with cutter radius comp");

  theta SET_TO acos(radius/distance);
  alpha SET_TO (side IS LEFT) ? (atan2((cy - py), (cx - px)) - theta) :
                                (atan2((cy - py), (cx - px)) + theta);
  cx SET_TO (px + (radius * cos(alpha))); /* reset to end location */
  cy SET_TO (py + (radius * sin(alpha)));
  STRAIGHT_FEED (cx, cy, end_z);
  settings->current_x SET_TO cx;
  settings->current_y SET_TO cy;
  settings->program_x SET_TO px;
  settings->program_y SET_TO py;
  return RS274NGC_OK;
}

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

/* convert_straight_comp2

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The compensation side is not RIGHT or LEFT.
   2. A concave corner is found.
   3. The tool radius is less than or equal to zero.

Side effects:
   This executes a straight move command at cutting feed rate.
   It also generates an arc cut to go around a corner, if necessary.
   It also updates the setting of the position of the tool point to
   the end point of the move and updates the programmed point.

Called by: convert_straight.

This is called if cutter radius compensation is on and
settings->program_x is not UNKNOWN, indicating that this is not the
first move after cutter radius compensation is turned on.

The algorithm used here is:
1. Determine the direction of the last motion. This is done by finding
   the direction of the line from the last programmed point to the
   current tool tip location. This line is a radius of the tool and is
   perpendicular to the direction of motion since the cutter is tangent
   to that direction.
2. Determine the direction of the programmed motion.
3. If there is a convex corner, insert an arc to go around the corner.
4. Find the destination point for the tool tip. The tool will be
   tangent to the line from the last programmed point to the present
   programmed point at the present programmed point.
5. Go in a straight line from the current tool tip location to the
   destination tool tip location.

This uses an angle tolerance of 0.001 radian to determine if:
1) an illegal concave corner exists (tool will not fit into corner),
2) no arc is required to go around the corner (i.e. the current line
   is in the same direction as the end of the previous move), or
3) an arc is required to go around a convex corner and start off in
   a new direction.

If the B-axis is moved in this block and an extra arc is required to go
around a sharp corner, all the B-axis motion occurs on the arc.
An alternative might be to distribute the B-axis motion over the arc
and the straight move in proportion to their lengths.

*/

int convert_straight_comp2( /* ARGUMENT VALUES                         */
 setup_pointer settings,    /* pointer to machine settings             */
 double program_end_x,      /* X coordinate of programmed end point    */
 double program_end_y,      /* Y coordinate of programmed end point    */
 double end_z)              /* Z coordinate of end point               */
{
  static char name[] SET_TO "convert_straight_comp2";
  double radius;
  double cx, cy; /* actual end point */
  double dx, dy; /* end of added arc, if needed */
  double start_x, start_y; /* programmed beginning point */
  double theta;
  double alpha;
  double beta;
  double gamma;
  /* small angle in radians for testing corners */
  double small SET_TO TOLERANCE_CONCAVE_CORNER;
  int side;

  side SET_TO settings->cutter_radius_compensation;
  start_x SET_TO settings->program_x;
  start_y SET_TO settings->program_y;
  if ((start_x IS program_end_x) AND (start_y IS program_end_y))
    {
      STRAIGHT_FEED(settings->current_x, settings->current_y, end_z);
      return RS274NGC_OK;
    }
  radius SET_TO
    (settings->tool_table[settings->tool_table_index].diameter)/2.0;
  if (radius <= 0.0)
    ERROR_MACRO(_interpreter_linetext, name, "Bad tool radius value with cutter radius comp");
  theta SET_TO atan2(settings->current_y - start_y,
                     settings->current_x - start_x);
  alpha SET_TO
    atan2(program_end_y - start_y, program_end_x - start_x);

  if (side IS LEFT)
    {
      if (theta < alpha)
        theta SET_TO (theta + TWO_PI);
      beta SET_TO ((theta - alpha) - PI2);
      gamma SET_TO PI2;
    }
  else if (side IS RIGHT)
    {
      if (alpha < theta)
        alpha SET_TO (alpha + TWO_PI);
      beta SET_TO ((alpha - theta) - PI2);
      gamma SET_TO -PI2;
    }
  else
    BUG_MACRO(name,
              "Side fails to be right or left in convert_straight_comp2");
  cx SET_TO (program_end_x + (radius * cos(alpha + gamma)));
  cy SET_TO (program_end_y + (radius * sin(alpha + gamma)));
  dx SET_TO (start_x + (radius * cos(alpha + gamma)));
  dy SET_TO (start_y + (radius * sin(alpha + gamma)));

  if ((beta < -small) OR (beta > (PI + small)))
    ERROR_MACRO(_interpreter_linetext, name, "Cannot have concave corner with cutter radius comp");
  else if (beta > small) /* ARC NEEDED */
    {
      ARC_FEED(dx, dy, start_x, start_y, (side IS LEFT) ? -1 : 1, end_z);
      STRAIGHT_FEED (cx, cy, end_z);
    }
  else STRAIGHT_FEED (cx, cy, end_z);

  settings->current_x SET_TO cx;
  settings->current_y SET_TO cy;
  settings->program_x SET_TO program_end_x;
  settings->program_y SET_TO program_end_y;
  return RS274NGC_OK;
}

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

/* read_integer_unsigned

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, RS274NGC_ERROR is returned.
   Otherwise, RS274NGC_OK is returned.
   1. The first character is not a digit.
   2. BUG - sscanf fails.

Side effects:
   The number read from the line is put into what integer_ptr points at.

Called by:
   read_line_number

This reads an explicit unsigned (positive) integer from a string,
starting from the position given by *counter. It expects to find one
or more digits. Any character other than a digit terminates reading
the integer. Note that if the first character is a sign (+ or -),
an error will be reported (since a sign is not a digit).

*/

int read_integer_unsigned(   /* ARGUMENT VALUES                        */
 char * line,         /* string: line of RS274 code being processed    */
 int * counter,       /* pointer to a counter for position on the line */
 int * integer_ptr)   /* pointer to the value being read               */
{
  static char name[] SET_TO "read_integer_unsigned";
  int n;
  char c;

  for (n SET_TO *counter; ; n++)
    {
      c SET_TO line[n];
      if ((c < 48) OR (c > 57))
        break;
    }
  if (n IS *counter)
    ERROR_MACRO(_interpreter_linetext, name, "Bad format unsigned integer");
  if (sscanf(line + *counter, "%d", integer_ptr) IS 0)
    BUG_MACRO(name, "Sscanf failure in read_integer_unsigned");
  else
    {
      *counter SET_TO n;
      return RS274NGC_OK;
    }
}

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

/* read_real_value

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If no characters are found before the end of the line or
   if a call to read_real_expression, read_parameter, read_unary,
   or read_real_number returns RS274NGC_ERROR, this returns RS274NGC_ERROR.
   Otherwise, this returns RS274NGC_OK.

Side effects:
   The value read from the line 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_f
   read_g
   read_i
   read_integer_value
   read_j
   read_k
   read_parameter
   read_parameter_setting
   read_q
   read_r
   read_real_expression
   read_spindle_speed
   read_x
   read_y
   read_z

This attempts to read a real value out of the line, starting at the
index given by the counter. The value may be a number, a parameter
value, a unary function, or an expression. It calls one of four
other readers, depending upon the first character.


*/

int read_real_value(  /* ARGUMENT VALUES                                */
 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                     */
{
  static char name[] SET_TO "read_real_value";
  char c;

  c SET_TO line[*counter];
  if (c IS 0)
    ERROR_MACRO(_interpreter_linetext, name, "No characters found in reading real value");
  else if (c IS '[')
    return read_real_expression (line, counter, double_ptr, parameters);
  else if (c IS '#')
    return read_parameter(line, counter, double_ptr, parameters);
  else if ((c >= 'a') AND (c <= 'z'))
    return read_unary(line, counter, double_ptr, parameters);
  else
    return read_real_number(line, counter, double_ptr);
}

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

/* utility_find_ends

Returned Value: int (RS274NGC_OK)

Side effects:
   The values of px, py, and pz are set.

Called by:
   convert_arc
   convert_straight

This finds the end point of a straight line or arc.

*/

int utility_find_ends(   /* ARGUMENT VALUES                              */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings, /* pointer to machine settings                  */
 double * px,            /* pointer to end_x                             */
 double * py,            /* pointer to end_y                             */
 double * pz)            /* pointer to end_z                             */
{
  int mode;
  int middle;
  int comp;

  mode SET_TO settings->distance_mode;
  middle SET_TO (settings->program_x ISNT UNKNOWN);
  comp SET_TO (settings->cutter_radius_compensation ISNT OFF);

  if (block->g_modes[4] IS G_53) /* mode is absolute in this case */
    {
#ifdef DEBUG_EMC
      COMMENT("interpreter: offsets temporarily suspended");
#endif
      *px SET_TO (block->x_flag IS ON) ? (block->x_number -
                   (settings->origin_offset_x + settings->axis_offset_x)) :
                     settings->current_x;
      *py SET_TO (block->y_flag IS ON) ? (block->y_number -
                   (settings->origin_offset_y + settings->axis_offset_y)) :
                     settings->current_y;
      *pz SET_TO (block->z_flag IS ON) ? (block->z_number -
                   (settings->tool_length_offset + settings->origin_offset_z
                    + settings->axis_offset_z)) : settings->current_z;
    }
  else if (mode IS MODE_ABSOLUTE)
    {
      *px SET_TO (block->x_flag IS ON) ? block->x_number     :
                 (comp AND middle)     ? settings->program_x :
                                         settings->current_x ;

      *py SET_TO (block->y_flag IS ON) ? block->y_number     :
                 (comp AND middle)     ? settings->program_y :
                                         settings->current_y ;

      *pz SET_TO (block->z_flag IS ON) ? block->z_number     :
                                         settings->current_z ;
    }
  else
    {
      *px SET_TO (block->x_flag IS ON)
        ? ((comp AND middle) ? (block->x_number + settings->program_x)
                             : (block->x_number + settings->current_x))
        : ((comp AND middle) ? settings->program_x
                             : settings->current_x);

      *py SET_TO (block->y_flag IS ON)
        ? ((comp AND middle) ? (block->y_number + settings->program_y)
                             : (block->y_number + settings->current_y))
        : ((comp AND middle) ? settings->program_y
                             : settings->current_y);

      *pz SET_TO (block->z_flag IS ON)
        ? (settings->current_z + block->z_number)
        : settings->current_z;
    }

  return RS274NGC_OK;
}

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

/* convert_arc

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   This returns RS274NGC_OK unless one of the following errors occurs,
   in which case it returns RS274NGC_ERROR.
   1. The block has neither an r value nor any i,j,k values.
   2. The block has both an r value and one or more i,j,k values.
   3. In the ijk format the XY-plane is selected and either:
      a. the block has a k value, or
      b. the block has no i value and no j value.
   4. In the ijk format the YZ-plane is selected and either:
      a. the block has an i value, or
      b. the block has no j value and no k value.
   5. In the ijk format the XZ-plane is selected and either:
      a. the block has a j value, or
      b. the block has no i value and no k value.
   6. In either format any of the following occurs.
      a. The XY-plane is selected and the block has no x or y value.
      b. The XY-plane is selected, cutter radius compensation is on,
         and inverse time feed is used.
      c. The YZ-plane is selected and the block has no y or z value.
      d. The ZX-plane is selected and the block has no z or x value.
   7. BUG - The selected plane is an unknown plane.
   8. One of the subordinate arc making functions is called and returns
      RS274NGC_ERROR.
   9. The feed rate is zero.

Side effects:
   This generates and executes an arc command at feed rate
   (and, possibly a second arc command). It also updates the setting
   of the position of the tool point to the end point of the move.

Called by: convert_motion.

This converts a helical or circular arc.  The function calls one of
five convert_arc_XXX functions (three for for the xy plane and one
each for the yz and zx plane) according to the currently selected
plane and whether cutter radius compensation is in effect.

If the ijk format is used, at least one of the offsets in the current
plane must be given in the block; it is common but not required to
give both offsets. The offsets are always incremental [NCMS, page 21].

*/

int convert_arc(         /* ARGUMENT VALUES                              */
 int move,               /* either G_2 (cw arc) or G_3 (ccw arc)         */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings) /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_arc";
  int status;
  DISTANCE_MODE mode;
  int first;
  int ijk_flag;
  double end_x;
  double end_y;
  double end_z;

  mode SET_TO settings->distance_mode;
  ijk_flag SET_TO
    ((block->i_flag OR block->j_flag) OR block->k_flag) ? ON : OFF;
  first SET_TO (settings->program_x IS UNKNOWN);

  if ((block->r_flag ISNT ON) AND (ijk_flag ISNT ON))
    ERROR_MACRO(_interpreter_linetext, name, "R, I, J, and K words all missing for arc");
  else if ((block->r_flag IS ON) AND (ijk_flag IS ON))
    ERROR_MACRO(_interpreter_linetext, name, "Mixed radius-ijk format for arc");
  else if (settings->feed_rate IS 0.0)
    ERROR_MACRO(_interpreter_linetext, name, "Cannot make arc with zero feed rate");
  else if (ijk_flag)
    {
      if (settings->plane IS CANON_PLANE_XY)
        {
          if (block->k_flag)
            ERROR_MACRO(_interpreter_linetext, name, "K word given for arc in XY-plane");
          else if (block->i_flag IS OFF) /* i or j flag on to get here */
              block->i_number SET_TO 0.0;
          else if (block->j_flag IS OFF)
            block->j_number SET_TO 0.0;
        }
      else if (settings->plane IS CANON_PLANE_YZ)
        {
          if (block->i_flag)
            ERROR_MACRO(_interpreter_linetext, name, "I word given for arc in YZ-plane");
          else if (block->j_flag IS OFF) /* j or k flag on to get here */
              block->j_number SET_TO 0.0;
          else if (block->k_flag IS OFF)
            block->k_number SET_TO 0.0;
        }
      else if (settings->plane IS CANON_PLANE_XZ)
        {
          if (block->j_flag)
            ERROR_MACRO(_interpreter_linetext, name, "J word given for arc in XZ-plane");
          else if (block->i_flag IS OFF) /* i or k flag on to get here */
              block->i_number SET_TO 0.0;
          else if (block->k_flag IS OFF)
            block->k_number SET_TO 0.0;
        }
      else
        BUG_MACRO(name, "Plane is not XY, YZ, or XZ in convert_arc");
    }
  else; /* r format arc; no other checks needed specific to this format */

  if (settings->plane IS CANON_PLANE_XY) /* checks for both formats */
    {
      if ((block->x_flag IS OFF) AND (block->y_flag IS OFF))
        ERROR_MACRO(_interpreter_linetext, name, "X and Y words missing for arc in XY-plane");
    }
  else if (settings->plane IS CANON_PLANE_YZ)
    {
      if ((block->y_flag IS OFF) AND (block->z_flag IS OFF))
        ERROR_MACRO(_interpreter_linetext, name, "Y and Z words missing for arc in YZ-plane");
    }
  else if (settings->plane IS CANON_PLANE_XZ)
    {
      if ((block->x_flag IS OFF) AND (block->z_flag IS OFF))
        ERROR_MACRO(_interpreter_linetext, name, "X and Z words missing for arc in XZ-plane");
    }

  utility_find_ends(block, settings, &end_x, &end_y, &end_z);

  settings->motion_mode SET_TO move;

  if (settings->plane IS CANON_PLANE_XY)
    {
      if (settings->cutter_radius_compensation IS OFF)
        status SET_TO convert_arc_xy(move, block, settings, end_x, end_y,
                                     end_z);
      else if (settings->feed_mode IS INVERSE_TIME)
        ERROR_MACRO(_interpreter_linetext, name,
                     "Cannot use inverse time feed with cutter radius comp");
      else if (first)
        status SET_TO convert_arc_comp1
          (move, block, settings, end_x, end_y, end_z);
      else
        status SET_TO convert_arc_comp2
          (move, block, settings, end_x, end_y, end_z);
    }
  else if (settings->plane IS CANON_PLANE_XZ)
    status SET_TO convert_arc_zx (move, block, settings, end_z, end_x, end_y);
  else if (settings->plane IS CANON_PLANE_YZ)
    status SET_TO convert_arc_yz (move, block, settings, end_y, end_z, end_x);
  else
   BUG_MACRO(name, "Plane is not XY, YZ, or XZ in convert_arc");

  if (status ISNT RS274NGC_OK)
    ERROR_MACRO_PASS(name);
  else
    return RS274NGC_OK;
}

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

/* convert_axis_offsets

Returned Value: int
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. The function is called when cutter radius compensation is on.
   2. BUG - g_code is not G_92 or G_92_2.

Side effects:
   SET_PROGRAM_ORIGIN is called, and the coordinate
   values for the axis offsets are reset. The coordinates of the
   current point are reset.

Called by: convert_modal_0.

The action of G92 is described in [NCMS, pages 10 - 11] and {Fanuc,
pages 61 - 63]. [NCMS] is ambiguous about the intent, but [Fanuc]
is clear. When G92 is executed, an offset of the origin is calculated
so that the coordinates of the current point with respect to the moved
origin are as specified on the line containing the G92. If an axis
is not mentioned on the line, the coordinates of the current point
are not changed. The execution of G92 results in an axis offset being
calculated and saved for each of the five axes, and the axis offsets
are always used when motion is specified with respect to absolute
distance mode using any of the nine coordinate systems (those designated
by G54 - G59.3). Thus all nine coordinate systems are affected by G92.

Being in incremental distance mode has no effect on the action of G92
in this implementation. [NCMS] is not explicit about this, but it is
implicit in the second sentence of [Fanuc, page 61].

The offset is the amount the origin must be moved so that the
coordinate of the controlled point has the specified value. For
example if the current point is at X=4 in the currently specified
coordinate system, then "G92 x7" causes the X-axis offset to be -3.

Since a non-zero offset may be already be in effect when the G92 is
called, that must be taken into account.

The action of G92.2 is described in [NCMS, page 12]. G92.2 resets axis
offsets to zero.

These offset values are saved in parameters 5211-5213, which were not
assigned in [NCMS] but look like reasonable places to put them.
*/

int convert_axis_offsets( /* ARGUMENT VALUES                                */
 int g_code,              /* g_code being executed (must be G_92 or G_92_2) */
 block_pointer block,     /* pointer to a block of RS274/NGC instructions   */
 setup_pointer settings)  /* pointer to machine settings                    */
{
  static char name[] SET_TO "convert_axis_offsets";

  if (settings->cutter_radius_compensation ISNT OFF) /* not "IS ON" */
    ERROR_MACRO(_interpreter_linetext, name, "Cannot change axis offsets with cutter radius comp");
  else if (g_code IS G_92)
    {
      if (block->x_flag IS ON)
        {
          settings->axis_offset_x SET_TO
            (settings->current_x + settings->axis_offset_x - block->x_number);
          settings->current_x SET_TO block->x_number;
        }

      if (block->y_flag IS ON)
        {
          settings->axis_offset_y SET_TO
            (settings->current_y + settings->axis_offset_y - block->y_number);
          settings->current_y SET_TO block->y_number;
        }

      if (block->z_flag IS ON)
        {
          settings->axis_offset_z SET_TO
            (settings->current_z + settings->axis_offset_z - block->z_number);
          settings->current_z SET_TO block->z_number;
        }

      SET_ORIGIN_OFFSETS(settings->origin_offset_x + settings->axis_offset_x,
                         settings->origin_offset_y + settings->axis_offset_y,
                         settings->origin_offset_z + settings->axis_offset_z);

      settings->parameters[5211] SET_TO settings->axis_offset_x;
      settings->parameters[5212] SET_TO settings->axis_offset_y;
      settings->parameters[5213] SET_TO settings->axis_offset_z;
    }
  else if (g_code IS G_92_2)
    {
      settings->current_x SET_TO
        settings->current_x + settings->axis_offset_x;
      settings->current_y SET_TO
        settings->current_y + settings->axis_offset_y;
      settings->current_z SET_TO
        settings->current_z + settings->axis_offset_z;
      SET_ORIGIN_OFFSETS(settings->origin_offset_x,
                         settings->origin_offset_y,
                         settings->origin_offset_z);
      settings->axis_offset_x SET_TO 0.0;
      settings->axis_offset_y SET_TO 0.0;
      settings->axis_offset_z SET_TO 0.0;

      settings->parameters[5211] SET_TO 0.0;
      settings->parameters[5212] SET_TO 0.0;
      settings->parameters[5213] SET_TO 0.0;
    }
  else
    BUG_MACRO(name, "Code is not G92 or G92.2 in convert_axis_offsets");

  return RS274NGC_OK;
}

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

/* convert_cutter_compensation_off

Returned Value: int (RS274NGC_OK)

Side effects:
   A comment is made that cutter radius compensation is turned off.
   The machine model of the cutter radius compensation mode is set to OFF.
   The value of program_x in the machine model is set to UNKNOWN.
     This serves as a flag when cutter radius compensation is
     turned on again.

Called by: convert_cutter_compensation

*/

int convert_cutter_compensation_off( /* ARGUMENT VALUES             */
 setup_pointer settings)             /* pointer to machine settings */
{
#ifdef DEBUG_EMC
  COMMENT("interpreter: cutter radius compensation off");
#endif
  settings->cutter_radius_compensation SET_TO OFF;
  settings->program_x SET_TO UNKNOWN;
  return RS274NGC_OK;
}

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

/* convert_cutter_compensation_on

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. The selected plane is not the XY plane.
   2. There is no D word in the block.
   3. Cutter radius compensation is already on.

Side effects:
   A COMMENT function call is made (conditionally) saying that the
   interpreter is switching mode so that cutter radius compensation is on.
   The value of cutter_radius_compensation in the machine model mode is
   set to RIGHT or LEFT. The currently active tool table index in
   the machine model is updated.

Called by: convert_cutter_compensation

check_other_codes checks that a d word occurs only in a block with g41 or g42.

Cutter radius compensation is carried out in the interpreter, so no
call is made to a canonical function (although there is a canonical
function, START_CUTTER_RADIUS_COMPENSATION, that could be called if
the primitive level could execute it).

*/

int convert_cutter_compensation_on( /* ARGUMENT VALUES                */
 int side,               /* side of path cutter is on (LEFT or RIGHT) */
 block_pointer block,    /* pointer to a block of RS274 instructions  */
 setup_pointer settings) /* pointer to machine settings               */
{
  static char name[] SET_TO "convert_cutter_compensation_on";

  if (settings->plane ISNT CANON_PLANE_XY)
    ERROR_MACRO(_interpreter_linetext, name, "Cannot turn cutter radius comp on out of XY-plane");
  if (block->d_number IS -1)
    ERROR_MACRO(_interpreter_linetext, name, "D word missing with cutter radius comp on");
  if (settings->cutter_radius_compensation ISNT OFF)
    ERROR_MACRO(_interpreter_linetext, name, "Cannot turn cutter radius comp on when already on");

#ifdef DEBUG_EMC
  if (side IS RIGHT)
    COMMENT("interpreter: cutter radius compensation on right");
  else
    COMMENT("interpreter: cutter radius compensation on left");
#endif

  /* radius is (settings->tool_table[block->d_number].diameter)/2.0) */
  settings->tool_table_index SET_TO block->d_number;
  settings->cutter_radius_compensation SET_TO side;
  return RS274NGC_OK;
}

/****************************************************************************/
/* convert_cycle

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. The r-value is not given the first time this code is called after
      some other motion mode has been in effect.
   2. The z-value is not given the first time this code is called after
      some other motion mode has been in effect.
   3. The r clearance plane is below the bottom_z.
   4. BUG - the distance mode is neither absolute or incremental.
   5. The l number is zero.
   6. G82, G86, G88, or G89 is called when it is not already in effect,
      and no p number is in the block.
   7. G83 is called when it is not already in effect,
      and no q number is in the block.
   8. G87 is called when it is not already in effect,
      and any of the i number, j number, or k number is missing.
   9. The distance mode setting is neither incremental nor absolute.
  10. BUG - the G code is not between G_81 and G_89.
  11. One of the specific cycle functions called returns RS274NGC_ERROR.

Side effects:
   A number of moves are made to execute the g-code

Called by: convert_motion

The function does not require that any of x,y,z, or r be specified in
the block, except that if the last motion mode command executed was
not the same as this one, the r-value and z-value must be specified.

This function is handling the repeat feature, wherein
the L word represents the number of repeats [NCMS, page 99]. We are
not allowing L=0, contrary to the manual. We are allowing L > 1
in absolute distance mode to mean "do the same thing in the same
place several times", as provided in the manual, although this seems
abnormal.

In incremental distance mode, x, y, and r values are treated as
increments to the current position and z as an increment from r.  In
absolute distance mode, x, y, r, and z are absolute. In g87, i and j
will always be increments, regardless of the distance mode setting, as
implied in [NCMS, page 98], but k (z-value of top of counterbore) will
be an absolute z-value in absolute distance mode, and an increment
(from bottom z) in incremental distance mode.

If the r position of a cycle is above the current_z position, this
retracts the z-axis to the r position before moving parallel to the
XY plane.

In the code for this function, there is a nearly identical "for" loop
in every case of the switch. The loop is the done with a compiler
macro, "CYCLE_MACRO" so that the code is easy to read, automatically
kept identical from case to case and, and much shorter than it would
be without the macro. The loop could be put outside the switch, but
then the switch would run every time around the loop, not just once,
as it does here. The loop could also be placed in the called
functions, but then it would not be clear that all the loops are the
same, and it would be hard to keep them the same when the code is
modified.  The macro would be very awkward as a regular function
because it would have to be passed all of the arguments used by any of
the specific cycles, and, if another switch in the function is to be
avoided, it would have to passed a function pointer, but the different
cycle functions have different arguments so the type of the pointer
could not be declared unless the cycle functions were re-written to
take the same arguments (in which case most of them would have several
unused arguments).

The motions within the CYCLE_MACRO (but outside a specific cycle) are
a straight traverse parallel to the XY-plane to the given xy-position
and a straight traverse of the z-axis only (if needed) to the r
position.

The height of the retract move at the end of each repeat of a cycle is
determined by the setting of the retract_mode: either to the r
position (if the retract_mode is R_PLANE) or to the original
z-position (if that is above the r position and the retract_mode is
not R_PLANE). This is a slight departure from [NCMS, page 98], which
does not require checking that the original z-position is above r.

*/

#define CYCLE_MACRO(call)                       \
for (repeat SET_TO block->l_number;             \
     repeat > 0;                                \
     repeat--)                                  \
{                                               \
  x SET_TO (x + x_increment);                   \
  y SET_TO (y + y_increment);                   \
  STRAIGHT_TRAVERSE(x, y, old_z);               \
  if (old_z ISNT r)                             \
    STRAIGHT_TRAVERSE(x, y, r);                 \
  if (call IS RS274NGC_ERROR)                   \
    ERROR_MACRO_PASS(name);                     \
  old_z SET_TO clear_z;                         \
}

int convert_cycle(       /* ARGUMENT VALUES                                */
 int motion,             /* a g-code between G_81 and G_89, a canned cycle */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions   */
 setup_pointer settings) /* pointer to machine settings                    */
{
  static char name[] SET_TO "convert_cycle";
  double x_increment;
  double y_increment;
  double i;
  double j;
  double k;
  double x;
  double y;
  double clear_z;
  double old_z;
  double z;
  double r;
  int repeat;
  CANON_MOTION_MODE save_mode;

  if (settings->motion_mode ISNT motion)
    {
      if (block->r_flag IS OFF)
        ERROR_MACRO(_interpreter_linetext, name, "R clearance plane unspecified in canned cycle");
      if (block->z_flag IS OFF)
        ERROR_MACRO(_interpreter_linetext, name, "Z value unspecified in canned cycle");
    }

  block->r_number SET_TO
    block->r_flag IS ON ? block->r_number : settings->cycle_r;
  block->z_number SET_TO
    block->z_flag IS ON ? block->z_number : settings->cycle_z;
  old_z SET_TO settings->current_z;

  if (settings->distance_mode IS MODE_ABSOLUTE)
    {
      x_increment SET_TO 0.0;
      y_increment SET_TO 0.0;
      r SET_TO block->r_number;
      z SET_TO block->z_number;
      x SET_TO block->x_flag IS ON ? block->x_number : settings->current_x;
      y SET_TO block->y_flag IS ON ? block->y_number : settings->current_y;
    }
  else if (settings->distance_mode IS MODE_INCREMENTAL)
    {
      x_increment SET_TO block->x_number;
      y_increment SET_TO block->y_number;
      r SET_TO (block->r_number + old_z);
      z SET_TO (r + block->z_number); /* [NCMS, page 98] */
      x SET_TO settings->current_x;
      y SET_TO settings->current_y;
    }
  else
    BUG_MACRO(name,
        "Distance mode is neither absolute nor incremental in convert_cycle");

  if (r < z)
    ERROR_MACRO(_interpreter_linetext, name, "R value less than Z value in canned cycle");

  if (block->l_number IS -1)
    block->l_number SET_TO 1;
  else if (block->l_number IS 0)
    ERROR_MACRO(_interpreter_linetext, name, "Cannot do zero repeats of cycle");

  if (old_z < r)
    {
      STRAIGHT_TRAVERSE(settings->current_x, settings->current_y, r);
      old_z SET_TO r;
    }
  clear_z SET_TO (settings->retract_mode IS R_PLANE) ? r : old_z;

  save_mode = GET_MOTION_CONTROL_MODE();
  if (save_mode ISNT CANON_EXACT_PATH)
    SET_MOTION_CONTROL_MODE(CANON_EXACT_PATH);

  switch(motion)
    {
    case G_81:
      CYCLE_MACRO(convert_cycle_g81(x, y, clear_z, z))
      break;
    case G_82:
      if ((settings->motion_mode ISNT G_82) AND (block->p_number IS -1.0))
        ERROR_MACRO(_interpreter_linetext, name, "P word (dwell time) missing with G82");
      block->p_number SET_TO
        block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
      CYCLE_MACRO(convert_cycle_g82 (x, y, clear_z, z, block->p_number))
      settings->cycle_p SET_TO block->p_number;
      break;
    case G_83:
      if ((settings->motion_mode ISNT G_83) AND (block->q_number IS -1.0))
        ERROR_MACRO(_interpreter_linetext, name, "Q word (depth increment) missing with G83");
      block->q_number SET_TO
        block->q_number IS -1.0 ? settings->cycle_q : block->q_number;
      CYCLE_MACRO(convert_cycle_g83 (x, y, r, clear_z, z, block->q_number))
      settings->cycle_q SET_TO block->q_number;
      break;
    case G_84:
      CYCLE_MACRO(convert_cycle_g84 (x, y, clear_z, z,
                      settings->spindle_turning, settings->speed_feed_mode))
      break;
    case G_85:
      CYCLE_MACRO(convert_cycle_g85 (x, y, clear_z, z))
      break;
    case G_86:
      if ((settings->motion_mode ISNT G_86) AND (block->p_number IS -1.0))
        ERROR_MACRO(_interpreter_linetext, name, "P word (dwell time) missing with G86");
      block->p_number SET_TO
        block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
      CYCLE_MACRO(convert_cycle_g86 (x, y, clear_z, z, block->p_number,
                                 settings->spindle_turning))
      settings->cycle_p SET_TO block->p_number;
      break;
    case G_87:
      if (settings->motion_mode ISNT G_87)
        {
          if (block->i_flag IS OFF)
            ERROR_MACRO(_interpreter_linetext, name, "I word missing with G87");
          if (block->j_flag IS OFF)
            ERROR_MACRO(_interpreter_linetext, name, "J word missing with G87");
          if (block->k_flag IS OFF)
            ERROR_MACRO(_interpreter_linetext, name, "K word missing with G87");
        }
      i SET_TO block->i_flag IS ON ? block->i_number : settings->cycle_i;
      j SET_TO block->j_flag IS ON ? block->j_number : settings->cycle_j;
      k SET_TO block->k_flag IS ON ? block->k_number : settings->cycle_k;
      settings->cycle_i SET_TO i;
      settings->cycle_j SET_TO j;
      settings->cycle_k SET_TO k;
      if (settings->distance_mode IS MODE_INCREMENTAL)
        {
          k SET_TO (z + k); /* k always absolute in function call below */
        }
      CYCLE_MACRO(convert_cycle_g87 (x, (x + i), y, (y + j), r, clear_z, k,
                                 z, settings->spindle_turning))
      break;
    case G_88:
      if ((settings->motion_mode ISNT G_88) AND (block->p_number IS -1.0))
        ERROR_MACRO(_interpreter_linetext, name, "P word (dwell time) missing with G88");
      block->p_number SET_TO
        block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
      CYCLE_MACRO(convert_cycle_g88 (x, y, z, block->p_number,
                                 settings->spindle_turning))
      settings->cycle_p SET_TO block->p_number;
      break;
    case G_89:
      if ((settings->motion_mode ISNT G_89) AND (block->p_number IS -1.0))
        ERROR_MACRO(_interpreter_linetext, name, "P word (dwell time) missing with G89");
      block->p_number SET_TO
        block->p_number IS -1.0 ? settings->cycle_p : block->p_number;
      CYCLE_MACRO(convert_cycle_g89 (x, y, clear_z, z, block->p_number))
      settings->cycle_p SET_TO block->p_number;
      break;
    default:
      BUG_MACRO(name, "Convert_cycle should not have been called");
    }
  settings->current_x SET_TO x;
  settings->current_y SET_TO y;
  settings->current_z SET_TO clear_z;
  settings->cycle_l SET_TO block->l_number;
  settings->cycle_r SET_TO block->r_number;
  settings->cycle_z SET_TO block->z_number;
  settings->motion_mode SET_TO motion;

  if (save_mode ISNT CANON_EXACT_PATH)
    SET_MOTION_CONTROL_MODE(save_mode);

  return RS274NGC_OK;
}

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

/* convert_probe

Returned Value: int
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. No value is given in the block for any of X, Y, or Z.

Side effects:
   This executes a straight_probe command.
   The probe_flag in the settings is set to ON.
   The motion mode in the settings is set to G_38_2.

Called by: convert_motion.

The approach to operating in incremental distance mode (g91) is to
put the the absolute position values into the block before using the
block to generate a move.

After probing is performed, the location of the probe cannot be
predicted.  This differs from every other command, all of which have
predictable results. The next call to the interpreter (with either
rs274ngc_read or rs274ngc_execute) will result in updating the
current position by a call to get_position. When running stand-alone
the get_position function just returns the current position. To
provide a reasonable value for get_position to return, in stand-alone
mode (only) this function sets the current position nine_tenths of the
way from the old current position to the programmed x, y, z point.

*/

int convert_probe(       /* ARGUMENT VALUES                          */
 block_pointer block,    /* pointer to a block of RS274 instructions */
 setup_pointer settings) /* pointer to machine settings              */
{
  static char name[] SET_TO "convert_probe";
  double end_x;
  double end_y;
  double end_z;

  if (((block->x_flag IS OFF) AND (block->y_flag IS OFF)) AND
      (block->z_flag IS OFF))
    ERROR_MACRO(_interpreter_linetext, name, "X, Y, and Z words all missing with G38.2");
  utility_find_ends(block, settings, &end_x, &end_y, &end_z);
  TURN_PROBE_ON();
  STRAIGHT_PROBE (end_x, end_y, end_z);
  TURN_PROBE_OFF();
  settings->motion_mode SET_TO G_38_2;
  settings->probe_flag SET_TO ON;
#ifdef STAND_ALONE_INTERP
  settings->current_x SET_TO ((0.9 * end_x) + (0.1 * settings->current_x));
  settings->current_y SET_TO ((0.9 * end_y) + (0.1 * settings->current_y));
  settings->current_z SET_TO ((0.9 * end_z) + (0.1 * settings->current_z));
#endif
  return RS274NGC_OK;
}

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

/* convert_setup

Returned Value: int (RS274NGC_OK)

Side effects:
   SET_ORIGIN_OFFSETS is called, and the coordinate values for the origin
   offsets in the settings are reset.
   If the coordinate system being changed is currently in use, the values
   of the the coordinates of the current point are updated.

Called by: convert_g.

This is called only if g10 is called. g10 may be used to alter the
second program coordinate system as described in [NCMS, pages 9 - 10].
All nine coordinate systems are implemented here.

Being in incremental distance mode has no effect on the action of G10
in this implementation. The manual is not explicit about what is
intended.

See documentation of convert_coordinate_systems for more information.

*/

int convert_setup(        /* ARGUMENT VALUES                              */
 block_pointer block,     /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings)  /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_setup";
  double x;
  double y;
  double z;
  double * parameters;
  int p_int;

  parameters SET_TO settings->parameters;
  p_int SET_TO (int)(block->p_number + 0.0001); /* p_number is a double */

  if (block->x_flag IS ON)
    {
      x SET_TO block->x_number;
      parameters[5201 + (p_int * 20)] SET_TO x;
    }
  else
    x SET_TO parameters[5201 + (p_int * 20)];

  if (block->y_flag IS ON)
    {
      y SET_TO block->y_number;
      parameters[5202 + (p_int * 20)] SET_TO y;
    }
  else
    y SET_TO parameters[5202 + (p_int * 20)];

  if (block->z_flag IS ON)
    {
      z SET_TO block->z_number;
      parameters[5203 + (p_int * 20)] SET_TO z;
    }
  else
   z SET_TO parameters[5203 + (p_int * 20)];

/* axis offsets could be included in the following calculations but
   do not need to be because the results do not change */
  if (p_int IS settings->origin_ngc) /* system is currently used */
    {
      settings->current_x SET_TO
        (settings->current_x + settings->origin_offset_x);
      settings->current_y SET_TO
        (settings->current_y + settings->origin_offset_y);
      settings->current_z SET_TO
        (settings->current_z + settings->origin_offset_z);

      settings->origin_offset_x SET_TO x;
      settings->origin_offset_y SET_TO y;
      settings->origin_offset_z SET_TO z;

      SET_ORIGIN_OFFSETS(x + settings->axis_offset_x,
                         y + settings->axis_offset_y,
                         z + settings->axis_offset_z);
      settings->current_x SET_TO (settings->current_x - x);
      settings->current_y SET_TO (settings->current_y - y);
      settings->current_z SET_TO (settings->current_z - z);
    }
#ifdef DEBUG_EMC
  else
    COMMENT("interpreter: setting coordinate system origin");
#endif
  return RS274NGC_OK;
}

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

/* convert_straight

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. x, y, and z are all missing from the block.
   2. convert_straight_comp1 or convert_straight_comp2 is called
      and returns RS274NGC_ERROR.
   3. A traverse (g0) move is called with cutter radius compensation on.
   4. BUG - The value of move is not G_0 or G_1.
   5. A straight feed (g1) move is called with feed rate set to 0.
   6. A straight feed (g1) move is called with cutter radius compensation
      on while inverse time feed is in effect.
   7. A straight feed (g1) move is called with inverse time feed in effect
      but no f word (feed time) is provided.
   8. A G1 move is called with G53 and cutter radius compensation on.

Side effects:
   This executes a straight move command at either traverse feed rate
   (if move is 0) or cutting feed rate (if move is 1). It also updates
   the setting of the position of the tool point to the end point of
   the move. If cutter radius compensation is on, it may also generate
   an arc before the straight move.

Called by: convert_motion.

The approach to operating in incremental distance mode (g91) is to
put the the absolute position values into the block before using the
block to generate a move.

*/

int convert_straight(    /* ARGUMENT VALUES                          */
 int move,               /* either G_0 (for g0) or G_1 (for g1)      */
 block_pointer block,    /* pointer to a block of RS274 instructions */
 setup_pointer settings) /* pointer to machine settings              */
{
  static char name[] SET_TO "convert_straight";
  double end_x = 0.0;
  double end_y = 0.0;
  double end_z = 0.0;
  double length;
  double rate;

  if (((block->x_flag IS OFF) AND (block->y_flag IS OFF)) AND
      (block->z_flag IS OFF))
    ERROR_MACRO(_interpreter_linetext, name, "X, Y, and Z words all missing with G0 or G1");

  settings->motion_mode SET_TO move;
  utility_find_ends(block, settings, &end_x, &end_y, &end_z);

  if (move IS G_0)
    {
      if (settings->cutter_radius_compensation ISNT OFF)
        ERROR_MACRO(_interpreter_linetext, name, "Cannot use G0 with cutter radius comp");
      STRAIGHT_TRAVERSE(end_x, end_y, end_z);
      settings->current_x SET_TO end_x;
      settings->current_y SET_TO end_y;
    }
  else if (move IS G_1)
    {
      if (settings->cutter_radius_compensation ISNT OFF) /* NOT "IS ON"! */
        {
          if (settings->feed_mode IS INVERSE_TIME)
            ERROR_MACRO(_interpreter_linetext, name,
                "Cannot use inverse time feed with cutter radius comp");
          else if (block->g_modes[4] IS G_53)
            ERROR_MACRO(_interpreter_linetext, name, "Cannot use G53 with cutter radius comp");
          else if (settings->feed_rate IS 0.0)
            ERROR_MACRO(_interpreter_linetext, name, "Cannot do G1 with zero feed rate");
          else if (settings->program_x IS UNKNOWN)
            {
              if (convert_straight_comp1(settings, end_x, end_y, end_z)
                  IS RS274NGC_ERROR)
                ERROR_MACRO_PASS(name);
            }
          else
            {
              if (convert_straight_comp2(settings, end_x, end_y, end_z)
                  IS RS274NGC_ERROR)
                ERROR_MACRO_PASS(name);
            }
        }
      else
        {
          if (settings->feed_mode IS INVERSE_TIME)
            {
              if (block->f_number IS -1.0)
                ERROR_MACRO(_interpreter_linetext, name,
                            "F word missing with inverse time G1 move");
              else
                {
                  length SET_TO utility_find_straight_length
                    (end_x, end_y, end_z,
                     settings->current_x, settings->current_y,
                     settings->current_z);
                  rate SET_TO MAX(0.1, (length * block->f_number));
                  SET_FEED_RATE (rate);
                  settings->feed_rate SET_TO rate;
                }
            }
          else if (settings->feed_rate IS 0.0)
            ERROR_MACRO(_interpreter_linetext, name, "Cannot do G1 with zero feed rate");
          STRAIGHT_FEED(end_x, end_y, end_z);
          settings->current_x SET_TO end_x;
          settings->current_y SET_TO end_y;
        }
    }
  else
    BUG_MACRO(name, "Code is not G0 or G1 in convert_straight");

  settings->current_z SET_TO end_z;
  return RS274NGC_OK;
}

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

/* read_comment

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   BUG - If the first character read is not '(' , this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.

Side effects:
   The counter is reset to point to the character following the comment.
   The comment string, without parentheses, is copied into the comment
   area of the block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character '(', indicating a comment is
beginning. The function reads characters of the comment, up to and
including the comment closer ')'.

It is expected that the format of a comment will have been checked (by
read_text or read_keyboard_line) and bad format comments will
have prevented the system from getting this far, so that this function
can assume a close parenthesis will be found when an open parenthesis
has been found, and that comments are not nested.

The "parameters" argument is not used in this function. That argument is
present only so that this will have the same argument list as the other
"read_XXX" functions called using a function pointer by read_one_item.

*/

int read_comment(     /* ARGUMENT VALUES                               */
 char * line,         /* string: line of RS274 code being processed    */
 int * counter,       /* pointer to a counter for position on the line */
 block_pointer block, /* pointer to a block being filled from the line */
 double * parameters) /* array of system parameters                    */
{
  static char name[] SET_TO "read_comment";
  int n;

  if (line[*counter] ISNT '(')
    BUG_MACRO(name, "Read_comment should not have been called");

  (*counter)++;
  for (n SET_TO 0; line[*counter] ISNT ')' ; (*counter)++, n++)
    {
      block->comment[n] SET_TO line[*counter];
    }
  block->comment[n] SET_TO 0;
  (*counter)++;
  return RS274NGC_OK;
}

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

/* read_d

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not d.
   2. A d_number has already been inserted in the block.
   3. The value cannot be read.
   4. The d_number is negative.

Side effects:
   counter is reset to the character following the tool number.
   A d_number is inserted in the block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'd', indicating an index into a
table of tool diameters.  The function reads characters which give the
(positive integer) value of the index.

read_integer_value allows a minus sign, so a check for a negative value
is needed here, and the parameters argument is also needed.

*/

int read_d(           /* ARGUMENT VALUES                               */
 char * line,         /* string: line of RS274 code being processed    */
 int * counter,       /* pointer to a counter for position on the line */
 block_pointer block, /* pointer to a block being filled from the line */
 double * parameters) /* array of system parameters                    */
{
  static char name[] SET_TO "read_d";
  int value;

  if (line[*counter] ISNT 'd')
    BUG_MACRO(name, "Read_d should not have been called");

  *counter SET_TO (*counter + 1);

  if (block->d_number > -1)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple D words on one line");
  else if (read_integer_value(line, counter, &value, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else if (value < 0)
    ERROR_MACRO(_interpreter_linetext, name, "Negative D code used");
  else
    {
      block->d_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_f

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not f.
   2. An f_number has already been inserted in the block.
   3. The f_number cannot be read.
   4. The f_number is negative.

Side effects:
   counter is reset to point to the first character following the f_number.
   The f_number is inserted in block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'f'. The function reads characters
which tell how to set the f_number, up to the start of the next item
or the end of the line. This information is inserted in the block.

The value may be a real number or something that evaluates to a
real number, so read_real_value is used to read it. Parameters
may be involved, so an extra argument is required. The value is always
a feed rate.

*/

int read_f(           /* ARGUMENT VALUES                               */
 char * line,         /* string: line of RS274 code being processed    */
 int * counter,       /* pointer to a counter for position on the line */
 block_pointer block, /* pointer to a block being filled from the line */
 double * parameters) /* array of system parameters                    */
{
  static char name[] SET_TO "read_f";
  double value;

  if (line[*counter] ISNT 'f')
    BUG_MACRO(name, "Read_f should not have been called");

  *counter SET_TO (*counter + 1);

  if (block->f_number > -1.0)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple F words on one line");
  else if (read_real_value(line, counter, &value, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else if (value < 0.0)
    ERROR_MACRO(_interpreter_linetext, name, "Negative F word found");
  else
    {
      block->f_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_g

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not g.
   2. The value cannot be read.
   3. The value is negative.
   4. The value differs from a number ending in an even tenth by more
      than 0.0001.
   5. Another g code from the same modal group has already been
      inserted in the block.

Side effects:
   counter is reset to the character following the end of the g_code.
   A g code is inserted as the value of the appropriate mode in the
   g_modes array in the block.
   The g code counter in the block is increased by 1.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'g', indicating a g_code.  The
function reads characters which tell how to set the g_code.

The manual [NCMS, page 51] allows g_codes to be represented
by expressions and provide [NCMS, 71 - 73] that a g_code must evaluate
to to a number of the form XX.X (59.1, for example). The manual does not
say how close an expression must come to one of the allowed values for
it to be legitimate. Is 59.099999 allowed to mean 59.1, for example?
In the interpreter, we adopt the convention that the evaluated number
for the g_code must be within 0.0001 of a value of the form XX.X

To simplify the handling of g_codes, we convert them to integers by
multiplying by 10 and rounding down or up if within 0.001 of an
integer. Other functions that deal with g_codes handle them
symbolically, however. The symbols are defined in rs274ngc.hh
where G_1 is 10, G_83 is 830, etc.

This allows any number g_codes on one line, provided that no two are
in the same modal group. The check_g_codes function checks that no
more than some maximum number of g_codes (currently 4) are on the same
line.

*/

int read_g(           /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274/NGC code being processed */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_g";
  double value_read;
  int value;
  int mode;

  if (line[*counter] ISNT 'g')
    BUG_MACRO(name, "Read_g should not have been called");

  *counter SET_TO (*counter + 1);
  if (read_real_value(line, counter, &value_read, parameters)
      IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  value_read SET_TO (10.0 * value_read);
  value SET_TO (int)floor(value_read);

  if ((value_read - value) > 0.999)
    value SET_TO (int)ceil(value_read);
  else if ((value_read - value) > 0.001)
    ERROR_MACRO(_interpreter_linetext, name,"G code out of range");

  if (value > 999)
    ERROR_MACRO(_interpreter_linetext, name, "G code out of range");
  else if (value < 0)
    ERROR_MACRO(_interpreter_linetext, name, "Negative G code used");

  mode SET_TO gees[value];

  if (mode IS -1)
    ERROR_MACRO(_interpreter_linetext, name, "Unknown G code used");
  else if (block->g_modes[mode] ISNT -1)
    ERROR_MACRO(_interpreter_linetext, name, "Two G codes used from same modal group");
  else
    {
      block->g_modes[mode] SET_TO value;
      block->g_count++;
      return RS274NGC_OK;
    }
}

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

/* read_i

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not i.
   2. A i_coordinate has already been inserted in the block.
   3. The value cannot be read.

Side effects:
   counter is reset.
   The i_flag in the block is turned on.
   A i_coordinate setting is inserted in the block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'i', indicating a i_coordinate
setting. The function reads characters which tell how to set the
coordinate, up to the start of the next item or the end of the line.
This information is inserted in the block. The counter is then set to
point to the character following.

The value may be a real number or something that evaluates to a
real number, so read_real_value is used to read it. Parameters
may be involved.

*/

int read_i(           /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274 code being processed     */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_i";
  double value;

  if (line[*counter] ISNT 'i')
    BUG_MACRO(name, "Read_i should not have been called");

  *counter SET_TO (*counter + 1);

  if (block->i_flag ISNT OFF)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple I words on one line");
  else if (read_real_value(line, counter, &value, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else
    {
      block->i_flag SET_TO ON;
      block->i_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_j

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not j.
   2. A j_coordinate has already been inserted in the block.
   3. The value cannot be read.

Side effects:
   counter is reset.
   The j_flag in the block is turned on.
   A j_coordinate setting is inserted in the block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'j', indicating a j_coordinate
setting. The function reads characters which tell how to set the
coordinate, up to the start of the next item or the end of the line.
This information is inserted in the block. The counter is then set to
point to the character following.

The value may be a real number or something that evaluates to a
real number, so read_real_value is used to read it. Parameters
may be involved.

*/

int read_j(           /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274 code being processed     */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_j";
  double value;

  if (line[*counter] ISNT 'j')
    BUG_MACRO(name, "Read_j should not have been called");

  *counter SET_TO (*counter + 1);

  if (block->j_flag ISNT OFF)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple J words on one line");
  else if (read_real_value(line, counter, &value, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else
    {
      block->j_flag SET_TO ON;
      block->j_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_k

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not k.
   2. A k_coordinate has already been inserted in the block.
   3. The value cannot be read.

Side effects:
   counter is reset.
   The k_flag in the block is turned on.
   A k_coordinate setting is inserted in the block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'k', indicating a k_coordinate
setting. The function reads characters which tell how to set the
coordinate, up to the start of the next item or the end of the line.
This information is inserted in the block. The counter is then set to
point to the character following.

The value may be a real number or something that evaluates to a
real number, so read_real_value is used to read it. Parameters
may be involved.

*/

int read_k(           /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274 code being processed     */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_k";
  double value;

  if (line[*counter] ISNT 'k')
    BUG_MACRO(name, "Read_k should not have been called");

  *counter SET_TO (*counter + 1);

  if (block->k_flag ISNT OFF)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple K words on one line");
  else if (read_real_value(line, counter, &value, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else
    {
      block->k_flag SET_TO ON;
      block->k_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_l

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - the first character read is not l
   2. the value cannot be read
   3. the value is negative
   4. there is already an l code in the block

Side effects:
   counter is reset to the character following the l number.
   An l code is inserted in the block as the value of l.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'l', indicating an L code.
The function reads characters which give the (integer) value of the
L code.

L codes are used for:
1. the number of times a canned cycle should be repeated.
2. a key with G10.

*/

int read_l(           /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274/NGC code being processed */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_l";
  int value;

  if (line[*counter] ISNT 'l')
    BUG_MACRO(name, "Read_l should not have been called");

  *counter SET_TO (*counter + 1);

  if (block->l_number > -1)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple L words on one line");
  else if (read_integer_value(line, counter, &value, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else if (value < 0)
    ERROR_MACRO(_interpreter_linetext, name, "Negative L word used");
  else
    {
      block->l_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_m

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not m.
   2. The value cannot be read.
   3. The value is negative.
   4. The value is greater than 99.
   5. The m code is not known to the system.
   6. Another m code in the same modal group has already been read.

Side effects:
   counter is reset to the character following the m number.
   An m code is inserted as the value of the appropriate mode in the
   m_modes array in the block.
   The m code counter in the block is increased by 1.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'm', indicating an m code.
The function reads characters which give the (integer) value of the
m code.

read_integer_value allows a minus sign, so a check for a negative value
is needed here, and the parameters argument is also needed.

*/

int read_m(           /* ARGUMENT VALUES                               */
 char * line,         /* string: line of RS274 code being processed    */
 int * counter,       /* pointer to a counter for position on the line */
 block_pointer block, /* pointer to a block being filled from the line */
 double * parameters) /* array of system parameters                    */
{
  static char name[] SET_TO "read_m";
  int value;
  int mode;

  if (line[*counter] ISNT 'm')
    BUG_MACRO(name, "Read_m should not have been called");

  *counter SET_TO (*counter + 1);

  if (read_integer_value(line, counter, &value, parameters) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else if (value < 0)
    ERROR_MACRO(_interpreter_linetext, name, "Negative M code used");
  else if (value > 99)
    ERROR_MACRO(_interpreter_linetext, name, "M code greater than 99");

  mode SET_TO ems[value];

  if (mode IS -1)
    ERROR_MACRO(_interpreter_linetext, name, "Unknown M code used");
  else if (block->m_modes[mode] ISNT -1)
    ERROR_MACRO(_interpreter_linetext, name, "Two M codes used from same modal group");
  else
    {
      block->m_modes[mode] SET_TO value;
      block->m_count++;
      return RS274NGC_OK;
    }
}

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

/* read_p

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not p.
   2. A p value has already been inserted in the block.
   3. The p value cannot be read.
   4. The p value is negative.

Side effects:
   counter is reset to point to the first character following the p value.
   The p value setting is inserted in block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'p', indicating a p value
setting. The function reads characters which tell how to set the p
value, up to the start of the next item or the end of the line. This
information is inserted in the block.

P codes are used for:
1. Dwell time with G4 dwell [NCMS, page 23].
2. Dwell time in canned cycles g82, G86, G88, G89 [NCMS pages 98 - 100].
3. A key with G10 [NCMS, pages 9, 10].

*/

int read_p(           /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274/NGC code being processed */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_p";
  double value;

  if (line[*counter] ISNT 'p')
    BUG_MACRO(name, "Read_p should not have been called");

  *counter SET_TO (*counter + 1);
  if (block->p_number > -1.0)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple P words on one line");
  else if (read_real_value(line, counter, &value, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else if (value < 0.0)
    ERROR_MACRO(_interpreter_linetext, name, "Negative P value used");
  else
    {
      block->p_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_parameter_setting

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not # .
   2. The characters immediately following do not evaluate to an integer.
   3. The parameter index is out of range.
   4. An equal sign does not follow the parameter expression.
   5. The value on the right side of the equal sign cannot be read.

Side effects:
   counter is reset to the character following the end of the parameter
   setting. The parameter whose index follows "#" is set to the
   real value following "=".

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character '#', indicating a parameter
setting.  The function reads characters which tell how to set the
parameter.

Any number of parameters may be set on a line, and parameters set
early on the line may be used in expressions later on the line.

Parameter setting is not clearly described in [NCMS, pp. 51 - 62]: it is
not clear if more than one parameter setting per line is allowed (any
number is OK in this implementation). The characters immediately following
the "#" must constitute a "parameter expression", but it is not clear
what that is. Here we allow any expression as long as it evaluates to
an integer.

Parameters are handled in the interpreter by having a parameter table as
part of the machine settings. The parameter table is passed to the
reading functions which need it. Reading functions may set parameter
values or use them.

The syntax recognized by this this function is # followed by an
integer expression (explicit integer or expression evaluating to an
integer) followed by = followed by a real value (number or
expression).

Note that # also starts a bunch of characters which represent a parameter
to be evaluated. That situation is handled by read_parameter.

*/

int read_parameter_setting(  /* ARGUMENT VALUES                         */
 char * line,         /* string: line of RS274/NGC code being processed */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_parameter_setting";
  int index;
  double value;

  if (line[*counter] ISNT '#')
    BUG_MACRO(name, "Read_parameter_setting should not have been called");
  *counter SET_TO (*counter + 1);
  if (read_integer_value(line, counter, &index, parameters) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else if ((index < 1) OR (index >= RS274NGC_MAX_PARAMETERS))
    ERROR_MACRO(_interpreter_linetext, name, "Parameter number out of range");
  else if (line[*counter] ISNT '=')
    ERROR_MACRO(_interpreter_linetext, name, "Equal sign missing in parameter setting");
  *counter SET_TO (*counter + 1);
  if (read_real_value(line, counter, &value, parameters) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else
    {
      parameters[index] SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_q

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not q.
   2. A q value has already been inserted in the block.
   3. The q value cannot be read.
   4. The q value is negative.

Side effects:
   counter is reset to point to the first character following the q value.
   The q value setting is inserted in block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'q', indicating a q value
setting. The function reads characters which tell how to set the q
value, up to the start of the next item or the end of the line. This
information is inserted in the block.

Q is used in the G87 canned cycle [NCMS, page 98].

*/

int read_q(           /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274/NGC code being processed */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_q";
  double value;

  if (line[*counter] ISNT 'q')
    BUG_MACRO(name, "Read_q should not have been called");

  *counter SET_TO (*counter + 1);
  if (block->q_number > -1.0)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple Q words on one line");
  else if (read_real_value(line, counter, &value, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else if (value < 0.0)
    ERROR_MACRO(_interpreter_linetext, name, "Negative Q value used");
  else
    {
      block->q_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_r

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not r.
   2. An r_number has already been inserted in the block.
   3. The value cannot be read.

Side effects:
   counter is reset.
   The r_flag in the block is turned on.
   The r_number is inserted in the block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'r'. The function reads characters
which tell how to set the coordinate, up to the start of the next item
or the end of the line. This information is inserted in the block. The
counter is then set to point to the character following.

An r number indicates the clearance plane in canned cycles.

An r number may also be the radius of an arc. The parameters argument
is needed.

*/

int read_r(           /* ARGUMENT VALUES                               */
 char * line,         /* string: line of RS274 code being processed    */
 int * counter,       /* pointer to a counter for position on the line */
 block_pointer block, /* pointer to a block being filled from the line */
 double * parameters) /* array of system parameters                    */
{
  static char name[] SET_TO "read_r";
  double value;

  if (line[*counter] ISNT 'r')
    BUG_MACRO(name, "Read_r should not have been called");

  *counter SET_TO (*counter + 1);

  if (block->r_flag ISNT OFF)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple R words on one line");
  else if (read_real_value(line, counter, &value, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else
    {
      block->r_flag SET_TO ON;
      block->r_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_spindle_speed

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not s.
   2. A spindle speed has already been inserted in the block.
   3. The spindle speed cannot be read.
   4. The spindle speed is negative.

Side effects:
   counter is reset to the character following the spindle speed.
   A spindle speed setting is inserted in the block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 's', indicating a spindle speed
setting. The function reads characters which tell how to set the spindle
speed.

The value may be a real number or something that evaluates to a
real number, so read_real_value is used to read it. Parameters
may be involved.

*/

int read_spindle_speed( /* ARGUMENT VALUES                               */
 char * line,           /* string: line of RS274 code being processed    */
 int * counter,         /* pointer to a counter for position on the line */
 block_pointer block,   /* pointer to a block being filled from the line */
 double * parameters)   /* array of system parameters                    */
{
  static char name[] SET_TO "read_spindle_speed";
  double speed;

  if (line[*counter] ISNT 's')
    BUG_MACRO(name, "Read_spindle_speed should not have been called");

  *counter SET_TO (*counter + 1);

  if (block->s_number > -1.0)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple S word spindle speed settings on one line");
  else if (read_real_value(line, counter, &speed, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else if (speed < 0.0)
    ERROR_MACRO(_interpreter_linetext, name, "Negative spindle speed found");
  else
    {
      block->s_number SET_TO speed;
      return RS274NGC_OK;
    }
}

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

/* read_tool

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not t.
   2. A t_number has already been inserted in the block.
   3. The value cannot be read.
   4. The tool number is negative.

Side effects:
   counter is reset to the character following the tool number.
   A t_number is inserted in the block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 't', indicating a tool.
The function reads characters which give the (integer) value of the
tool code.

*/

int read_tool(        /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274/NGC code being processed */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_tool";
  int value;

  if (line[*counter] ISNT 't')
    BUG_MACRO(name, "Read_tool should not have been called");

  *counter SET_TO (*counter + 1);
  if (block->t_number > -1)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple T words (tool ids) on one line");
  if (read_integer_value(line, counter, &value, parameters) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else if (value < 0)
    ERROR_MACRO(_interpreter_linetext, name, "Negative tool id used");
  else
    {
      block->t_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_tool_length_offset

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not h.
   2. An h_number has already been inserted in the block.
   3. The value cannot be read.
   4. The value is negative.

Side effects:
   counter is reset to the character following the tool length offset number.
   An h_number is inserted in the block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'h', indicating a tool length
offset.  The function reads characters which give the (integer) value
of the tool length offset code. This code is a reference to the
location of an offset in a table, not the actual distance of the
offset.

*/

int read_tool_length_offset(  /* ARGUMENT VALUES                        */
 char * line,         /* string: line of RS274/NGC code being processed */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_tool_length_offset";
  int value;

  if (line[*counter] ISNT 'h')
    BUG_MACRO(name, "Read_tool_length_offset should not have been called");

  *counter SET_TO (*counter + 1);
  if (block->h_number > -1)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple tool length offsets on one line");
  if (read_integer_value(line, counter, &value, parameters) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else if (value < 0)
    ERROR_MACRO(_interpreter_linetext, name, "Negative tool length offset used");
  else
    {
      block->h_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_x

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not x.
   2. A x_coordinate has already been inserted in the block.
   3. The value cannot be read.

Side effects:
   counter is reset.
   The x_flag in the block is turned on.
   A x_coordinate setting is inserted in the block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'x', indicating a x_coordinate
setting. The function reads characters which tell how to set the
coordinate, up to the start of the next item or the end of the line.
This information is inserted in the block. The counter is then set to
point to the character following.

The value may be a real number or something that evaluates to a
real number, so read_real_value is used to read it. Parameters
may be involved.

*/

int read_x(           /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274 code being processed     */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_x";
  double value;

  if (line[*counter] ISNT 'x')
    BUG_MACRO(name, "Read_x should not have been called");

  *counter SET_TO (*counter + 1);

  if (block->x_flag ISNT OFF)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple X words on one line");
  else if (read_real_value(line, counter, &value, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else
    {
      block->x_flag SET_TO ON;
      block->x_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_y

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not y.
   2. A y_coordinate has already been inserted in the block.
   3. The value cannot be read.

Side effects:
   counter is reset.
   The y_flag in the block is turned on.
   A y_coordinate setting is inserted in the block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'y', indicating a y_coordinate
setting. The function reads characters which tell how to set the
coordinate, up to the start of the next item or the end of the line.
This information is inserted in the block. The counter is then set to
point to the character following.

The value may be a real number or something that evaluates to a
real number, so read_real_value is used to read it. Parameters
may be involved.

*/

int read_y(           /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274 code being processed     */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_y";
  double value;

  if (line[*counter] ISNT 'y')
    BUG_MACRO(name, "Read_y should not have been called");

  *counter SET_TO (*counter + 1);

  if (block->y_flag ISNT OFF)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple Y words on one line");
  else if (read_real_value(line, counter, &value, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else
    {
      block->y_flag SET_TO ON;
      block->y_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_z

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - The first character read is not z.
   2. A z_coordinate has already been inserted in the block.
   3. The value cannot be read.

Side effects:
   counter is reset.
   The z_flag in the block is turned on.
   A z_coordinate setting is inserted in the block.

Called by: read_one_item

When this function is called, counter is pointing at an item on the
line that starts with the character 'z', indicating a z_coordinate
setting. The function reads characters which tell how to set the
coordinate, up to the start of the next item or the end of the line.
This information is inserted in the block. The counter is then set to
point to the character following.

The value may be a real number or something that evaluates to a
real number, so read_real_value is used to read it. Parameters
may be involved.

*/

int read_z(           /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274 code being processed     */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_z";
  double value;

  if (line[*counter] ISNT 'z')
    BUG_MACRO(name, "Read_z should not have been called");

  *counter SET_TO (*counter + 1);

  if (block->z_flag ISNT OFF)
    ERROR_MACRO(_interpreter_linetext, name, "Multiple Z words on one line");
  else if (read_real_value(line, counter, &value, parameters)
           IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else
    {
      block->z_flag SET_TO ON;
      block->z_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* check_g_codes

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. A g4 (dwell) is used with an axis word.
   2. A g4 is used without a P (dwell time) word.
   3. A g4 is used and a motion g_code (other than g80) is on same line.
   4. There are too many g codes in the block.
   5. g10 (which uses axis values) is used and a motion g_code (other
      than g80) is on the same line.
   6. A g10 is used and L2 is not in the block.
   7. A g10 is used and P is not close to an integer.
   8. A g10 is used and P is less than 1 or more than 9.
   9. A g53 is used with motion other than g0 or g1.
  10. A g53 is used in incremental distance mode.
  11. A g80 is used while g10 isn't used, and an axis value is given.
  12. All axis values are missing with g92.
  13. g92 (which uses axis values) is used and a motion g_code (other
      than g80) is on the same line.
  14. BUG - g_modes[0] is set to an unknown value.

Side effects: none

Called by: check_items

This runs checks on g_codes from a block of RS274/NGC instructions.

The read_g function checks for errors which would foul up the
reading. This function checks for additional logical errors in g_codes.

[NCMS] does not give any maximum for how many g_codes may be put on
the same line. The value of MAX_GEES (set in rs274ngc.hh) is currently
4.

We are suspending any implicit motion g_code when g4 or g10 is used.
The implicit motion g_code takes effect again automatically after the
line on which the g4 or g10 occurs.  It is not clear what the intent
of [NCMS] is in this regard. The alternative is to require that any
implicit motion be explicitly cancelled.

Not all checks on g_codes are included here. Those checks that are
sensitive to whether other g_codes on the same line have been executed
yet are made by the functions called by convert_g.

*/

int check_g_codes(       /* ARGUMENT VALUES                  */
 block_pointer block,    /* pointer to a block to be checked */
 setup_pointer settings) /* pointer to machine settings      */
{
  static char name[] SET_TO "check_g_codes";
  ON_OFF axis_flag;
  int explicit_motion;
  int mode0;
  int p_int;

  axis_flag SET_TO
    ((block->x_flag) OR (block->y_flag) OR (block->z_flag)) ? ON : OFF;
  explicit_motion SET_TO block->g_modes[1];
  mode0 SET_TO block->g_modes[0];

  if(block->g_count > MAX_GEES)
    ERROR_MACRO(_interpreter_linetext, name, "Too many G codes on line");

  if (mode0 IS -1)
    {
      if (block->g_modes[4] IS -1)
        {
          if ((block->motion_to_be IS G_80) AND (axis_flag IS ON))
            ERROR_MACRO(_interpreter_linetext, name,  "Cannot use axis commands with G80");
        }
      else if (block->g_modes[4] IS G_4)
        {
          if (((block->motion_to_be IS -1) OR
               (block->motion_to_be IS G_80)) AND
              (axis_flag IS ON))
            ERROR_MACRO(_interpreter_linetext, name, "Cannot use axis commands with G4");
          if(block->p_number IS -1.0)
            ERROR_MACRO(_interpreter_linetext, name, "Dwell time missing with G4");
        }
      else if (block->g_modes[4] IS G_53)
        {
          if ((block->motion_to_be ISNT G_0) AND
              (block->motion_to_be ISNT G_1))
            ERROR_MACRO(_interpreter_linetext, name, "Must use G0 or G1 with G53");
          if((block->g_modes[3] IS G_91) OR
             ((block->g_modes[3] ISNT G_90) AND
              (settings->distance_mode IS MODE_INCREMENTAL)))
            ERROR_MACRO(_interpreter_linetext, name, "Cannot use G53 in incremental distance mode");
        }
      else
        BUG_MACRO(name, "Bad setting of g_mode in check_g_codes");
    }
  else if (block->g_modes[4] ISNT -1)
    ERROR_MACRO(_interpreter_linetext, name, "Cannot use two G codes from group 0");
  else if (mode0 IS G_10)
    {
      p_int SET_TO (int)(block->p_number + 0.0001);
      if ((explicit_motion ISNT -1) AND (explicit_motion ISNT G_80))
        ERROR_MACRO(_interpreter_linetext, name, "Cannot use a G code for motion with G10");
      if (block->l_number ISNT 2)
        ERROR_MACRO(_interpreter_linetext, name, "Line with G10 does not have L2");
      if (((block->p_number + 0.0001) - p_int) > 0.0002)
        ERROR_MACRO(_interpreter_linetext, name, "P value not an integer with G10 L2");
      if ((p_int < 1) OR (p_int > 9))
        ERROR_MACRO(_interpreter_linetext, name, "P value out of range with G10 L2");
    }
  else if (mode0 IS G_92)
    {
      if ((explicit_motion ISNT -1) AND (explicit_motion ISNT G_80))
        ERROR_MACRO(_interpreter_linetext, name, "Cannot use a G motion with G92");
      if (axis_flag IS OFF)
        ERROR_MACRO(_interpreter_linetext, name, "All axes missing with G92");
    }
  else if (mode0 IS G_92_2)
    {}
  else
    BUG_MACRO(name, "Bad setting of g_mode in check_g_codes");

  return RS274NGC_OK;
}

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

/* check_m_codes

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. There are too many m codes in the block.

Side effects: none

Called by: check_items

This runs checks on m_codes from a block of RS274/NGC instructions.

The read_m function checks for errors which would foul up the
reading. This function checks for additional errors in m_codes.

*/

int check_m_codes(       /* ARGUMENT VALUES                  */
 block_pointer block,    /* pointer to a block to be checked */
 setup_pointer settings) /* pointer to machine settings      */
{
  static char name[] SET_TO "check_m_codes";

  if(block->m_count > MAX_EMS)
    ERROR_MACRO(_interpreter_linetext, name, "Too many M codes on line");

  return RS274NGC_OK;
}

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

/* check_other_codes

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. A d word is in a block with no cutter_radius_compensation_on command.
   2. An h_number is in a block with no tool length offset setting.
   3. An i_number is in a block with no G code that uses it.
   4. A j_number is in a block with no G code that uses it.
   5. A k_number is in a block with no G code that uses it.
   6. A l_number is in a block with no G code that uses it.
   7. A p_number is in a block with no G code that uses it.
   8. A q_number is in a block with no G code that uses it.
   9. An r_number is in a block with no G code that uses it.

Side effects: none

Called by: check_items

This runs checks on codes from a block of RS274/NGC code which are
not m or g codes.

The functions named read_XXXX check for errors which would foul up the
reading. This function checks for additional logical errors in codes.

*/

int check_other_codes(   /* ARGUMENT VALUES                              */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings) /* pointer to machine settings                  */
{
  static char name[] SET_TO "check_other_codes";
  int motion;

  motion SET_TO block->motion_to_be;
  if (block->d_number ISNT -1)
    {
      if ((block->g_modes[7] ISNT G_41) AND (block->g_modes[7] ISNT G_42))
        ERROR_MACRO(_interpreter_linetext, name,
           "D word on line with no cutter comp on (G41 or G42) command");
    }
  if (block->h_number ISNT -1)
    {
      if (block->g_modes[8] ISNT G_43)
        ERROR_MACRO(_interpreter_linetext, name,
          "H word on line with no tool length comp (G43) command");
    }

  if (block->i_flag IS ON) /* could still be useless if yz_plane arc */
    {
      if (((motion ISNT G_2) AND (motion ISNT G_3)) AND (motion ISNT G_87))
        ERROR_MACRO(_interpreter_linetext, name,
          "I word on line with no G code (G2, G3, G87) that uses it");
    }


  if (block->j_flag IS ON) /* could still be useless if xz_plane arc */
    {
      if (((motion ISNT G_2) AND (motion ISNT G_3)) AND (motion ISNT G_87))
        ERROR_MACRO(_interpreter_linetext, name,
          "J word on line with no G code (G2, G3, G87) that uses it");
    }

  if (block->k_flag IS ON) /* could still be useless if xy_plane arc */
    {
      if (((motion ISNT G_2) AND (motion ISNT G_3)) AND (motion ISNT G_87))
        ERROR_MACRO(_interpreter_linetext, name,
          "K word on line with no G code (G2, G3, G87) that uses it");
    }

  if (block->l_number ISNT -1)
    {
      if (((motion < G_81) OR (motion > G_89)) AND
          (block->g_modes[0] ISNT G_10))
        ERROR_MACRO(_interpreter_linetext, name,
                    "L word on line with no canned cycle or G10 to use it");
    }

  if (block->p_number ISNT -1.0)
    {
      if (((block->g_modes[0] ISNT G_10) AND
           (block->g_modes[4] ISNT G_4)) AND
          (((motion ISNT G_82) AND (motion ISNT G_86)) AND
           ((motion ISNT G_88) AND (motion ISNT G_89))))
        ERROR_MACRO(_interpreter_linetext, name,
      "P word on line with no G code (G4 G10 G82 G86 G88 G89) that uses it");
    }

  if (block->q_number ISNT -1.0)
    {
      if (motion ISNT G_83)
        ERROR_MACRO(_interpreter_linetext, name, "Q word on line with no G83 cycle that uses it");
    }

  if (block->r_flag IS ON)
    {
      if (((motion ISNT G_2) AND (motion ISNT G_3)) AND
          ((motion < G_81) OR (motion > G_89)))
        ERROR_MACRO(_interpreter_linetext, name,
          "R word on line with no G code (arc or cycle) that uses it");
    }

  return RS274NGC_OK;
}

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

/* convert_control_mode

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
  BUG - If g_code isn't G_61 or G_64, this returns RS274NGC_ERROR.
  Otherwise, it returns RS274NGC_OK.

Side effects:
  The interpreter switches the machine settings to indicate the current
  control mode (CANON_EXACT_PATH or CANON_CONTINUOUS).

  The call SET_MOTION_CONTROL_MODE(CANON_CONTINUOUS) is made if
  the G code is G_64. The call SET_MOTION_CONTROL_MODE(CANON_EXACT_PATH)
  is made if the G code is G_61.

  We could, alternatively, set the control mode to CANON_EXACT_STOP
  on G_61, and that would correspond more closely to the meaning as
  given in [NCMS, page 40], but CANON_EXACT_PATH has the advantage
  that the tool does not stop if it does not have to, and no evident
  disadvantage compared to CANON_EXACT_STOP, so it is being used.

Called by: convert_g.

It is OK to call G_61 when G_61 is already in force, and similarly for
G_64.

*/

int convert_control_mode( /* ARGUMENT VALUES                               */
 int g_code,               /* g_code being executed (must be G_61 or G_64) */
 block_pointer block,      /* pointer to a block of RS274 instructions     */
 setup_pointer settings)   /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_control_mode";
  if (g_code IS G_61)
    {
      SET_MOTION_CONTROL_MODE(CANON_EXACT_PATH);
      settings->control_mode SET_TO CANON_EXACT_PATH;
    }
  else if (g_code IS G_64)
    {
      SET_MOTION_CONTROL_MODE(CANON_CONTINUOUS);
      settings->control_mode SET_TO CANON_CONTINUOUS;
    }
  else
    BUG_MACRO(name, "Code is not G61 or G64 in convert_control_mode");
  return RS274NGC_OK;
}

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

/* convert_coordinate_system

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occurs, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. The value of the g_code argument is not 540, 550, 560, 570, 580,
      590, 591, 592, or 593

Side effects:
   If the NGC coordinate system selected by the g_code is not already in
   use, the canonical program coordinate system axis offset values are
   reset and the coordinate values of the current point are reset, and
   a call is made to SET_ORIGIN_OFFSETS.

Called by: convert_g.

COORDINATE SYSTEMS (involves g10, g54, g54 - g59.3, g92)

The canonical machining functions view of coordinate systems is:
1. There are two coordinate systems: absolute and program.
2. All coordinate values are given in terms of the program coordinate system.
3. The offsets of the program coordinate system may be reset.

The RS274/NGC view of coordinate systems, as given in section 3.2
of the manual [NCMS] is:
1. there are ten coordinate systems: absolute and 9 program. The
   program coordinate systems are numbered 1 to 9.
2. you can switch among the 9 but not to the absolute one. G54
   selects coordinate system 1, G55 selects 2, and so on through
   G56, G57, G58, G59, G59.1, G59.2, and G59.3.
3. you can set the offsets of the 9 program coordinate systems
   using G10 L2 Pn (n is the number of the coordinate system) with
   values for the axes in terms of the absolute coordinate system.
4. the first one of the 9 program coordinate systems is the default.
5. data for coordinate systems is stored in parameters [NCMS, pages 59 - 60].
6. g53 means to interpret coordinate values in terms of the absolute
   coordinate system for the one block in which g53 appears.
7. You can offset the current coordinate system using g92. This offset
   will then apply to all nine program coordinate systems.

The approach used in the interpreter mates the two views
of coordinate systems as follows:

During initialization, data from the parameters for the first NGC
coordinate system is used in a SET_ORIGIN_OFFSETS function call and
origin_ngc in the machine model is set to 1.

If a g_code in the range g54 - g59.3 is encountered in an NC program,
the data from the appropriate NGC coordinate system is copied into the
origin offsets used by the interpreter, a SET_ORIGIN_OFFSETS function
call is made, and the current position is reset.

If a g10 is encountered, the convert_setup function is called to reset
the offsets of the program coordinate system indicated by the P number
given in the same block.

If a g53 is encountered, the axis values given in that block are used
to calculate what the coordinates are of that point in the current
coordinate system, and a STRAIGHT_TRAVERSE or STRAIGHT_FEED function
call to that point using the calculated values is made. No offset
values are changed.

If a g92 is encountered, that is handled by the convert_axis_offsets
function. A g92 results in an axis offset for each axis being calculated
and stored in the machine model. The axis offsets are applied to all
nine coordinate systems. Axis offsets are initialized to zero.

*/

int convert_coordinate_system( /* ARGUMENT VALUES                         */
 int g_code,              /* g_code called (must be one listed above)     */
 block_pointer block,     /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings)  /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_coordinate_system";
  int origin;
  double x;
  double y;
  double z;
  double * parameters;

  parameters SET_TO settings->parameters;
  switch(g_code)
    {
    case 540:
      origin SET_TO 1;
      break;
    case 550:
      origin SET_TO 2;
      break;
    case 560:
      origin SET_TO 3;
      break;
    case 570:
      origin SET_TO 4;
      break;
    case 580:
      origin SET_TO 5;
      break;
    case 590:
      origin SET_TO 6;
      break;
    case 591:
      origin SET_TO 7;
      break;
    case 592:
      origin SET_TO 8;
      break;
    case 593:
      origin SET_TO 9;
      break;
    default:
      BUG_MACRO(name, "Code is not G54 to G59.3 in convert_coordinate_system");
    }

  if (origin IS settings->origin_ngc) /* already using this origin */
    {
#ifdef DEBUG_EMC
      COMMENT("interpreter: continuing to use same coordinate system");
#endif
      return RS274NGC_OK;
    }

/* axis offsets could be included in the following calculcations
but do not need to be because they would not change the result. */
  settings->current_x SET_TO
    (settings->current_x + settings->origin_offset_x);
  settings->current_y SET_TO
    (settings->current_y + settings->origin_offset_y);
  settings->current_z SET_TO
    (settings->current_z + settings->origin_offset_z);

  x SET_TO parameters[5201 + (origin * 20)];
  y SET_TO parameters[5202 + (origin * 20)];
  z SET_TO parameters[5203 + (origin * 20)];

  settings->origin_offset_x SET_TO x;
  settings->origin_offset_y SET_TO y;
  settings->origin_offset_z SET_TO z;

  settings->current_x SET_TO (settings->current_x - x);
  settings->current_y SET_TO (settings->current_y - y);
  settings->current_z SET_TO (settings->current_z - z);
  settings->origin_ngc SET_TO origin;

  SET_ORIGIN_OFFSETS(x + settings->axis_offset_x,
                     y + settings->axis_offset_y,
                     z + settings->axis_offset_z);

  return RS274NGC_OK;
}

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

/* convert_cutter_compensation

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. convert_cutter_compensation_on or convert_cutter_compensation_off
      is called and returns RS274NGC_ERROR.
   2. BUG - g_code is not G_40, G_41, or G_42.

Side effects:
   The value of cutter_radius_compensation in the machine model mode is
   set to RIGHT, LEFT, or OFF. The currently active tool table index in
   the machine model is updated.

Since cutter radius compensation is performed in the interpreter, no
call is made to any canonical function regarding cutter radius compensation.

Called by: convert_g

*/

int convert_cutter_compensation(  /* ARGUMENT VALUES                  */
 int g_code,              /* must be G_40, G_41, or G_42              */
 block_pointer block,     /* pointer to a block of RS274 instructions */
 setup_pointer settings)  /* pointer to machine settings              */
{
  static char name[] SET_TO "convert_cutter_compensation";
  if (g_code IS G_40)
    {
      if (convert_cutter_compensation_off(settings) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  else if (g_code IS G_41)
    {
      if (convert_cutter_compensation_on(LEFT, block, settings)
          IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  else if (g_code IS G_42)
    {
      if (convert_cutter_compensation_on(RIGHT, block, settings)
          IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  else
    BUG_MACRO(name,
              "Code is not G40, G41, or G42 in convert_cutter_compensation");

  return RS274NGC_OK;
}
/****************************************************************************/
/* convert_distance_mode

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   BUG - If g_code isn't G_90 or G_91, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.

Side effects:
   The interpreter switches the machine settings to indicate the current
   distance mode (absolute or incremental).

   The canonical machine to which commands are being sent does not have
   an incremental mode, so no command setting the distance mode is
   generated in this function. A comment function call explaining the
   change of mode is made (conditionally), however, if there is a change.

Called by: convert_g.

*/

int convert_distance_mode( /* ARGUMENT VALUES                              */
 int g_code,               /* g_code being executed (must be G_90 or G_91) */
 block_pointer block,      /* pointer to a block of RS274 instructions     */
 setup_pointer settings)   /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_distance_mode";
  if (g_code IS G_90)
    {
      if (settings->distance_mode ISNT MODE_ABSOLUTE)
        {
#ifdef DEBUG_EMC
          COMMENT("interpreter: distance mode changed to absolute");
#endif
          settings->distance_mode SET_TO MODE_ABSOLUTE;
        }
    }
  else if (g_code IS G_91)
    {
      if (settings->distance_mode ISNT MODE_INCREMENTAL)
        {
#ifdef DEBUG_EMC
          COMMENT("interpreter: distance mode changed to incremental");
#endif
          settings->distance_mode SET_TO MODE_INCREMENTAL;
        }
    }
  else
    BUG_MACRO(name, "Code is not G90 or G91 in convert_distance_mode");
  return RS274NGC_OK;
}

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

/* convert_dwell

Returned Value: int (RS274NGC_OK)

Side effects:
   A dwell command is executed.

Called by: convert_g.

*/

int convert_dwell( /* ARGUMENT VALUES           */
 double time)      /* time in seconds to dwell  */
{
  DWELL(time);
  return RS274NGC_OK;
}

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

/* convert_length_units

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)

   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. Bug - The g_code argument isnt G_20 or G_21.
   2. Cutter radius compensation is on.

Side effects:
   A command setting the length units is executed. The machine
   settings are reset regarding length units and current position.

Called by: convert_g.

We are not changing tool length offset values or tool diameter values.
Those values must be given in the table in the correct units. Thus it
will generally not be feasible to switch units in the middle of a
program.

We are not changing the parameters that represent the positions
of the nine work coordinate systems.

We are also not changing feed rate values when length units are
changed, so the actual behavior may change.

Several other distance items in the settings (such as the various
parameters for cycles) are also not reset.

We are changing origin offset and axis offset values, which are
critical. If this were not done, when length units are set and the new
length units are not the same as the default length units
(millimeters), and any XYZ origin or axis offset is not zero, then any
subsequent change in XYZ origin or axis offset values will be
incorrect.  Also, g53 (motion in absolute coordinates) will not work
correctly.

*/

int convert_length_units( /* ARGUMENT VALUES                              */
 int g_code,              /* g_code being executed (must be G_20 or G_21) */
 setup_pointer settings)  /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_length_units";
  if (settings->cutter_radius_compensation ISNT OFF)
    ERROR_MACRO(_interpreter_linetext, name, "Cannot change units with cutter radius comp");
  else if (g_code IS G_20)
    {
      USE_LENGTH_UNITS(CANON_UNITS_INCHES);
      if (settings->length_units ISNT CANON_UNITS_INCHES)
        {
          settings->length_units SET_TO CANON_UNITS_INCHES;
          settings->current_x SET_TO (settings->current_x * INCH_PER_MM);
          settings->current_y SET_TO (settings->current_y * INCH_PER_MM);
          settings->current_z SET_TO (settings->current_z * INCH_PER_MM);
          settings->axis_offset_x SET_TO
            (settings->axis_offset_x * INCH_PER_MM);
          settings->axis_offset_y SET_TO
            (settings->axis_offset_y * INCH_PER_MM);
          settings->axis_offset_z SET_TO
            (settings->axis_offset_z * INCH_PER_MM);
          settings->origin_offset_x SET_TO
            (settings->origin_offset_x * INCH_PER_MM);
          settings->origin_offset_y SET_TO
            (settings->origin_offset_y * INCH_PER_MM);
          settings->origin_offset_z SET_TO
            (settings->origin_offset_z * INCH_PER_MM);
        }
    }
  else if (g_code IS G_21)
    {
      USE_LENGTH_UNITS(CANON_UNITS_MM);
      if (settings->length_units ISNT CANON_UNITS_MM)
        {
          settings->length_units SET_TO CANON_UNITS_MM;
          settings->current_x SET_TO (settings->current_x * MM_PER_INCH);
          settings->current_y SET_TO (settings->current_y * MM_PER_INCH);
          settings->current_z SET_TO (settings->current_z * MM_PER_INCH);
          settings->axis_offset_x SET_TO
            (settings->axis_offset_x * MM_PER_INCH);
          settings->axis_offset_y SET_TO
            (settings->axis_offset_y * MM_PER_INCH);
          settings->axis_offset_z SET_TO
            (settings->axis_offset_z * MM_PER_INCH);
          settings->origin_offset_x SET_TO
            (settings->origin_offset_x * MM_PER_INCH);
          settings->origin_offset_y SET_TO
            (settings->origin_offset_y * MM_PER_INCH);
          settings->origin_offset_z SET_TO
            (settings->origin_offset_z * MM_PER_INCH);
        }
    }
  else
    BUG_MACRO(name, "Code is not G20 or G21 in convert_length_units");
  return RS274NGC_OK;
}

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

/* convert_modal_0

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. code is not G_10, G_92, or G92.2
   2. One of the following functions is called and returns an error.
      convert_axis_offsets
      convert_setup

Side effects:
   A g_code in g modal group 0 is executed (g10, g92, or g92.2)

Called by: convert_g.

*/

int convert_modal_0(     /* ARGUMENT VALUES                              */
 int code,               /* G code, must be G_10, G_92, or G_92_2        */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings) /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_modal_0";

  if (code IS G_10)
    {
      if (convert_setup(block, settings) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  else if ((code IS G_92) OR (code IS G_92_2))
    {
      if (convert_axis_offsets(code, block, settings) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  else
    BUG_MACRO(name, "Code is not G10, G92, or G92.2 in convert_modal_0");
  return RS274NGC_OK;
}

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

/* convert_motion

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. One of the following functions is called and returns RS274NGC_ERROR
      convert_arc
      convert_cycle
      convert_straight
   2. BUG - The motion code is not 0,1,2,3,80,81,82,83,84,85,86,87,88, or 89.
   3. An x, y, or z coordinate value is given with g80.
   4. Inverse time feed mode is on and no feed setting is in the block.
   5. A probe move (G38.2) is called in inverse time feed mode.
   6. A probe move is called with cutter radius compensation on.
   7. A probe move is called with zero feed rate.

Side effects:
   A g_code from the group causing motion (mode 1) is executed.

Called by: convert_g.

Error number 3 above does not prevent the use of coordinate offsets in
a block where the implicit motion mode is G80 because convert motion
will not be called in this case (because the motion_mode will be -1).

*/

int convert_motion(      /* ARGUMENT VALUES                           */
 int motion,             /* g_code for a line, arc, canned cycle      */
 block_pointer block,    /* pointer to a block of RS274 instructions  */
 setup_pointer settings) /* pointer to machine settings               */
{
  static char name[] SET_TO "convert_motion";

  if ((motion IS G_0) OR (motion IS G_1))
    {
      if (convert_straight (motion, block, settings) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  else if ((motion IS G_3) OR (motion IS G_2))
    {
      if ((settings->feed_mode IS INVERSE_TIME) AND
          (block->f_number IS -1.0))
        ERROR_MACRO(_interpreter_linetext, name, "F word missing with inverse time arc move");
      if (convert_arc (motion, block, settings) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  else if (motion IS G_38_2)
    {
      if (settings->feed_mode IS INVERSE_TIME)
        ERROR_MACRO(_interpreter_linetext, name, "Cannot probe in inverse time feed mode");
      if (settings->cutter_radius_compensation ISNT OFF) /* NOT "IS ON"! */
        ERROR_MACRO(_interpreter_linetext, name, "Cannot probe with cutter radius compensation on");
      if (settings->feed_rate IS 0.0)
        ERROR_MACRO(_interpreter_linetext, name, "Cannot probe with zero feed rate");
      if (convert_probe (block, settings) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  else if (motion IS G_80)
    {
      if((block->x_flag) OR (block->y_flag) OR (block->z_flag))
        ERROR_MACRO(_interpreter_linetext, name, "Coordinate setting given with G80");
      else
        {
#ifdef DEBUG_EMC
          COMMENT("interpreter: motion mode set to none");
#endif
          settings->motion_mode SET_TO G_80;
        }
    }
  else if ((motion > G_80) AND (motion < G_90))
    {
     if (convert_cycle(motion, block, settings) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  else
    BUG_MACRO(name, "Code is not G0 to G3 or G80 to G89 in convert_motion");

  return RS274NGC_OK;
}

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

/* convert_retract_mode

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. BUG - g_code isn't G_98 or G_99.

Side effects:
   The interpreter switches the machine settings to indicate the current
   retract mode for canned cycles (OLD_Z or R_PLANE).

Called by: convert_g.

The canonical machine to which commands are being sent does not have a
retract mode, so no command setting the retract mode is generated in
this function.

*/

int convert_retract_mode( /* ARGUMENT VALUES                              */
 int g_code,              /* g_code being executed (must be G_98 or G_99) */
 block_pointer block,     /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings)  /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_retract_mode";
  if (g_code IS G_98)
    {
#ifdef DEBUG_EMC
      COMMENT("interpreter: retract mode set to old_z");
#endif
      settings->retract_mode SET_TO OLD_Z;
    }
  else if (g_code IS G_99)
    {
#ifdef DEBUG_EMC
      COMMENT("interpreter: retract mode set to r_plane");
#endif
      settings->retract_mode SET_TO R_PLANE;
    }
  else
    BUG_MACRO(name, "Code is not G98 or G99 in convert_retract_mode");
  return RS274NGC_OK;
}

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

/* convert_set_plane

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. G_18 or G_19 is called when cutter radius compensation is on.
   2. BUG - The g_code is not G_17, G_18, or G_19,

Side effects:
   A command setting the current plane is executed.

Called by: convert_g.

*/

int convert_set_plane(    /* ARGUMENT VALUES                          */
 int g_code,              /* must be G_17, G_18, or G_19              */
 block_pointer block,     /* pointer to a block of RS274 instructions */
 setup_pointer settings)  /* pointer to machine settings              */
{
  static char name[] SET_TO "convert_set_plane";
  if (g_code IS G_17)
    {
      SELECT_PLANE(CANON_PLANE_XY);
      settings->plane SET_TO CANON_PLANE_XY;
    }
  else if (g_code IS G_18)
    {
      if (settings->cutter_radius_compensation ISNT OFF)
        ERROR_MACRO(_interpreter_linetext, name, "Cannot use XZ plane with cutter radius comp");
      SELECT_PLANE(CANON_PLANE_XZ);
      settings->plane SET_TO CANON_PLANE_XZ;
    }
  else if (g_code IS G_19)
    {
      if (settings->cutter_radius_compensation ISNT OFF)
        ERROR_MACRO(_interpreter_linetext, name, "Cannot use YZ plane with cutter radius comp");
      SELECT_PLANE(CANON_PLANE_YZ);
      settings->plane SET_TO CANON_PLANE_YZ;
    }
  else
    BUG_MACRO(name, "Code is not G17, G18, or G19 in convert_set_plane");
  return RS274NGC_OK;
}

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

/* convert_tool_change

Returned Value: int (RS274NGC_OK)

Side effects:
   This makes function calls to primitive machining functions, and sets
   the machine model as described below.

Called by: convert_m

This function carries out an m6 command, which changes the tool in the
spindle. The only function call this makes is to the CHANGE_TOOL
function. The semantics of this function call is that when it is
completely carried out, the tool that was selected is in the spindle,
the tool that was in the spindle (if any) is returned to its changer
slot, the spindle will be stopped (but the spindle speed setting will
not have changed) and the x, y, z, and b positions will be the same
as they were before (although they may have moved around during the
change).

It would be nice to add more flexibility to this function by allowing
more changes to occur (position changes, for example) as a result of
the tool change. There are at least two ways of doing this:

1. Require that certain machine settings always have a given fixed
value after a tool change (which may be different from what the value
was before the change), and record the fixed values somewhere (in the
world model that is read at initialization, perhaps) so that this
function can retrieve them and reset any settings that have changed.
Fixed values could even be hard coded in this function.

2. Allow the executor of the CHANGE_TOOL function to change the state
of the world however it pleases, and have the interpreter read the
executor's world model after the CHANGE_TOOL function is carried out.
Implementing this would require a change in other parts of the EMC
system, since calls to the interpreter would then have to be
interleaved with execution of the function calls output by the
interpreter.

There may be other commands in the block that includes the tool change.
They will be executed in the order described in execute_block.

This implements the "Next tool in T word" approach to tool selection.
The tool is selected when the T word is read (and the carousel may
move at that time) but is changed when M6 is read.

Note that if a different tool is put into the spindle, the current_z
location setting may be incorrect for a time. It is assumed the
program will contain an appropriate USE_TOOL_LENGTH_OFFSET command
near the CHANGE_TOOL command, so that the incorrect setting is only
temporary.

In [NCMS, page 73, 74] there are three other legal approaches in addition
to this one.

*/

int convert_tool_change(  /* ARGUMENT VALUES                             */
 block_pointer block,     /* pointer to a block of RS274NGC instructions */
 setup_pointer settings)  /* pointer to machine settings                 */
{
  static char name[] SET_TO "convert_tool_change";

  CHANGE_TOOL(settings->selected_tool_slot);
  settings->current_slot SET_TO settings->selected_tool_slot;
  settings->spindle_turning SET_TO CANON_STOPPED;

  return RS274NGC_OK;
}

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

/* convert_tool_length_offset

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. The block has no offset index (h number).
   2. The h number is bigger than the largest table index.
   3. BUG - The g_code argument is not G_43 or G_49.

Side effects:
   A USE_TOOL_LENGTH_OFFSET function call is made. Current_z,
   tool_length_offset, and length_offset_index are reset.

Called by: convert_g

This is called to execute g43 or g49.

The g49 RS274/NGC command translates into a USE_TOOL_LENGTH_OFFSET(0.0)
function call.

The g43 RS274/NGC command translates into a USE_TOOL_LENGTH_OFFSET(length)
function call, where length is the value of the entry in the tool length
offset table whose index is the H number in the block.

The H number in the block (if present) was checked for being a
positive integer when it was read, so it that check does not need to
be repeated.

*/

int convert_tool_length_offset( /* ARGUMENT VALUES                       */
 int g_code,             /* g_code being executed (must be G_43 or G_49) */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings) /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_tool_length_offset";
  int index;
  double offset;

  if (g_code IS G_49)
    {
      USE_TOOL_LENGTH_OFFSET(0.0);
      settings->current_z SET_TO (settings->current_z +
                                  settings->tool_length_offset);
      settings->tool_length_offset SET_TO 0.0;
      settings->length_offset_index SET_TO 0;
    }
  else if (g_code IS G_43)
    {
      index SET_TO block->h_number;
      if (index IS -1)
        ERROR_MACRO(_interpreter_linetext, name, "Offset index missing");
      else if (index > GET_EXTERNAL_TOOL_MAX())
        ERROR_MACRO(_interpreter_linetext, name, "Tool index out of bounds");
      else
        {
          offset SET_TO settings->tool_table[index].length;
          USE_TOOL_LENGTH_OFFSET(offset);
          settings->current_z SET_TO
            (settings->current_z + settings->tool_length_offset - offset);
          settings->tool_length_offset SET_TO offset;
          settings->length_offset_index SET_TO index;
        }
    }
  else
    BUG_MACRO(name, "Code is not G43 or G49 in convert_tool_length_offset");
  return RS274NGC_OK;
}

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

/* read_line_number

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. The first character read is not n (bug).
   2. read_integer_unsigned returns RS274NGC_ERROR.
   3. The line number is too large (more than 5 digits).

Side effects:
   counter is reset to the character following the line number.
   A line number is inserted in the block.

Called by: read_items

When this function is called, counter is pointing at an item on the
line that starts with the character 'n', indicating a line number.
The function reads characters which give the (integer) value of the
line number.

Note that extra initial zeros in a line number will not cause the
line number to be too large.

*/

int read_line_number( /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274    code being processed  */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block) /* pointer to a block being filled from the line  */
{
  static char name[] SET_TO "read_line_number";
  int value;

  if (line[*counter] ISNT 'n')
    BUG_MACRO(name, "Read_line_number should not have been called");

  *counter SET_TO (*counter + 1);
  if (read_integer_unsigned(line, counter, &value) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  else if (value > 99999)
    ERROR_MACRO(_interpreter_linetext, name, "Line number greater than 99999");
  else
    {
      block->line_number SET_TO value;
      return RS274NGC_OK;
    }
}

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

/* read_one_item

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If the first character read is not a known character for starting a
   word, or if the reader function which is called returns RS274NGC_ERROR, this
   returns RS274NGC_ERROR. Otherwise, it returns RS274NGC_OK.

Side effects:
   This function reads one item from a line of RS274/NGC code and inserts
   the information in a block. System parameters may be reset.

Called by: read_items.

When this function is called, the counter is set so that the position
being considered is the first position of a word. The character at
that position must be one known to the system.  In this version those
characters are: d,f,g,h,i,j,k,l,m,n,p,q,r,s,t,u,x,y,z,(,#.
This function does not look for N words because read_items calls
read_line_number directly.

The function looks for a letter or special character and calls a
selected function according to what the letter or character is.  The
selected function will be responsible to consider all the characters
that comprise the remainder of the item, and reset the pointer so that
points to the next character after the end of the item (which may be
the end of the line or the first character of another item).

After an item is read, the counter is set at the index of the
next unread character. The item data is stored in the block.

It is expected that the format of a comment will have been checked;
this is being done by close_and_downcase. Bad format comments will
have prevented the system from getting this far, so that this function
can assume a close parenthesis will be found when an open parenthesis
has been found, and that comments are not nested.

*/

typedef int (*_function_pointer) (char *, int *, block_pointer, double *);

int read_one_item(    /* ARGUMENT VALUES                                */
 char * line,         /* string: line of RS274/NGC code being processed */
 int * counter,       /* pointer to a counter for position on the line  */
 block_pointer block, /* pointer to a block being filled from the line  */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_one_item";
  _function_pointer function_pointer;

  switch (line[*counter])
    {
    case 'd':
      function_pointer SET_TO read_d;
      break;
    case 'f':
      function_pointer SET_TO read_f;
      break;
    case 'g':
      function_pointer SET_TO read_g;
      break;
    case 'h':
      function_pointer SET_TO read_tool_length_offset;
      break;
    case 'i':
      function_pointer SET_TO read_i;
      break;
    case 'j':
      function_pointer SET_TO read_j;
      break;
    case 'k':
      function_pointer SET_TO read_k;
      break;
    case 'l':
      function_pointer SET_TO read_l;
      break;
    case 'm':
      function_pointer SET_TO read_m;
      break;
    case 'p':
      function_pointer SET_TO read_p;
      break;
    case 'q':
      function_pointer SET_TO read_q;
      break;
    case 'r':
      function_pointer SET_TO read_r;
      break;
    case 's':
      function_pointer SET_TO read_spindle_speed;
      break;
    case 't':
      function_pointer SET_TO read_tool;
      break;
    case 'x':
      function_pointer SET_TO read_x;
      break;
    case 'y':
      function_pointer SET_TO read_y;
      break;
    case 'z':
      function_pointer SET_TO read_z;
      break;
    case '(':
      function_pointer SET_TO read_comment;
      break;
    case '#':
      function_pointer SET_TO read_parameter_setting;
      break;
    default:
      ERROR_MACRO(_interpreter_linetext, name, "Bad character used");
    }
  if (function_pointer (line, counter, block, parameters) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  return RS274NGC_OK;
}

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

/* check_items

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR
   Otherwise, it returns RS274NGC_OK.
   1. check_g_codes return RS274NGC_ERROR.
   2. check_m_codes returns RS274NGC_ERROR.
   3. check_other_codes returns RS274NGC_ERROR.
   4. A G38.2 (probing) is used with an M code for stopping.

Side effects: none

Called by: read_line

This runs checks on a block of RS274 code.

The functions named read_XXXX check for errors which would foul up the
reading. This function checks for additional logical errors.

A block has an array of g_codes, which are initialized to -1
(meaning no code). This calls check_g_codes to check the g_codes.

A block has an array of m_codes, which are initialized to -1
(meaning no code). This calls check_m_codes to check the m_codes.

Items in the block which are not m or g codes are checked by
check_other_codes.

*/

int check_items(          /* ARGUMENT VALUES                  */
 block_pointer block,     /* pointer to a block to be checked */
 setup_pointer settings)  /* pointer to machine settings      */
{
  static char name[] SET_TO "check_items";
  if (check_g_codes(block, settings) ISNT RS274NGC_OK)
    ERROR_MACRO_PASS(name);
  if (check_m_codes(block, settings) ISNT RS274NGC_OK)
    ERROR_MACRO_PASS(name);
  if (check_other_codes(block, settings) ISNT RS274NGC_OK)
    ERROR_MACRO_PASS(name);
  if ((block->m_modes[4] ISNT -1) AND (block->g_modes[1] IS G_38_2))
    ERROR_MACRO(_interpreter_linetext, name, "Cannot put an M code for stopping with G38.2");
  return RS274NGC_OK;
}

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

/* close_and_downcase

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If one of the following errors occurs, this returns RS274NGC_ERROR
   Otherwise, it returns RS274NGC_OK.
   1. A left parenthesis is found inside a comment.
   2. The line ends before an open comment is closed
   3. A newline character is found that is not followed by null
   4. The input line was too long

Side effects:
   see below.

Called by:
   read_text

To simplify handling upper case letters, spaces, and tabs, this
function removes spaces and and tabs and downcases everything on a
line which is not part of a comment.

Comments are left unchanged in place. Comments are anything
enclosed in parentheses. Nested comments, indicated by a left
parenthesis inside a comment, are illegal.

The line must have a null character at the end when it comes in.
The line may have one newline character just before the end. If
there is a newline, it will be removed.

Although this software system detects and rejects all illegal characters
and illegal syntax, this particular function does not detect problems
with anything but comments.

We are treating RS274 code here as case-insensitive and spaces and
tabs as if they have no meaning. RS274D, page 6 says spaces and tabs
are to be ignored by control.

The manual [NCMS] says nothing about case or spaces and tabs.

*/

int close_and_downcase( /* ARGUMENT VALUES             */
 char * line)           /* string: one line of NC code */
{
  static char name[] SET_TO "close_and_downcase";
  int m;
  int n;
  int comment;
  char item;
  comment SET_TO 0;
  for (n SET_TO 0, m SET_TO 0; (item SET_TO line[m]) ISNT (char) NULL; m++)
    {
      if (comment)
        {
          line[n++] SET_TO item;
          if (item IS ')')
            {
              comment SET_TO 0;
            }
          else if (item IS '(')
            ERROR_MACRO(_interpreter_linetext, name, "Nested comment found");
        }
      else if ((item IS ' ') OR (item IS '\t') OR (item IS '\r'));
                                      /* don't copy blank or tab  or CR */
      else if (item IS '\n')          /* don't copy newline             */
        {                             /* but check null follows         */
          if (line[m+1] ISNT 0)
            ERROR_MACRO(_interpreter_linetext, name, "Null missing after newline");
        }
      else if ((64 < item) AND (item < 91)) /* downcase upper case letters */
        {
          line[n++] SET_TO (32 + item);
        }
      else if (item IS '(')   /* comment is starting */
        {
          comment SET_TO 1;
          line[n++] SET_TO item;
        }
      else
        {
          line[n++] SET_TO item; /* copy anything else */
        }
    }
  if (m IS (INTERP_TEXT_SIZE - 1)) /* line was too long */
    ERROR_MACRO(_interpreter_linetext, name, "Command too long");
  else if (comment)
    ERROR_MACRO(_interpreter_linetext, name, "Unclosed comment found");
  line[n] SET_TO 0;
  return RS274NGC_OK;
}

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

/* convert_comment

Returned Value: int (RS274NGC_OK)

Side effects:
   The message function is called if the string starts with "MSG,".
   Otherwise, the comment function is called.

Called by: execute_block

To be a message, the first four characters of the comment after the
opening left parenthesis must be "MSG,", ignoring the case of the
letters and allowing spaces or tabs anywhere before the comma (to make
the treatment of case and white space consistent with how it is
handled elsewhere).

Messages are not provided for in [NCMS]. They are implemented here as a
subtype of comment.

*/

int convert_comment( /*ARGUMENT VALUES      */
 char * comment)     /* string with comment */
{
  int m;
  int item;

  for (m SET_TO 0; ((item SET_TO comment[m]) IS ' ') OR (item IS '\t') ; m++);
  if ((item ISNT 'M') AND (item ISNT 'm'))
    {
      COMMENT(comment);
      return RS274NGC_OK;
    }
  for (m++; ((item SET_TO comment[m]) IS ' ') OR (item IS '\t') ; m++);
  if ((item ISNT 'S') AND (item ISNT 's'))
    {
      COMMENT(comment);
      return RS274NGC_OK;
    }
  for (m++; ((item SET_TO comment[m]) IS ' ') OR (item IS '\t') ; m++);
  if ((item ISNT 'G') AND (item ISNT 'g'))
    {
      COMMENT(comment);
      return RS274NGC_OK;
    }
  for (m++; ((item SET_TO comment[m]) IS ' ') OR (item IS '\t') ; m++);
  if (item ISNT ',')
    {
      COMMENT(comment);
      return RS274NGC_OK;
    }
  MESSAGE(comment + m + 1);
  return RS274NGC_OK;
}

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

/* convert_feed_mode

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   BUG - If g_code isn't G_93 or G_94, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.

Side effects:
   The interpreter switches the machine settings to indicate the current
   feed mode (UNITS_PER_MINUTE or INVERSE_TIME).

   The canonical machine to which commands are being sent does not have
   a feed mode, so no command setting the distance mode is generated in
   this function. A comment function call is made (conditionally)
   explaining the change in mode, however.

Called by: execute_block.

*/

int convert_feed_mode(     /* ARGUMENT VALUES                              */
 int g_code,               /* g_code being executed (must be G_93 or G_94) */
 block_pointer block,      /* pointer to a block of RS274 instructions     */
 setup_pointer settings)   /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_feed_mode";
  if (g_code IS G_93)
    {
#ifdef DEBUG_EMC
      COMMENT("interpreter: feed mode set to inverse time");
#endif
      settings->feed_mode SET_TO INVERSE_TIME;
    }
  else if (g_code IS G_94)
    {
#ifdef DEBUG_EMC
      COMMENT("interpreter: feed mode set to units per minute");
#endif
      settings->feed_mode SET_TO UNITS_PER_MINUTE;
    }
  else
    BUG_MACRO(name, "Code is not G93 or G94 in convert_feed_mode");
  return RS274NGC_OK;
}

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

/* convert_feed_rate

Returned Value: int (RS274NGC_OK)

Side effects:
   The machine feed_rate is set to the value of f_number in the
     block by function call.
   The machine model feed_rate is set to that value.

Called by: execute_block

*/

int convert_feed_rate(   /* ARGUMENT VALUES                          */
 block_pointer block,    /* pointer to a block of RS274 instructions */
 setup_pointer settings) /* pointer to machine settings              */
{
  SET_FEED_RATE(block->f_number);
  settings->feed_rate SET_TO block->f_number;
  return RS274NGC_OK;
}

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

/* convert_g

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occurs, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.
   1. A g code in the block is not known to the system.
   2. One of the following functions is called and returns error:
      convert_control_mode
      convert_coordinate_system
      convert_cutter_compensation
      convert_distance_mode
      convert_length_units
      convert_modal_0
      convert_motion
      convert_retract_mode
      convert_set_plane
      convert_tool_length_offset

Side effects:
   Any g_codes in the block (excluding g93 and 94) and any implicit
   motion g_code are executed.

Called by: execute_block.

This takes a pointer to a block of RS274/NGC instructions (already
read in) and creates the appropriate output commands corresponding to
any "g" codes in the block.

Codes g93 and g94, which set the feed mode, are executed earlier by
execute_block before reading the feed rate.

G codes are are executed in the following order.
1. mode 4, (G4) - dwell. G53 is also in mode 4 but is not executed
   here.
2. mode 2, one of (G17, G18, G19) - plane selection.
3. mode 6, one of (G20, G21) - length units.
4. mode 7, one of (G40, G41, G42) - cutter radius compensation.
5. mode 8, one of (G43, G49) - tool length offset
6. mode 12, one of (G54, G55, G56, G57, G58, G59, G59.1, G59.2, G59.3)
   - coordinate system selection.
7. mode 13, one of (G61, G64) - control mode (exact path or continuous)
8. mode 3, one of (G90, G91) - distance mode.
9. mode 10, one of (G98, G99) - retract mode.
10. mode 0 (G10, G92, G92.2) - setting coordinate system locations, setting
    or cancelling axis offsets.
11. mode 1, one of (G0, G1, G2, G3, G38.2, G80, G81 to G89) - motion or cancel.

The mode 0 and mode 1 G codes must be executed after the length units
are set, since they use coordinate values. Mode 1 codes also must wait
until most of the other modes are set.

The mode 0 and mode 1 G codes are not quite mutually exclusive because
G80 is in the mode 1 group. check_g_codes prevents competition between
the mode 0 and mode 1 G codes for the use of axis values. If a mode 0
G code is used, only G80 from the mode 1 group is possible.

Mode 4 codes (G4 and G53) can coexist with mode 1 codes.

*/

int convert_g(           /* ARGUMENT VALUES                              */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings) /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_g";

  if (block->g_modes[4] IS G_4)
    {
      if (convert_dwell(block->p_number) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }

  if (block->g_modes[2] ISNT -1)
    {
      if (convert_set_plane(block->g_modes[2], block, settings)
          IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }

  if (block->g_modes[6] ISNT -1)
    {
      if (convert_length_units(block->g_modes[6], settings) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }

  if (block->g_modes[7] ISNT -1)
    {
      if (convert_cutter_compensation(block->g_modes[7], block, settings)
          IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }

  if (block->g_modes[8] ISNT -1)
    {
      if (convert_tool_length_offset(block->g_modes[8], block, settings)
          IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }

  if (block->g_modes[12] ISNT -1)
    {
      if (convert_coordinate_system (block->g_modes[12], block, settings)
          IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }

  if (block->g_modes[13] ISNT -1)
    {
      if (convert_control_mode (block->g_modes[13], block, settings)
          IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }

  if (block->g_modes[3] ISNT -1)
    {
      if (convert_distance_mode(block->g_modes[3], block, settings)
          IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }

  if (block->g_modes[10] ISNT -1)
    {
      if (convert_retract_mode(block->g_modes[10], block, settings)
          IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }

  if (block->g_modes[0] ISNT -1)
    {
      if (convert_modal_0(block->g_modes[0], block, settings)
          IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }

  if (block->motion_to_be ISNT -1)
    {
      if (convert_motion(block->motion_to_be, block, settings)
          IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  return RS274NGC_OK;
}

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

/* convert_m

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If convert_tool_change is returns RS274NGC_ERROR, this
   returns RS274NGC_ERROR. Otherwise, it returns RS274NGC_OK.

Side effects:
   m_codes in the block are executed. For each m_code
   this consists of making a function call to a primitive machining
   function and setting the machine model.

Called by: execute_block.

This handles the following types of activity in order:
1. changing the tool (m6) - which also retracts and stops the spindle.
2. Turning the spindle on or off (m3, m4, and m5)
3. Turning coolant on and off (m7, m8, and m9)
4. enabling or disabling feed and speed overrides (m49, m49).
Within each group, only the first code encountered will be executed.

This is called if any m_code is programmed, but does nothing with m0,
m1, m2, m30, or m60 (which are handled in convert_stop).

*/

int convert_m(           /* ARGUMENT VALUES                              */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings) /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_m";
  if (block->m_modes[6] ISNT -1)
    if (convert_tool_change(block, settings) IS RS274NGC_ERROR)
      ERROR_MACRO_PASS(name);

  if (block->m_modes[7] IS 3)
    {
      START_SPINDLE_CLOCKWISE();
      settings->spindle_turning SET_TO CANON_CLOCKWISE;
    }
  else if (block->m_modes[7] IS 4)
    {
      START_SPINDLE_COUNTERCLOCKWISE();
      settings->spindle_turning SET_TO CANON_COUNTERCLOCKWISE;
    }
  else if (block->m_modes[7] IS 5)
    {
      STOP_SPINDLE_TURNING();
      settings->spindle_turning SET_TO CANON_STOPPED;
    }

  if (block->m_modes[8] IS 7)
    {
      MIST_ON();
      settings->mist SET_TO ON;
    }
  else if (block->m_modes[8] IS 8)
    {
      FLOOD_ON();
      settings->flood SET_TO ON;
    }
  else if (block->m_modes[8] IS 9)
    {
      MIST_OFF();
      settings->mist SET_TO OFF;
      FLOOD_OFF();
      settings->flood SET_TO OFF;
    }

  if (block->m_modes[9] IS 48)
    {
      ENABLE_FEED_OVERRIDE();
      ENABLE_SPEED_OVERRIDE();
      settings->feed_override SET_TO ON;
      settings->speed_override SET_TO ON;
    }
  else if (block->m_modes[9] IS 49)
    {
      DISABLE_FEED_OVERRIDE();
      DISABLE_SPEED_OVERRIDE();
      settings->feed_override SET_TO OFF;
      settings->speed_override SET_TO OFF;
    }
  return RS274NGC_OK;
}

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

/* convert_speed

Returned Value: int (RS274NGC_OK)

Side effects:
  The machine spindle speed is set to the value of s_number in the
  block by function call.
  The machine model for spindle speed is set to that value.

Called by: execute_block.

*/

int convert_speed(       /* ARGUMENT VALUES                          */
 block_pointer block,    /* pointer to a block of RS274 instructions */
 setup_pointer settings) /* pointer to machine settings              */
{
  SET_SPINDLE_SPEED(block->s_number);
  settings->speed SET_TO block->s_number;
  return RS274NGC_OK;
}

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

/* convert_stop

Returned Value: int (RS274NGC_OK or RS274NGC_EXIT)
   When an m2 or m30 (program_end) is encountered, this returns RS274NGC_EXIT.
   BUG - If the code is not m0, m1, m2, m30, or m60, this
   returns RS274NGC_ERROR. Otherwise, it returns RS274NGC_OK.

Side effects:
   An m0, m1, m2, m30, or m60 in the block is executed.
   This consists of making a function call to a primitive
   machining function.

   For m0, m1, and m60, this makes a function call to a canonical
   machining function that stops the machine. In addition, m60 calls
   PALLET_SHUTTLE.

   For m2 and m30, this resets the machine and then calls PROGRAM_END.
   In addition, m30 calls PALLET_SHUTTLE.

Called by: execute_block.

This handles stopping or ending the program (m0, m1, m2, m30, m60)

[NCMS] specifies how the following modes should be reset at m2 or
m30. The descriptions are not collected in one place, so this list
may be incomplete.

G52 offsetting coordinate zero points [NCMS, page 10]
G92 coordinate offset using tool position [NCMS, page 10]

The following should have reset values, but no description of reset
behavior could be found in [NCMS].
G17, G18, G19 selected plane [NCMS, pages 14, 20]
G90, G91 distance mode [NCMS, page 15]
G93, G94 feed mode [NCMS, pages 35 - 37]
M48, M49 overrides enabled, disabled [NCMS, pages 37 - 38]
M3, M4, M5 spindle turning [NCMS, page 7]

The following should be set to some value at machine start-up but
not automatically reset by any of the stopping codes.
1. G20, G21 length units [NCMS, page 15]. This is up to the installer.
2. motion_control_mode. This is set in rs274ngc_init but not reset here.
   Might add it here.

The following resets have been added by calling the appropriate
canonical machining command and/or by resetting interpreter
settings. They occur on M2 or M30.

1. Axis offsets are set to zero (like g92.2) and      - SET_ORIGIN_OFFSETS
   origin offsets are set to the default (like G54)
2. Selected plane is set to CANON_PLANE_XY (like G17) - SELECT_PLANE
3. Distance mode is set to ABSOLUTE (like G90)        - no canonical call
4. Feed mode is set to UNITS_PER_MINUTE (like G94)    - no canonical call
5. Feed and speed overrides are set to ON (like G48)  - ENABLE_FEED_OVERRIDE
                                                      - ENABLE_SPEED_OVERRIDE
6. Cutter compensation is turned off (like G40)       - no canonical call
7. The spindle is stopped (like M5)                   - STOP_SPINDLE_TURNING
8. The motion mode is set to G_1 (like G1)            - no canonical call
9. Coolant is turned off (like M9)                    - FLOOD_OFF & MIST_OFF

*/

int convert_stop(         /* ARGUMENT VALUES                              */
 block_pointer block,     /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings)  /* pointer to machine settings                  */
{
  static char name[] SET_TO "convert_stop";

  if (block->m_modes[4] IS 0)
    {
      PROGRAM_STOP();
    }
  else if (block->m_modes[4] IS 60)
    {
      PALLET_SHUTTLE();
      PROGRAM_STOP();
    }
  else if (block->m_modes[4] IS 1)
    {
      OPTIONAL_PROGRAM_STOP();
    }
  else if ((block->m_modes[4] IS 2) OR (block->m_modes[4] IS 30))
    { /* reset stuff here */
/*1*/
      settings->current_x SET_TO settings->current_x
        + settings->origin_offset_x;
      settings->current_y SET_TO settings->current_y
        + settings->origin_offset_y;
      settings->current_z SET_TO settings->current_z
        + settings->origin_offset_z;
      settings->origin_offset_x SET_TO settings->parameters[5221];
      settings->origin_offset_y SET_TO settings->parameters[5222];
      settings->origin_offset_z SET_TO settings->parameters[5223];
      settings->current_x SET_TO settings->current_x -
        settings->origin_offset_x;
      settings->current_y SET_TO settings->current_y -
        settings->origin_offset_y;
      settings->current_z SET_TO settings->current_z -
        settings->origin_offset_z;
      SET_ORIGIN_OFFSETS(settings->origin_offset_x + settings->axis_offset_x,
                         settings->origin_offset_y + settings->axis_offset_y,
                         settings->origin_offset_z + settings->axis_offset_z);

/*2*/ if (settings->plane ISNT CANON_PLANE_XY)
        {
          SELECT_PLANE(CANON_PLANE_XY);
          settings->plane SET_TO CANON_PLANE_XY;
        }

/*3*/ settings->distance_mode SET_TO MODE_ABSOLUTE;

/*4*/ settings->feed_mode SET_TO UNITS_PER_MINUTE;

/*5*/ if (settings->feed_override ISNT ON)
        {
          ENABLE_FEED_OVERRIDE();
          settings->feed_override SET_TO ON;
        }
      if (settings->speed_override ISNT ON)
        {
          ENABLE_SPEED_OVERRIDE();
          settings->speed_override SET_TO ON;
        }

/*6*/ settings->cutter_radius_compensation SET_TO OFF;
      settings->program_x SET_TO UNKNOWN;

/*7*/ STOP_SPINDLE_TURNING();
      settings->spindle_turning SET_TO CANON_STOPPED;

/*8*/ settings->motion_mode SET_TO G_1;

/*9*/ if (settings->mist IS ON)
        {
          MIST_OFF();
          settings->mist SET_TO OFF;
        }
      if (settings->flood IS ON)
        {
          FLOOD_OFF();
          settings->flood SET_TO OFF;
        }

      if (block->m_modes[4] IS 30)
        PALLET_SHUTTLE();
      PROGRAM_END();
      return RS274NGC_EXIT;
    }
  else
    BUG_MACRO(name, "Code is not M0, M1, M2, M30 or M60 in convert_stop");
  return RS274NGC_OK;
}

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

/* convert_tool_select

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If the tool number in the block is out of bounds, this
   returns RS274NGC_ERROR. Otherwise, it returns RS274NGC_OK.

Side effects:
  A select tool command is given, which causes the changer chain
  to move so that the selected slot is next to the tool changer,
  ready for a tool change. The settings->selected_tool_slot is set
  to the t number in the block.

Called by: execute_block.

*/

int convert_tool_select( /* ARGUMENT VALUES                                 */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions    */
 setup_pointer settings) /* pointer to machine settings                     */
{
  static char name[] SET_TO "convert_tool_select";

  if (block->t_number > GET_EXTERNAL_TOOL_MAX())
    ERROR_MACRO(_interpreter_linetext, name, "Selected tool slot number too large");

  SELECT_TOOL(block->t_number);
  settings->selected_tool_slot SET_TO block->t_number;
  return RS274NGC_OK;
}

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

/* init_block

Returned Value: int (RS274NGC_OK)

Side effects:
   Values in the block are reset as described below.

Called by: read_line

This system reuses the same block over and over, rather than building
a new one for each line of NC code. The block is re-initialized before
each new line of NC code is read.

The block contains many slots for values which may or may not be present
on a line of NC code. For some of these slots, there is a flag which
is turned on (at the time time value of the slot is read) if the item
is present.  For slots whose values are to be read which do not have a
flag, there is always some excluded range of values. Setting the
initial value of these slot to some number in the excluded range
serves to show that a value for that slot has not been read.

The rules for the indicators for slots whose values may be read are:
1. If the value may be an arbitrary real number (which is always stored
   internally as a double), a flag is needed to indicate if a value has
   been read. All such flags are initialized to OFF.
   Note that the value itself is not initialized; there is no point in it.
2. If the value must be a non-negative real number (which is always stored
   internally as a double), a value of -1.0 indicates the item is not present.
3. If the value must be an unsigned integer (which is always stored
   internally as an int), a value of -1 indicates the item is not present.
   (RS274/NGC does not use any negative integers.)
4. If the value is a character string (only the comment slot is one), the
   first character is set to 0 (NULL).

*/

int init_block(        /* ARGUMENT VALUES                               */
 block_pointer block)  /* pointer to a block to be initialized or reset */
{
  int n;
  block->comment[0] SET_TO 0;
  block->d_number SET_TO -1;
  block->f_number SET_TO -1.0;
  block->g_count SET_TO 0;
  for (n SET_TO 0; n < 14; n++)
    {
      block->g_modes[n] SET_TO -1;
    }
  block->h_number SET_TO -1;
  block->i_flag SET_TO OFF;
  block->j_flag SET_TO OFF;
  block->k_flag SET_TO OFF;
  block->l_number SET_TO -1;
  block->line_number SET_TO -1;
  block->motion_to_be SET_TO -1;
  block->m_count SET_TO 0;
  for (n SET_TO 0; n < 10; n++)
    {
      block->m_modes[n] SET_TO -1;
    }
  block->p_number SET_TO -1.0;
  block->q_number SET_TO -1.0;
  block->r_flag SET_TO OFF;
  block->s_number SET_TO -1.0;
  block->t_number SET_TO -1;
  block->x_flag SET_TO OFF;
  block->y_flag SET_TO OFF;
  block->z_flag SET_TO OFF;

  return RS274NGC_OK;
}

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

/* read_items

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If read_line_number or read_one_item returns RS274NGC_ERROR,
   this returns RS274NGC_ERROR. Otherwise, it returns RS274NGC_OK.

Side effects:
   One line of RS274 code is read and data inserted into a block.
   The counter which is passed around among the readers is initialized.
   System parameters may be reset.

Called by: read_line

*/

int read_items(       /* ARGUMENT VALUES                                */
 block_pointer block, /* pointer to a block being filled from the line  */
 char * line,         /* string: line of RS274/NGC code being processed */
 double * parameters) /* array of system parameters                     */
{
  static char name[] SET_TO "read_items";
  int counter;
  int length;

  length SET_TO strlen(line);
  counter SET_TO 0;

  if (line[counter] IS '/')
    counter++;
  if (line[counter] IS 'n')
    {
      if (read_line_number(line, &counter, block) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  for ( ; counter < length; )
    {
      if (read_one_item (line, &counter, block, parameters) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  return RS274NGC_OK;
}

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

/* utility_enhance_block

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If
   this returns RS274NGC_ERROR. Otherwise, it returns RS274NGC_OK.

Side effects:
   The value of motion_to_be in the block is set.

Called by: read_line

It does not seem practical to change x and y to absolute coordinates
here because they are handled differently according to whether cutter
radius compensation is on or not.

*/

int utility_enhance_block( /* ARGUMENT VALUES                   */
 block_pointer block,      /* pointer to a block to be checked  */
 setup_pointer settings)   /* pointer to machine settings       */
{
  static char name[] SET_TO "utility_enhance_block";
  if (block->g_modes[1] ISNT -1)
    block->motion_to_be SET_TO block->g_modes[1];
  else if ((((block->x_flag IS ON) OR (block->y_flag IS ON)) OR
            (block->z_flag IS ON)) AND
           (block->g_modes[0] IS -1))
    block->motion_to_be SET_TO settings->motion_mode;
  return RS274NGC_OK;
}

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

/* write_g_codes

Returned Value: int (RS274NGC_OK)

Side effects:
   The gez struct is updated.

Called by:
   rs274ngc_execute
   rs274ngc_init

The block may be NULL.

This writes active g_codes into the gez structure by examining the
interpreter settings. The gez structure array of actives is composed
of ints, so (to handle codes like 59.1) all g_codes are is reported as
ints ten times the actual value. For example, 59.1 is reported as 591.

Note: the recent_gees_pointer is no longer an array with the history.
It's only a single group of the most recent ones.

*/

int write_g_codes(        /* ARGUMENT VALUES                              */
 block_pointer block,     /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings,  /* pointer to machine settings                  */
 int line_number,         /* number of line being executed                */
 int * gez)               /* pointer to array of G code numbers           */
{
  gez[0] SET_TO line_number;            /* 0 line number     */
  gez[1] SET_TO settings->motion_mode;  /* 1 motion mode     */
  gez[2] SET_TO
    (block IS NULL)             ? -1                :
    (block->g_modes[0] ISNT -1) ? block->g_modes[0] :  /* 2 g10,g92         */
                                  block->g_modes[4] ;  /* 2 g4, g53         */
  gez[3] SET_TO
    (settings->plane IS CANON_PLANE_XY) ? G_17 :       /* 3 active plane    */
    (settings->plane IS CANON_PLANE_XZ) ? G_18 : G_19;
  gez[4] SET_TO                         /* 4 cut radius comp */
    (settings->cutter_radius_compensation IS RIGHT) ? G_42 :
    (settings->cutter_radius_compensation IS LEFT) ? G_41 : G_40;
  gez[5] SET_TO                         /* 5 length units    */
    (settings->length_units IS CANON_UNITS_INCHES) ? G_20 : G_21;
  gez[6] SET_TO                         /* 6 distance mode   */
    (settings->distance_mode IS MODE_ABSOLUTE) ? G_90 : G_91;
  gez[7] SET_TO                         /* 7 feed mode       */
    (settings->feed_mode IS INVERSE_TIME) ? G_93 : G_94;
  gez[8] SET_TO                         /* 8 coord system    */
    (settings->origin_ngc < 7) ? (530 + (10 * settings->origin_ngc)) :
                                 (584 + settings->origin_ngc);
  gez[9] SET_TO                         /* 9 tool len offset */
    (settings->tool_length_offset IS 0.0) ? G_49 : G_43;
  gez[10] SET_TO                        /* 10 retract mode   */
    (settings->retract_mode IS OLD_Z) ? G_98 : G_99;
  gez[11] SET_TO                        /* 11 control mode   */
    (settings->control_mode IS CANON_CONTINUOUS) ? G_64 : G_61;

  return RS274NGC_OK;
}

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

/* write_m_codes

Returned Value: int (RS274NGC_OK)

Side effects:
   The array of ints is updated.

Called by:
   rs274ngc_execute
   rs274ngc_init

Note that this no longer maintains a history, and just returns the current
M code settings.

*/

int write_m_codes(       /* ARGUMENT VALUES                              */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings, /* pointer to machine settings                  */
 int line_number,        /* number of line being executed                */
 int * ems)              /* pointer to array of M code numbers           */
{
  ems[0] SET_TO line_number;                           /* 0 line number */
  ems[1] SET_TO
    (block IS NULL) ? -1 : block->m_modes[4];          /* 1 stopping    */
  ems[2] SET_TO
    (settings->spindle_turning IS CANON_STOPPED) ? 5 : /* 2 spindle     */
    (settings->spindle_turning IS CANON_CLOCKWISE) ? 3 : 4;
  ems[3] SET_TO                                        /* 3 tool change */
    (block IS NULL) ? -1 : block->m_modes[6];
  ems[4] SET_TO                                        /* 4 mist        */
    (settings->mist IS ON) ? 7 :
    (settings->flood IS ON) ? -1 : 9;
  ems[5] SET_TO                                        /* 5 flood       */
    (settings->flood IS ON) ? 8 : -1;
  ems[6] SET_TO                                        /* 6 overrides   */
    (settings->feed_override IS ON) ? 48 : 49;         /* both overrides*/

  return RS274NGC_OK;
}

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

/* write_settings

Returned Value: int (RS274NGC_OK)

Side effects:
   The array of doubles is updated with the F and S code settings

Called by:
   rs274ngc_execute
   rs274ngc_init
*/

int write_settings(      /* ARGUMENT VALUES                              */
 block_pointer block,    /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings, /* pointer to machine settings                  */
 int line_number,        /* number of line being executed                */
 double * vals)          /* pointer to array of M code numbers           */
{
  vals[0] SET_TO line_number;   /* 0 line number */
  vals[1] SET_TO settings->feed_rate; /* 1 feed rate */
  vals[2] SET_TO settings->speed; /* 2 spindle speed */

  return RS274NGC_OK;
}

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

/* execute_block

Returned Value: int (RS274NGC_OK, RS274NGC_EXIT, RS274NGC_EXECUTE_FINISH,
                     or RS274NGC_ERROR)
   If any function called returns RS274NGC_ERROR, this returns RS274NGC_ERROR.
   Else if convert_stop returns RS274NGC_EXIT, this returns RS274NGC_EXIT.
   Else if the probe_flag in the settings is ON, this returns
      RS274NGC_EXECUTE_FINISH
   Otherwise, it returns RS274NGC_OK.

Side effects:
   One block of RS274/NGC instructions is executed.

Called by:
   rs274ngc_execute

This converts a block to zero to many actions. The order of execution
of items in a block is critical to safe and effective machine
operation, but is not specified clearly in the [NCMS] documentation.

Actions are executed in the following order:
1. any comment.
2. a feed mode setting (g93, g94)
3. a feed rate (f) setting if in units_per_minute feed mode.
4. a spindle speed (s) setting.
5. a tool selection (t).
6. "m" commands as described in convert_m (includes tool change).
7. any g_codes (except g93, g94) as described in convert_g.
8. stopping commands (m0, m1, m2, m30, or m60).

In inverse time feed mode, the explicit and implicit g code executions
include feed rate setting with g1, g2, and g3. Also in inverse time
feed mode, attempting a canned cycle cycle (g81 to g89) or setting a
feed rate with g0 is illegal and will be detected and result in an
error message.

*/

int execute_block(         /* ARGUMENT VALUES                              */
 block_pointer block,      /* pointer to a block of RS274/NGC instructions */
 setup_pointer settings,   /* pointer to machine settings                  */
 int line_number)          /* number of line being executed                */
{
  static char name[] SET_TO "execute_block";
  if (block->comment[0] ISNT 0)
    {
      if (convert_comment(block->comment) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  if (block->g_modes[5] ISNT -1)
    {
      if (convert_feed_mode(block->g_modes[5], block, settings)
          IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  if (block->f_number > -1.0)
    {
      if (settings->feed_mode IS INVERSE_TIME); /* handle elsewhere */
      else if (convert_feed_rate(block, settings) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  if (block->s_number > -1.0)
    {
      if (convert_speed(block, settings) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  if (block->t_number ISNT -1)
    {
      if (convert_tool_select(block, settings) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
    }
  if (convert_m(block, settings) IS RS274NGC_ERROR)
        ERROR_MACRO_PASS(name);
  if (convert_g(block, settings) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  if (block->m_modes[4] ISNT -1) /* converts m0, m1, m2, m30, or m60 */
    {
      if (convert_stop(block, settings) IS RS274NGC_EXIT)
        return RS274NGC_EXIT;
    }
  if (settings->probe_flag IS ON)
    return RS274NGC_EXECUTE_FINISH;
  else
    return RS274NGC_OK;
}

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

/* read_line

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the calls to init_block, read_items, utility_enhance_block,
   or check_items returns RS274NGC_ERROR, this returns RS274NGC_ERROR.
   Otherwise, it returns RS274NGC_OK.

Side effects:
   One RS274 line is read into a block and the block is checked for
   errors. System parameters may be reset.

Called by:
   rs274ngc_execute
   rs274ngc_read

*/

int read_line(           /* ARGUMENT VALUES                      */
 char * line,            /* array holding a line of RS274 code   */
 block_pointer block,    /* pointer to a block to be filled      */
 setup_pointer settings) /* pointer to machine settings          */
{
  static char name[] SET_TO "read_line";
  if (init_block (block) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  if (read_items(block, line, settings->parameters) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  if (utility_enhance_block(block, settings) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  if (check_items (block, settings) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);
  return RS274NGC_OK;
}

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

/* read_text

Returned Value: int - (RS274NGC_OK or RS274NGC_ERROR)
   If close_and_downcase returns RS274NGC_ERROR, this returns RS274NGC_ERROR;
   if the file end is found, this returns RS274NGC_ENDFILE.
   Otherwise, it returns RS274NGC_OK.

Side effects:
   The value of the length argument is set to the number of
   characters on the reduced line. The line is written into.

Called by:
   rs274ngc_execute
   rs274ngc_read

This reads a line of RS274 code from a command string or a file into
the line array. If the string is not null, the file is ignored.

If the end of file is reached, that means that the file has run out
without a stopping command having been given (a stopping command
causes other functions to close the file), so RS274NGC_ERROR is returned.

This then calls close_and_downcase to remove tabs and spaces from
everything on the line that is not part of a comment. Any comment is
left as is.

The length is set to zero if any of the following occur:
1. The line now starts with a slash, and block_delete is on.
2. The line now starts with a slash, but the second character is NULL.
3. The first character is NULL.
Otherwise, length is set to the length of the line.

An input line is blank if the first character is NULL or it consists
entirely of tabs and spaces and, possibly, a newline before the first
NULL.

If there is newline character at the end of the line, it is replaced
in close_and_downcase with a NULL character.

The rule used here (for what to do with a line starting with a slash)
is: if block delete is on, the line is read but not executed; if block
delete is off, ignore the slash and process the line normally. A slash
anywhere else on a line, except inside a comment, is illegal and will
cause an error.

Block delete is discussed in [NCMS, page 3] but the discussion makes no
sense.

*/

int read_text(         /* ARGUMENT VALUES                             */
 const char * command, /* a string which may have input text, or null */
 FILE * inport,        /* a file pointer for an input file, or null   */
 char * raw_line,      /* array to write raw input line into          */
 char * line,          /* array for input line to be processed in     */
 int * length,         /* a pointer an integer to be set              */
 ON_OFF block_delete)  /* whether block_delete switch is on or off    */
{
  static char name[] SET_TO "read_text";
  char * returned_value;
  int len;

  if (command IS NULL)
    {
      returned_value SET_TO fgets(raw_line, INTERP_TEXT_SIZE, inport);
      // knock off CR, LF
      len = strlen(raw_line) - 1; // set len to index of last char
      while (len >= 0)
        {
          if (isspace(raw_line[len]))
            {
              raw_line[len] = 0;
              len--;
            }
          else
            {
              break;
            }
        }
      if (returned_value IS NULL)
        return RS274NGC_ENDFILE;
      else
        strcpy(line, raw_line);
    }
  else
    {
      strcpy(raw_line, command);
      strcpy(line, command);
    }

  if (close_and_downcase(line) IS RS274NGC_ERROR)
    ERROR_MACRO_PASS(name);

  if (((line[0] IS '/') AND ((block_delete IS ON) OR (line[1] IS 0))) OR
      (line[0] IS 0))
    *length SET_TO 0;
  else
    *length SET_TO strlen(line);

  return RS274NGC_OK;
}

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

/* set_probe_data

Returned Value: int (RS274NGC_OK)

Side effects:
   System parameters may be reset.

Called by:
   rs274ngc_execute
   rs274ngc_read

*/

int set_probe_data(        /* ARGUMENT VALUES             */
 setup_pointer settings)   /* pointer to machine settings */
{
  static char name[] SET_TO "set_probe_data";
  CANON_POSITION position;
  CANON_POSITION probe_position;

  position SET_TO GET_EXTERNAL_POSITION();
  settings->current_x SET_TO position.x;
  settings->current_y SET_TO position.y;
  settings->current_z SET_TO position.z;
  probe_position SET_TO GET_EXTERNAL_PROBE_POSITION();
  settings->parameters[5061] SET_TO probe_position.x;
  settings->parameters[5062] SET_TO probe_position.y;
  settings->parameters[5063] SET_TO probe_position.z;
  settings->parameters[5067] SET_TO GET_EXTERNAL_PROBE_VALUE();
  return RS274NGC_OK;
}

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

/*

The functions defined below this point in this file comprise an
interface between the rs274 interpreter kernel and the rest of the
EMC software system.

The interface also includes ten data items, as listed immediately below.
These are passed by reference only to the interpreter kernel. In the
integrated EMC system, none of these is known outside this file. In
the stand-alone version seven of them are used in the driver source code
file.

*/

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

/* rs274ngc_reset

Returned Value: none

Side Effects:
   This function resets the status, so that when the interpreter
   is through with a part program (error, end of file, etc.) certain
   status data is zero.

Called By:
   rs274ngc_close
   rs274ngc_exit
   rs274ngc_init
   rs274ngc_read

*/

int rs274ngc_reset()
{
  _textline SET_TO 0;
  _interpreter_filename[0] SET_TO 0;
  _interpreter_linetext[0] SET_TO 0;
  _interpreter_blocktext[0] SET_TO 0;
  _interpreter_fp SET_TO NULL;
  _interpreter_status SET_TO 0;
  _interpreter_length SET_TO 0;

  return 0;
}

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

/* rs274ngc_command

Returned Value: char * (a string with the last line of NC code read)

Side Effects: (none)

Called By:
   This not called by any other function in the interpreter source file.
   It is intended to be called externally.
   It is not used in the stand-alone interpreter.

*/

const char * rs274ngc_command()
{
  return _interpreter_linetext;
}

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

/* rs274ngc_file

Returned Value: char * (the name of the NC program file being interpreted)

Side Effects: (none)

Called By:
   This not called by any other function in the interpreter source file.
   It is intended to be called externally.
   It is not used in the stand-alone interpreter.

*/

const char * rs274ngc_file()
{
  return _interpreter_filename;
}

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

/* rs274ngc_line

Returned Value: int

Side Effects: (none)

Called By:
   This not called by any other function in the interpreter source file.
   It is intended to be called externally.
   It is not used in the stand-alone interpreter.

This returns the line number assigned by the interpreter to the current
line of NC code. This is not the "N" number which is usually at the
beginning of a line of code. The _textline is initialized to 1 in
rs274ngc_open and is incremented by one each time rs274ngc_read
is called.

*/

int rs274ngc_line()
{
  return _textline;
}

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

/* rs274ngc_close

Returned Value: int (RS274NGC_OK)

Side Effects:
   The NC-code file is closed if open.

Called By:
   This not called by any other function in the interpreter source file.
   It is intended to be called externally.
   It is not used in the stand-alone interpreter.

*/

int rs274ngc_close()
{
  if (_interpreter_fp ISNT NULL)
  {
    fclose(_interpreter_fp);
    _interpreter_fp SET_TO NULL;
  }

  _interpreter_filename[0] SET_TO 0;

  rs274ngc_reset();

  return RS274NGC_OK;
}

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

/* rs274ngc_execute

Returned Value: int (RS274NGC_OK, RS274NGC_EXIT, RS274NGC_EXECUTE_FINISH,
                     or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   1. The command argument is not null and any of the following happens
     A. The command string is too long.
     B. The command string cannot be handled correctly by read_text.
     C. The command string cannot be parsed correctly by read_line.
   2. execute_block returns RS274NGC_ERROR.
   3. The probe_flag is ON but the HME command queue is not empty.

   If execute_block returns RS274NGC_EXIT, this returns RS274NGC_EXIT.
   if execute_block returns RS274NGC_EXECUTE_FINISH this returns that.
   Otherwise, this returns RS274NGC_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.

Called By:
   This not called by any other function in the interpreter source file.
   It is intended to be called externally.
   It is called by interpret_from_file and interpret_from_keyboard
    in the driver.

If the command argument is a non-null string, the string is assumed to
be a line of NC code. It is parsed into the _interpreter_block,
and the block is executed.

If the command argument is null, it is assumed that the
_interpreter_block already contains the information from a line of NC
code and the block is executed.

*/

int rs274ngc_execute(   /* ARGUMENT VALUES */
 const char * command)  /* string: line of NC code to execute (may be null) */
{
  static char name[] SET_TO "rs274ngc_execute";

  if (_interpreter_settings.probe_flag IS ON)
    {
      if (IS_EXTERNAL_QUEUE_EMPTY() IS 0)
        {
          /* rs274ngc_reset(); */
          ERR_MACRO(_interpreter_linetext, name, "Queue is not empty after probing");
        }
      set_probe_data(&_interpreter_settings);
      _interpreter_settings.probe_flag SET_TO OFF;
    }

  if (command ISNT NULL)
    {
      if(strlen(command) > (INTERP_TEXT_SIZE -1))
        ERR_MACRO(_interpreter_linetext, name, "Command too long");
      else if (read_text (command, NULL, _interpreter_linetext,
                          _interpreter_blocktext, &_interpreter_length,
                          _interpreter_settings.block_delete) ISNT RS274NGC_OK)
        ERR_MACRO_PASS(name);
      else if (_interpreter_length IS 0) /* blank or block-deleted command */
        return RS274NGC_OK;
      else if (read_line(_interpreter_blocktext, &_interpreter_block,
                         &_interpreter_settings) IS RS274NGC_ERROR)
        ERR_MACRO_PASS(name);
      _textline++;
    }

  if (_interpreter_length IS 0) /* blank or block deleted line from file */
    {
      write_g_codes((block *) NULL, &_interpreter_settings, _textline,
                    &_interpreter_active_g_codes[0]);
      write_m_codes((block *) NULL, &_interpreter_settings, _textline,
                    &_interpreter_active_m_codes[0]);
      write_settings((block *) NULL, &_interpreter_settings, _textline,
                    &_interpreter_active_settings[0]);

      return RS274NGC_OK;
    }

  _interpreter_status SET_TO
    execute_block (&_interpreter_block, &_interpreter_settings, _textline);

  // write most recent G codes
  write_g_codes(&_interpreter_block, &_interpreter_settings, _textline,
                &_interpreter_active_g_codes[0]);
  write_m_codes(&_interpreter_block, &_interpreter_settings, _textline,
                &_interpreter_active_m_codes[0]);
  write_settings(&_interpreter_block, &_interpreter_settings, _textline,
                 &_interpreter_active_settings[0]);

  if (_interpreter_status IS RS274NGC_EXIT) /* program over */
    {
      if (_interpreter_fp ISNT NULL)
        {
          fclose(_interpreter_fp);
          _interpreter_fp SET_TO NULL;
          _textline SET_TO 0;
          _interpreter_linetext[0] SET_TO 0;
        }
      return RS274NGC_EXIT;
    }
  else if (_interpreter_status IS RS274NGC_ERROR)
    ERR_MACRO_PASS(name);
  else if (_interpreter_status IS RS274NGC_EXECUTE_FINISH)
    return RS274NGC_EXECUTE_FINISH;
  else /* satisfactory execution of a line */
    return RS274NGC_OK;
}

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

/* rs274ngc_exit

Returned Value: int (RS274NGC_OK)

Side Effects:
   Some parts of the world model are reset.

Called By:
   This not called by any other function in the interpreter source file.
   It is intended to be called externally.
   It is not used in the stand-alone interpreter.

*/

int rs274ngc_exit()
{
  rs274ngc_save_parameters(RS274NGC_PARAMETER_FILE,
                           _interpreter_settings.parameters);

  rs274ngc_reset();

  return RS274NGC_OK;
}

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

/* rs274ngc_synch

Returned Value: int (RS274NGC_OK)

Side Effects:
   sets the value of _interpreter_settings.current_x/y/z to what's
   returned by GET_EXTERNAL_POSITION().

Called By:
   This not called by any other function in the interpreter source file.
   It is intended to be called externally.
   It is not used in the stand-alone interpreter.

   */

int rs274ngc_synch()
{
  CANON_POSITION current_point;

  _interpreter_settings.current_slot SET_TO GET_EXTERNAL_TOOL();

  rs274ngc_load_tool_table();

  _interpreter_settings.control_mode SET_TO GET_MOTION_CONTROL_MODE();
  current_point SET_TO GET_EXTERNAL_POSITION();
  _interpreter_settings.current_x SET_TO current_point.x;
  _interpreter_settings.current_y SET_TO current_point.y;
  _interpreter_settings.current_z SET_TO current_point.z;

  _interpreter_settings.feed_rate SET_TO GET_EXTERNAL_FEED_RATE();

  _interpreter_settings.flood SET_TO (GET_EXTERNAL_FLOOD() ISNT 0) ? ON : OFF;

  _interpreter_settings.mist SET_TO (GET_EXTERNAL_MIST() ISNT 0) ? ON : OFF;

  _interpreter_settings.selected_tool_slot SET_TO GET_EXTERNAL_POCKET();

  _interpreter_settings.speed SET_TO GET_EXTERNAL_SPEED();

  _interpreter_settings.spindle_turning SET_TO GET_EXTERNAL_SPINDLE();

  _interpreter_settings.traverse_rate SET_TO GET_EXTERNAL_TRAVERSE_RATE();

  return RS274NGC_OK;
}

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

/* rs274ngc_init

Returned Value: int (RS274NGC_OK)

Side Effects:
   Many values in the _interpreter_settings structure are reset.
   Many interpreter variables are reset.
   A SET_FEED_REFERENCE canonical command call is made.
   An INIT_CANON call is made.
   write_g_codes, write_m_codes, and write_settings are called.
   reset_interp_wm is called.


Called By:
   This not called by any other function in the interpreter source file.
   It is intended to be called externally.
   It is called by interpret_from_file and interpret_from_keyboard
     in the interpreter driver.

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).

Length units are set early since the default is inches, and calling
USE_LENGTH_UNITS before extracting data from the rest of the system
will get the rest of the system to use inches.

The early current position settings are used by the stand-alone interpreter.

*/

int rs274ngc_init()
{
  CANON_VECTOR axis_offset;
  CANON_VECTOR origin_point;
  int k;

  rs274ngc_reset();

  INIT_CANON();

  _interpreter_settings.length_units SET_TO CANON_UNITS_INCHES;
  USE_LENGTH_UNITS(_interpreter_settings.length_units);

  for (k SET_TO 5161; k < 5387; k++)
    {
      _interpreter_settings.parameters[k] SET_TO 0.0;
    }
  rs274ngc_restore_parameters(
#ifdef STAND_ALONE_INTERP
DEFAULT_RS274NGC_PARAMETER_FILE,
#else
RS274NGC_PARAMETER_FILE,
#endif
                              _interpreter_settings.parameters);

  // Get axis offsets from parameters
  axis_offset.x SET_TO _interpreter_settings.parameters[5211];
  axis_offset.y SET_TO _interpreter_settings.parameters[5212];
  axis_offset.z SET_TO _interpreter_settings.parameters[5213];

  // Get origin from parameters for G54 default coordinate system
  origin_point.x SET_TO _interpreter_settings.parameters[5221];
  origin_point.y SET_TO _interpreter_settings.parameters[5222];
  origin_point.z SET_TO _interpreter_settings.parameters[5223];

  // Set the origin offsets
  SET_ORIGIN_OFFSETS(origin_point.x + axis_offset.x,
                     origin_point.y + axis_offset.y,
                     origin_point.z + axis_offset.z);

  SET_FEED_REFERENCE(CANON_XYZ);

  _textline SET_TO 0;
  _interpreter_settings.axis_offset_x SET_TO 0.0;
  _interpreter_settings.axis_offset_y SET_TO 0.0;
  _interpreter_settings.axis_offset_z SET_TO 0.0;
  _interpreter_settings.block_delete SET_TO OFF;
/*_interpreter_settings.control_mode set in rs274ngc_synch */
/*_interpreter_settings.current_slot set in rs274ngc_synch */
  _interpreter_settings.current_x SET_TO 0.0; /* reset by rs274ngc_synch */
  _interpreter_settings.current_y SET_TO 0.0; /* reset by rs274ngc_synch */
  _interpreter_settings.current_z SET_TO 0.0; /* reset by rs274ngc_synch */
  _interpreter_settings.cutter_radius_compensation SET_TO OFF;
/* cycle values do not need initialization */
  _interpreter_settings.distance_mode SET_TO MODE_ABSOLUTE;
  _interpreter_settings.feed_mode SET_TO UNITS_PER_MINUTE;
  _interpreter_settings.feed_override SET_TO ON;
/*_interpreter_settings.feed_rate set in rs274ngc_synch */
/*_interpreter_settings.flood set in rs274ngc_synch */
  _interpreter_settings.length_offset_index SET_TO 1;
/*_interpreter_settings.length_units set above */
/*_interpreter_settings.mist set in rs274ngc_synch */
  _interpreter_settings.motion_mode SET_TO G_1;
  _interpreter_settings.origin_ngc SET_TO 1;
  _interpreter_settings.axis_offset_x SET_TO axis_offset.x;
  _interpreter_settings.axis_offset_y SET_TO axis_offset.y;
  _interpreter_settings.axis_offset_z SET_TO axis_offset.z;
  _interpreter_settings.origin_offset_x SET_TO origin_point.x;
  _interpreter_settings.origin_offset_y SET_TO origin_point.y;
  _interpreter_settings.origin_offset_z SET_TO origin_point.z;
/*_interpreter_settings.parameters set above */
  _interpreter_settings.plane SET_TO CANON_PLANE_XY;
  SELECT_PLANE(_interpreter_settings.plane);
  _interpreter_settings.probe_flag SET_TO OFF;
  _interpreter_settings.program_x SET_TO UNKNOWN; /* for cutter comp */
  _interpreter_settings.program_y SET_TO UNKNOWN; /* for cutter comp */
  _interpreter_settings.retract_mode SET_TO R_PLANE;
/*_interpreter_settings.selected_tool_slot set in rs274ngc_synch */
/*_interpreter_settings.speed set in rs274ngc_synch */
  _interpreter_settings.speed_feed_mode SET_TO CANON_INDEPENDENT;
  _interpreter_settings.speed_override SET_TO ON;
  _interpreter_settings.tool_length_offset SET_TO 0.0;
/*_interpreter_settings.tool_table set in rs274ngc_synch */
  _interpreter_settings.tool_table_index SET_TO 1;
/*_interpreter_settings.traverse_rate set in rs274ngc_synch */

  write_g_codes((block_pointer)NULL, &_interpreter_settings,
                _textline, &_interpreter_active_g_codes[0]);
  write_m_codes((block_pointer)NULL, &_interpreter_settings,
                _textline, &_interpreter_active_m_codes[0]);
  write_settings((block_pointer)NULL, &_interpreter_settings,
                _textline, &_interpreter_active_settings[0]);

  // Synch rest of settings to external world
  rs274ngc_synch();

  return RS274NGC_OK;
}

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

/* rs274ngc_open

Returned Value: int (RS274NGC_OK or RS274NGC_ERROR)
   If any of the following errors occur, this returns RS274NGC_ERROR.
   Otherwise it returns RS274NGC_OK.
   1. The file cannot be opened.

Side Effects:
   The file is opened for reading and _interpreter_fp is set.
   The input program line counter, _textline, is set.
   _interpreter_filename is set.

Called By:
   This not called by any other function in the interpreter source file.
   It is intended to be called externally.
   It is called by interpret_from_file in the interpreter driver.

The manual [NCMS, page 3] discusses the use of the "%" character at the
beginning of a "tape". It is not clear whether it is intended that
every NC-code file should begin with that character. Here, we are not
requiring it. _textline is set to 0.

*/

int rs274ngc_open(     /* ARGUMENT VALUES                               */
 const char *filename) /* string: the name of the input NC-program file */
{
  static char name[] SET_TO "rs274ngc_open";

  _interpreter_fp SET_TO fopen(filename, "r");
  if (_interpreter_fp IS NULL)
    ERR_MACRO(_interpreter_linetext, name, "Unable to open file");

  _textline SET_TO 0;

  strcpy(_interpreter_filename, filename);

  return RS274NGC_OK;
}

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

/* rs274ngc_read

Returned Value: int (RS274NGC_OK, RS274NGC_EXIT, RS274NGC_ENDFILE,
                     or RS274NGC_ERROR)
   If _interpreter_fp is NULL and _interpreter_status is RS274NGC_EXIT,
   this returns RS274NGC_EXIT.
   If the end of the file is found, this returns RS274NGC_ENDFILE.
   Otherwise, if any of the following errors occur, this
   returns RS274NGC_ERROR. Otherwise, it returns RS274NGC_OK.
   1. The _interpreter_fp file pointer is NULL.
   2. read_text (which gets a line of NC code from file)
      returns RS274NGC_ERROR.
   3. read_line (which parses the line) returns RS274NGC_ERROR.
   4. The end of the file has been reached.
   5. The probe_flag is ON but the HME command queue is not empty.

Side Effects:
   If there is an error, the file is closed.
   _textline is incremented.
   The _interpreter_block is filled with data.

Called By:
   This not called by any other function in the interpreter source file.
   It is intended to be called externally.
   It is called by interpret_from_file in the driver.

This reads a line of NC-code from a file. The _interpreter_length will
be set by read_text. This will be zero if the line is blank or block
deleted. If the length is not zero, this parses the line into the
_interpreter_block.

Before reading a line of NC-code, this checks to see it the probe_flag
in the settings in ON. If so, this means the STRAIGHT_PROBE function
was called last, so data about the current position and the probe
position is updated, after checking to be sure the command queue of
the HME is empty (so that the probing is sure to have been executed).

This is not closing the file when the end of the file has been
reached. When this function returns RS274NGC_ENDFILE, rs274ngc_close
should be called.

*/

int rs274ngc_read()
{
  static char name[] SET_TO "rs274ngc_read";
  int status;

  if (_interpreter_settings.probe_flag IS ON)
    {
      if (IS_EXTERNAL_QUEUE_EMPTY() IS 0)
        {
          /* rs274ngc_reset(); */
          ERR_MACRO(_interpreter_linetext, name, "Queue is not empty after probing");
        }
      set_probe_data(&_interpreter_settings);
      _interpreter_settings.probe_flag SET_TO OFF;
    }

  if (_interpreter_fp IS NULL)
    {
      if (_interpreter_status IS RS274NGC_EXIT)
        {   /* set in call to rs274ngc_execute */
          /* rs274ngc_reset(); */
          return RS274NGC_EXIT;
        }
      else
        {
          /* rs274ngc_reset(); */
          ERR_MACRO_PASS(name);
        }
    }

  /* read the line */
  _textline++;
  status SET_TO read_text (NULL, _interpreter_fp, _interpreter_linetext,
                           _interpreter_blocktext, &_interpreter_length,
                           _interpreter_settings.block_delete);
  if ((status IS RS274NGC_ENDFILE) AND (_interpreter_block.m_modes[4] IS 1))
    return RS274NGC_ENDFILE;  /* m1 appeared on the preceding line */
  else if (status IS RS274NGC_ENDFILE)
    {
      fclose(_interpreter_fp);
      _interpreter_fp SET_TO NULL;
      /* rs274ngc_reset(); */
      ERR_MACRO(_interpreter_linetext, name, "File ended with no stopping command given");
    }
  else if (status IS RS274NGC_ERROR)
    {
      /* rs274ngc_reset(); */
      ERR_MACRO_PASS(name);
    }
  if (_interpreter_length IS 0)
    return RS274NGC_OK;

  /* parse the block */
  else if (read_line(_interpreter_blocktext, &_interpreter_block,
                     &_interpreter_settings) IS RS274NGC_ERROR)
    {
      /* rs274ngc_reset(); */
      ERR_MACRO_PASS(name);
    }
  else
    return RS274NGC_OK;
}

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

/* rs274ngc_load_tool_table()

Returned Value: RS274NGC_OK

Side Effects:
   _interpreter_settings.tool_table[] is modified.

Called By:
   rs274ngc_init().
   It is also intended to be called externally, when the tool table
   is changed.

This function calls the canonical interface function GET_EXTERNAL_TOOL_TABLE
to load the whole tool table into the _interpreter_settings.
*/

int rs274ngc_load_tool_table()
{
  int t;

  for (t SET_TO 0; t <= CANON_TOOL_MAX; t++)
    {
      _interpreter_settings.tool_table[t] SET_TO GET_EXTERNAL_TOOL_TABLE(t);
    }

  return 0;
}

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

/* rs274ngc_restore_parameters()

Returned Value: RS274NGC_OK, RS274NGC_ERROR

Side Effects:
   parameters[] array in settings structure passed (e.g.,
   _interpreter_settings.parameters[]) is modified.

Called By:
   rs274ngc_init().

This function restores the parameters from a file containing lines of
the form:

<variable number> <value>

e.g.,

5161 10.456
*/
int rs274ngc_restore_parameters(const char *filename, double parameters[])
{
  static char name[] SET_TO "rs274ngc_restore_parameters";
  FILE *infp = NULL;
  char line[256];
  int variable;
  double value;

  // open original for reading
  if (NULL == (infp = fopen(filename, "r")))
    {
      ERR_MACRO(_interpreter_linetext, name, "Cannot open file");
      return -1;
    }

  while (!feof(infp))
    {
      if (NULL == fgets(line, 256, infp))
        {
          break;
        }

      // try for a variable-value match
      if (2 == sscanf(line, "%d %lf", &variable, &value))
        {
          // write it into variable array
          if (variable <= 0 || variable >= RS274NGC_MAX_PARAMETERS)
            {
              ERR_MACRO(_interpreter_linetext, name, "Parameter number out of range");
            }
          else
            {
              parameters[variable] = value;
            }
        }
    }

  fclose(infp);

  return 0;
}

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

/* rs274ngc_save_parameters()

Returned Value: RS274NGC_OK, RS274NGC_ERROR

Side Effects:
   A file containing variable-value assignments is updated with the
   current value of the variables.

Called By:
   rs274ngc_exit().

This function saves parameters to a file containing lines of
the form:

<variable number> <value>

e.g.,

5161 10.456
*/
int rs274ngc_save_parameters(const char *filename, const double parameters[])
{
  static char name[] SET_TO "rs274ngc_save_parameters";
  FILE *infp = NULL;
  FILE *outfp = NULL;
  char line[256];
  int variable;
  double value;

  // rename as .bak
  strcpy(line, filename);
  strcat(line, RS274NGC_PARAMETER_FILE_BACKUP_SUFFIX);
  if (0 != rename(filename, line))
    {
      ERR_MACRO(_interpreter_linetext, name, "Cannot create backup file");
      return -1;
    }

  // open backup for reading
  if (NULL == (infp = fopen(line, "r")))
    {
      ERR_MACRO(_interpreter_linetext, name, "Cannot open backup file");
      return -1;
    }

  // open original for writing
  if (NULL == (outfp = fopen(filename, "w")))
    {
      ERR_MACRO(_interpreter_linetext, name, "Cannot open variable file");
      return -1;
    }

  while (!feof(infp))
    {
      if (NULL == fgets(line, 256, infp))
        {
          break;
        }

      // try for a variable-value match
      if (2 == sscanf(line, "%d %f", &variable, &value))
        {
          // overwrite with internal variable
          if (variable <= 0 || variable >= RS274NGC_MAX_PARAMETERS)
            {
              ERR_MACRO(_interpreter_linetext, name, "Parameter number out of range");
            }
          else
            {
              sprintf(line, "%d\t%f\n", variable, parameters[variable]);
            }
        }

      // write it out
      fputs(line, outfp);
    }

  fclose(infp);
  fclose(outfp);

  return 0;
}

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

/* rs274ngc_ini_load()

Returned Value: RS274NGC_OK, RS274NGC_ERROR

Side Effects:
   An INI file containing values for global variables is used to
   update the globals

Called By:
   rs274ngc_init()

The file looks like this:

[RS274NGC]
VARIABLE_FILE = rs274ngc.var

*/

#ifdef STAND_ALONE_INTERP

int rs274ngc_ini_load(const char *filename)
{
  return RS274NGC_OK;
}

#else

#include "inifile.h"            // INIFILE

int rs274ngc_ini_load(const char *filename)
{
  INIFILE inifile;
  const char *inistring;

  // open it
  if (-1 == inifile.open(filename))
    {
      return -1;
    }

  if (NULL != (inistring = inifile.find("PARAMETER_FILE", "RS274NGC")))
    {
      // found it
      strcpy(RS274NGC_PARAMETER_FILE, inistring);
    }
  else
    {
      // not found, leave RS274NGC_PARAMETER_FILE alone
    }

  // close it
  inifile.close();

  return RS274NGC_OK;
}

#endif

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

/* rs274ngc_active_g_codes

Returned Value: RS274NGC_OK

Side Effects: copies active G codes into arg array

Called By: external programs

*/

int rs274ngc_active_g_codes(int *codes)
{
  int t;

  for (t = 0; t < RS274NGC_ACTIVE_G_CODES; t++)
    {
      codes[t] = _interpreter_active_g_codes[t];
    }

  return RS274NGC_OK;
}

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

/* rs274ngc_active_m_codes

Returned Value: RS274NGC_OK

Side Effects: copies active M codes into arg array

Called By: external programs

*/

int rs274ngc_active_m_codes(int *codes)
{
  int t;

  for (t = 0; t < RS274NGC_ACTIVE_M_CODES; t++)
    {
      codes[t] = _interpreter_active_m_codes[t];
    }

  return RS274NGC_OK;
}

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

/* rs274ngc_active_settings

Returned Value: RS274NGC_OK

Side Effects: copies active F, S settings into array

Called By: external programs

*/

int rs274ngc_active_settings(double *settings)
{
  int t;

  for (t = 0; t < RS274NGC_ACTIVE_SETTINGS; t++)
    {
      settings[t] = _interpreter_active_settings[t];
    }

  return RS274NGC_OK;
}

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

---