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

* Description: interp_o_word.cc

*

*

* Author: Kenneth Lerman

* License: GPL Version 2

* System: Linux

*

* Copyright 2005 All rights reserved.

*

* Last change: Michael Haberler 7/2011

*

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

#include <boost/python/list.hpp>

#include <boost/python/tuple.hpp>

#include <boost/python/dict.hpp>

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <string.h>

#include <ctype.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <dirent.h>

#include "rs274ngc.hh"

#include "rs274ngc_return.hh"

#include "interp_return.hh"

#include "interp_internal.hh"

#include "rs274ngc_interp.hh"

#include "python_plugin.hh"

#include "interp_python.hh"

namespace bp = boost::python;

//========================================================================

// Functions for control stuff (O-words)

//========================================================================

/*

  Given the root of a directory tree and a file name,

  find the path to the file, if any.

*/

		     char *direct,  // the directory to start looking in

		     char *target,  // the name of the file to find

		     char *foundFileDirect) // where to store the result

{

    FILE *file;

    DIR *aDir;

    struct dirent *aFile;

    char targetPath[PATH_MAX+1];

        return INTERP_OK;

    }

    }

            char path[PATH_MAX+1];

            }

        }

    }

}

/*

 *  this now uses STL maps for offset access

 */

				setup_pointer settings)     /* pointer to machine settings */

{

    static char name[] = "control_save_offset";

	// already exists

	    settings->filename, settings->sequence_number,

	    block->o_name,

	    op->filename);

    }

    offset new_offset;

    // the sequence number has already been bumped, so save

    // the proper value

}

			       setup_pointer settings,   // pointer to machine settings

			       offset_pointer *op)       // pointer to offset descriptor

{

    static char name[] = "control_find_oword";

    offset_map_iterator it;

    } else {

    }

}

const char *o_ops[] = {

    "O_none",

    "O_sub",

    "O_endsub",

    "O_call",

    "O_do",

    "O_while",

    "O_if",

    "O_elseif",

    "O_else",

    "O_endif",

    "O_break",

    "O_continue",

    "O_endwhile",

    "O_return",

    "O_repeat",

    "O_endrepeat",

    "O_continue_call",

    "O_pyreturn",

};

const char *call_statenames[] = {

    "CS_NORMAL",

    "CS_REEXEC_PROLOG",

    "CS_REEXEC_PYBODY",

    "CS_REEXEC_EPILOG",

    "CS_REEXEC_PYOSUB",

};

const char *call_typenames[] = {

    "CT_NGC_OWORD_SUB",

    "CT_PYTHON_OWORD_SUB",

    "CT_REMAP",

};

			 context_pointer current_frame,

			 int call_type)

{

    int i;

    bp::list plist;

	     current_frame->subName,

	     call_typenames[call_type],

	     call_statenames[settings->call_state],

	     settings->call_level,settings->remap_level);

    case CT_NGC_OWORD_SUB:

	// copy parameters from context

	// save old values of parameters

	// save current file position in context

	// if we were skipping, no longer

		     settings->skipping_o);

	}

	    previous_frame->saved_params[i] =

	    settings->parameters[i + INTERP_FIRST_SUBROUTINE_PARAM] =

	}

	// if the previous file was NULL, mark positon as -1 so as not to

	// reopen it on return.

	} else {

	}

	// save return location

		 settings->call_level-1,

		 previous_frame->filename,

		 previous_frame->sequence_number,

		 previous_frame->position);

	    // let any  Oword sub know the number of parameters

				  (double )eblock->param_cnt,

				  OVERRIDE_READONLY));

	}

	// transfer control

	    return INTERP_ERROR;

	}

	break;

    case CT_PYTHON_OWORD_SUB:

	case CS_NORMAL:

	case CS_REEXEC_PYOSUB:

	    status = pycall(settings, current_frame, OWORD_MODULE,

			    current_frame->subName,

	    case INTERP_EXECUTE_FINISH:

	    default:

		// M73 auto-restore is of dubious value in a Python subroutine

	    }

	    break;

	}

	break;

    case CT_REMAP:

	case CS_NORMAL:

		     remap->name);

	    }

		// add_parameters will decorate kwargs as per argspec

		// if named local parameters specified

	    }

	    // fall through

	case CS_REEXEC_PROLOG:

		status = pycall(settings, current_frame, REMAP_MODULE,remap->prolog_func,

		case INTERP_EXECUTE_FINISH:

		default:

		    //settings->sequence_number = previous_frame->sequence_number;

		}

	    }

	    // fall through

	case CS_REEXEC_PYBODY:

		status = pycall(settings, current_frame, REMAP_MODULE, remap->remap_py,

		case INTERP_EXECUTE_FINISH:

		default:

		    // epilog is not supported on python body -  makes no sense

		}

	    }

	    // call the NGC remap procedure

				 CT_NGC_OWORD_SUB));

	    }

	}

    }

}

// this is executed only for NGC subs, either normal ones or part of a remap

// subs whose name is a Py callable are handled inline in execute_call()

// since there is no corresponding O_return/O_endsub to execute.

{

	     current_frame->subName,

	     call_typenames[call_type],

	     call_statenames[settings->call_state]);

    // if level is not zero, in a call

    // otherwise in a defn

    // if we were skipping, no longer

		 (eblock->o_type == O_endsub) ? "endsub" : "return",

		 settings->skipping_o);

    }

    case CT_REMAP:

	case CS_NORMAL:

   	case CS_REEXEC_EPILOG:

		status = pycall(settings, current_frame, REMAP_MODULE,

	    			cblock->executing_remap->epilog_func,

		case INTERP_EXECUTE_FINISH:

		default:

		    // leave_context() is done by falling through into CT_NGC_OWORD_SUB code

		}

	    }

	}

	// fall through to normal NGC return handling

    case CT_NGC_OWORD_SUB:

	    // restore subroutine parameters.

	    }

	    // file at this level was marked as closed, so dont reopen.

	    } else {

		}

		//!!!KL must open the new file, if changed

			    previous_frame->filename,

			    strerror(errno));

		    }

		}

			 settings->filename,previous_frame->sequence_number,

			 previous_frame->position);

	    }

	    // cleanups on return:

	    // if this was a remap frame we're done

	    }

	    } else {

		settings->sub_name = NULL;

	    }

	} else { // call_level == 0

	    // a definition

		// no longer skipping or defining

			     settings->skipping_o);

		}

	    }

	}

    }

}

//

// TESTME!!! MORE THOROUGHLY !!!KL

//

// In the past, calls had to be to predefined subs

//

// Now they don't. Do things in the following sequence:

// 1 -- if o_word is already defined, just go back to it, else

// 2 -- if there is a file with the name of the o_word,

//             open it and start skipping (as in 3, below)

// 3 -- skip to the o_word (will be an error if not found)

//

			     setup_pointer settings)   // pointer to machine settings

{

    static char name[] = "control_back_to";

    char newFileName[PATH_MAX+1];

    FILE *newFP;

    offset_map_iterator it;

    offset_pointer op;

	    (settings->file_pointer == NULL))  {

	}

	    // open the new file...

	    // set the line number

            }

		// close the old file...

	    } else {

	    }

	}

	    fseek(settings->file_pointer,

	}

    }

	// close the old file...

        }

    } else {

		 dirname);

    }

}

			      const char *name, bool osub)

{

    case RET_YIELD:

	// yield <integer> was executed

	break;

    case RET_STOPITERATION:  // a bare 'return' in a generator - treat as INTERP_OK

    case RET_NONE:

	break;

    case RET_DOUBLE:

	} else {

			name, active_frame->pystuff.impl->py_returned_double);

	}

    case RET_INT:

	} else

    case RET_ERRORMSG:

	status = INTERP_ERROR;

	break;

    }

}

// prepare a new call frame.

{

	     settings->call_level, settings->call_level+1,

	     call_typenames[block->call_type]);

    }

    // mark frame for finishing remap

}

{

    }

	     settings->call_level, settings->call_level-1,

	     call_typenames[leaving_frame->call_type],

	     call_statenames[settings->call_state]);

		     (CONTEXT_RESTORE_ON_RETURN|CONTEXT_VALID)) ==

		    (CONTEXT_RESTORE_ON_RETURN|CONTEXT_VALID))) {

	// a valid previous context was marked by an M73 as auto-restore

    	// NB: this means an M71 invalidate context will prevent an

    	// auto-restore on return/endsub

    }

    return INTERP_OK;

}

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

/* convert_control_functions

Returned Value: int (INTERP_OK)

Side effects:

   Changes the flow of control.

Called by: execute

Calls: control_skip_to

       control_back_to

       control_save_offset

*/

				      setup_pointer settings)  // pointer to machine settings

{

    context_pointer current_frame;

    // must skip if skipping

	return INTERP_OK;

    }

	return INTERP_OK;

    }

    // if skipping_o was set, we are now on a line which contains that O-word.

    // if skipping_to_sub was set, we are now on the 'O-name sub' definition line.

    case O_none:

	// not an error because we use this to signal that we

	// are not evaluating functions

	break;

    case O_sub:

	// if the level is not zero, this is a call

	// not the definition

	// if we were skipping, no longer

	    // skipping to a sub means that we must define this now

	}

		     settings->parameters[1],

		     settings->parameters[2],

		     settings->parameters[3]);

	} else {

	    // a definition. We're on the O<name> sub line.

	    // start skipping to the corresponding ensub.

	}

	break;

    case O_endsub:

    case O_return:

	    // detect a standalone 'o<label> return|endsub'

		 settings->sequence_number, settings->linetext);

	}

	// proper label semantics (only refer to defined sub, within sub defn etc)

	// is handled in read_o() for return & endsub

			   current_frame->call_type));

	break;

    case O_call:

	// only enter new frame if not reexecuting a Python handler

	// which returned INTERP_EXECUTE_FINISH

	}

			 current_frame->call_type));

	break;

      case O_do:

	// if we were skipping, no longer

	// save the loop point

	// we hit this again on loop back -- so test first

	    {

		// save offset if not found in offset table

	    }

	break;

    case O_repeat:

		    settings->sequence_number,

		    settings->linetext, op->sequence_number + 1);

	} else

	// if we were skipping, no longer

	// test if not already seen OR

	// if seen and this is a repeat

	    // this is the beginning of a 'repeat' loop

	    // add it to the table if not already there

	    // note the repeat count.  it should only be calculated at the

	    // start of the repeat loop.

		op->repeat_count =

	    // are we still repeating?

		// execute forward

			 block->o_name, settings->test_value);

		// one less repeat remains

	    } else {

		// skip forward

			 block->o_name);

		// cause the repeat count to be recalculated

		// if we do this loop again

	    }

	}

	break;

    case O_while:

		    settings->sequence_number,

		    settings->linetext, op->sequence_number + 1);

	} else

	    // record only if this is a while/endwhile loop

	// if we were skipping, no longer

	// test if not already seen OR

	// if seen and this is a while (alternative is that it is a do)

	    // this is the beginning of a 'while' loop

	    // add it to the table if not already there

	    // test the condition

			 block->o_name);

	    else  {

		// false -  skip forward

			 block->o_name);

	    }

	} else {

	    // this is the end of a 'do'

	    // test the condition

		// true - loop on back

			 block->o_name);

	    } else {

		// false

			 block->o_name);

	    }

	}

	break;

    case O_if:

		    settings->sequence_number, op->sequence_number + 1,

		    settings->linetext);

	} else

	    //true

		     block->o_name);

	} else {

	    //false

		     block->o_name);

	}

	break;

    case O_elseif:

		settings->sequence_number, settings->linetext);

		settings->sequence_number, settings->linetext,

		o_ops[op->type] + 2, op->sequence_number + 1);

	    //!!!KL -- the if conditions here say that we were skipping

	    //!!!KL but that the target o_name is not ours.

	    //!!!KL so we should continue skipping -- that's not what

	    //!!!KL the code below says.

	    // mah: so?

#if 0

	    // we were not skipping -- start skipping

	    logOword("start skipping forward: [%s] in 'elseif'",

		     block->o_name);

	    settings->skipping_o = block->o_name;

	    settings->skipping_start = settings->sequence_number;

	    return INTERP_OK;

#else

	    // we were skipping -- continue skipping

		     block->o_name);

	    return INTERP_OK;

#endif

	}

	// we were skipping

	// but were we ever not skipping

	    // we have already executed, keep on skipping

		     "skipping forward: [%s] in 'elseif'",

		     block->o_name);

	}

	    //true -- start executing

		     block->o_name);

	} else {

	    //false

		     block->o_name);

	}

	break;

    case O_else:

		settings->sequence_number, settings->linetext);

		settings->sequence_number, settings->linetext,

		o_ops[op->type] + 2, op->sequence_number + 1);

	// were we ever not skipping

	    // we have already executed, skip

		     "skipping forward: [%s] in 'else'",

		     block->o_name);

	}

	    // we were skipping so stop skipping

		     block->o_name);

	} else	{

	    // we were not skipping -- so skip

		     block->o_name);

	}

	break;

    case O_endif:

		settings->sequence_number, settings->linetext);

		settings->sequence_number, block->o_name,

		o_ops[op->type] + 2, op->sequence_number + 1, settings->linetext);

	// stop skipping if we were

		 block->o_name);

	// the KEY -- outside if clearly must have executed

	// or this would not have executed

    case O_break:

		settings->sequence_number, settings->linetext);

		settings->sequence_number, settings->linetext,

		o_ops[op->type] + 2, op->sequence_number + 1);

      // start skipping

	      block->o_name);

      break;

    case O_continue:

		settings->sequence_number, settings->linetext);

		settings->sequence_number, settings->linetext,

		o_ops[op->type] + 2, op->sequence_number + 1);

	// if already skipping, do nothing

		     block->o_name);

	    return INTERP_OK;

	}

	// start skipping

		 block->o_name);

	break;

    case O_endrepeat:

    case O_endwhile:

		settings->sequence_number, settings->linetext);

		settings->sequence_number, settings->linetext,

		o_ops[op->type] + 2, op->sequence_number + 1);

	// end of a while loop

	    // we were skipping, so this is the end

		// loop on back

			 block->o_name);

	    } else {

		// not doing continue, we are done

			 block->o_name);

		return INTERP_OK;

	    }

	} else {

	    // loop on back

		     block->o_name);

	}

	break;

    default:

	// FIXME !!!KL should probably be an error

	return INTERP_ERROR;

	break;

    }

    // return status;

    return INTERP_OK;

//========================================================================

// End of functions for control stuff (O-words)

//========================================================================