emcCommandBuffer->msg2str(cmd));    }    switch (cmd->type) {	// general commands    case EMC_OPERATOR_ERROR_TYPE:	retval = emcOperatorError(((EMC_OPERATOR_ERROR *) cmd)->id,				  ((EMC_OPERATOR_ERROR *) cmd)->error);	break;    case EMC_OPERATOR_TEXT_TYPE:	retval = emcOperatorText(((EMC_OPERATOR_TEXT *) cmd)->id,				 ((EMC_OPERATOR_TEXT *) cmd)->text);	break;    case EMC_OPERATOR_DISPLAY_TYPE:	retval = emcOperatorDisplay(((EMC_OPERATOR_DISPLAY *) cmd)->id,				    ((EMC_OPERATOR_DISPLAY *) cmd)->				    display);	break;    case EMC_SYSTEM_CMD_TYPE:	retval = emcSystemCmd(((EMC_SYSTEM_CMD *) cmd)->string);	break;	// axis commands    case EMC_AXIS_DISABLE_TYPE:	disable_msg = (EMC_AXIS_DISABLE *) cmd;	retval = emcAxisDisable(disable_msg->axis);	break;    case EMC_AXIS_ENABLE_TYPE:	enable_msg = (EMC_AXIS_ENABLE *) cmd;	retval = emcAxisEnable(enable_msg->axis);	break;    case EMC_AXIS_HOME_TYPE:	home_msg = (EMC_AXIS_HOME *) cmd;	retval = emcAxisHome(home_msg->axis);	break;    case EMC_AXIS_JOG_TYPE:	jog_msg = (EMC_AXIS_JOG *) cmd;	retval = emcAxisJog(jog_msg->axis, jog_msg->vel);	break;    case EMC_AXIS_ABORT_TYPE:	axis_abort_msg = (EMC_AXIS_ABORT *) cmd;	retval = emcAxisAbort(axis_abort_msg->axis);	break;    case EMC_AXIS_INCR_JOG_TYPE:	incr_jog_msg = (EMC_AXIS_INCR_JOG *) cmd;	retval = emcAxisIncrJog(incr_jog_msg->axis,				incr_jog_msg->incr, incr_jog_msg->vel);	break;    case EMC_AXIS_ABS_JOG_TYPE:	abs_jog_msg = (EMC_AXIS_ABS_JOG *) cmd;	retval = emcAxisAbsJog(abs_jog_msg->axis,			       abs_jog_msg->pos, abs_jog_msg->vel);	break;/*! \todo Another #if 0 */#if 0    case EMC_AXIS_SET_GAINS_TYPE:	set_gains_msg = (EMC_AXIS_SET_GAINS *) cmd;	retval = emcAxisSetGains(set_gains_msg->axis,				 set_gains_msg->p,				 set_gains_msg->i,				 set_gains_msg->d,				 set_gains_msg->ff0,				 set_gains_msg->ff1,				 set_gains_msg->ff2,				 set_gains_msg->bias,				 set_gains_msg->maxError,				 set_gains_msg->deadband);	break;#endif    case EMC_AXIS_SET_BACKLASH_TYPE:	set_backlash_msg = (EMC_AXIS_SET_BACKLASH *) cmd;	retval =	    emcAxisSetBacklash(set_backlash_msg->axis,			       set_backlash_msg->backlash);	break;    case EMC_AXIS_SET_HOMING_PARAMS_TYPE:	set_homing_params_msg = (EMC_AXIS_SET_HOMING_PARAMS *) cmd;	retval = emcAxisSetHomingParams(set_homing_params_msg->axis,					set_homing_params_msg->home,					set_homing_params_msg->offset,					set_homing_params_msg->search_vel,					set_homing_params_msg->latch_vel,					set_homing_params_msg->use_index,					set_homing_params_msg->					ignore_limits);	break;/*! \todo Another #if 0 */#if 0    case EMC_AXIS_SET_CYCLE_TIME_TYPE:	set_cycle_time_msg = (EMC_AXIS_SET_CYCLE_TIME *) cmd;	retval = emcAxisSetCycleTime(set_cycle_time_msg->axis,				     set_cycle_time_msg->cycleTime);	break;    case EMC_AXIS_SET_INPUT_SCALE_TYPE:	set_input_scale_msg = (EMC_AXIS_SET_INPUT_SCALE *) cmd;	retval = emcAxisSetInputScale(set_input_scale_msg->axis,				      set_input_scale_msg->scale,				      set_input_scale_msg->offset);	break;    case EMC_AXIS_SET_OUTPUT_SCALE_TYPE:	set_output_scale_msg = (EMC_AXIS_SET_OUTPUT_SCALE *) cmd;	retval = emcAxisSetOutputScale(set_output_scale_msg->axis,				       set_output_scale_msg->scale,				       set_output_scale_msg->offset);	break;#endif    case EMC_AXIS_SET_FERROR_TYPE:	set_ferror_msg = (EMC_AXIS_SET_FERROR *) cmd;	retval = emcAxisSetFerror(set_ferror_msg->axis,				  set_ferror_msg->ferror);	break;    case EMC_AXIS_SET_MIN_FERROR_TYPE:	set_min_ferror_msg = (EMC_AXIS_SET_MIN_FERROR *) cmd;	retval = emcAxisSetMinFerror(set_min_ferror_msg->axis,				     set_min_ferror_msg->ferror);	break;    case EMC_AXIS_SET_MAX_POSITION_LIMIT_TYPE:	set_max_limit_msg = (EMC_AXIS_SET_MAX_POSITION_LIMIT *) cmd;	retval = emcAxisSetMaxPositionLimit(set_max_limit_msg->axis,					    set_max_limit_msg->limit);	break;    case EMC_AXIS_SET_MIN_POSITION_LIMIT_TYPE:	set_min_limit_msg = (EMC_AXIS_SET_MIN_POSITION_LIMIT *) cmd;	retval = emcAxisSetMinPositionLimit(set_min_limit_msg->axis,					    set_min_limit_msg->limit);	break;    case EMC_AXIS_HALT_TYPE:	axis_halt_msg = (EMC_AXIS_HALT *) cmd;	retval = emcAxisHalt(axis_halt_msg->axis);	break;    case EMC_AXIS_OVERRIDE_LIMITS_TYPE:	axis_lim_msg = (EMC_AXIS_OVERRIDE_LIMITS *) cmd;	retval = emcAxisOverrideLimits(axis_lim_msg->axis);	break;/*! \todo Another #if 0 */#if 0    case EMC_AXIS_SET_OUTPUT_TYPE:	axis_output_msg = (EMC_AXIS_SET_OUTPUT *) cmd;	retval = emcAxisSetOutput(axis_output_msg->axis,				  axis_output_msg->output);	break;#endif    case EMC_AXIS_LOAD_COMP_TYPE:	axis_load_comp_msg = (EMC_AXIS_LOAD_COMP *) cmd;	retval = emcAxisLoadComp(axis_load_comp_msg->axis,				 axis_load_comp_msg->file);	break;    case EMC_AXIS_ALTER_TYPE:	axis_alter_msg = (EMC_AXIS_ALTER *) cmd;	retval = emcAxisAlter(axis_alter_msg->axis, axis_alter_msg->alter);	break;/*! \todo Another #if 0 */#if 0    case EMC_AXIS_SET_STEP_PARAMS_TYPE:	set_step_params_msg = (EMC_AXIS_SET_STEP_PARAMS *) cmd;	retval = emcAxisSetStepParams(set_step_params_msg->axis,				      set_step_params_msg->setup_time,				      set_step_params_msg->hold_time);	break;#endif	// traj commands    case EMC_TRAJ_SET_SCALE_TYPE:	emcTrajSetScaleMsg = (EMC_TRAJ_SET_SCALE *) cmd;	retval = emcTrajSetScale(emcTrajSetScaleMsg->scale);	break;    case EMC_TRAJ_SET_VELOCITY_TYPE:	emcTrajSetVelocityMsg = (EMC_TRAJ_SET_VELOCITY *) cmd;	retval = emcTrajSetVelocity(emcTrajSetVelocityMsg->velocity,			emcTrajSetVelocityMsg->ini_maxvel);	break;    case EMC_TRAJ_SET_ACCELERATION_TYPE:	emcTrajSetAccelerationMsg = (EMC_TRAJ_SET_ACCELERATION *) cmd;	retval = emcTrajSetAcceleration(emcTrajSetAccelerationMsg->acceleration);	break;    case EMC_TRAJ_LINEAR_MOVE_TYPE:	emcTrajLinearMoveMsg = (EMC_TRAJ_LINEAR_MOVE *) cmd;	retval = emcTrajLinearMove(emcTrajLinearMoveMsg->end, emcTrajLinearMoveMsg->type);	break;    case EMC_TRAJ_CIRCULAR_MOVE_TYPE:	emcTrajCircularMoveMsg = (EMC_TRAJ_CIRCULAR_MOVE *) cmd;	retval = emcTrajCircularMove(emcTrajCircularMoveMsg->end,				     emcTrajCircularMoveMsg->center,				     emcTrajCircularMoveMsg->normal,				     emcTrajCircularMoveMsg->turn,                                     emcTrajCircularMoveMsg->type);	break;    case EMC_TRAJ_PAUSE_TYPE:	retval = emcTrajPause();	break;    case EMC_TRAJ_RESUME_TYPE:	retval = emcTrajResume();	break;    case EMC_TRAJ_ABORT_TYPE:	retval = emcTrajAbort();	break;    case EMC_TRAJ_DELAY_TYPE:	emcTrajDelayMsg = (EMC_TRAJ_DELAY *) cmd;#if defined(LINUX_KERNEL_2_2)	// load the timeout delta clock	taskExecDelayTimeout = emcTrajDelayMsg->delay;#else	// set the timeout clock to expire at 'now' + delay time	taskExecDelayTimeout = etime() + emcTrajDelayMsg->delay;#endif	retval = 0;	break;    case EMC_TRAJ_SET_TERM_COND_TYPE:	emcTrajSetTermCondMsg = (EMC_TRAJ_SET_TERM_COND *) cmd;	retval = emcTrajSetTermCond(emcTrajSetTermCondMsg->cond, emcTrajSetTermCondMsg->tolerance);	break;    case EMC_TRAJ_SET_SPINDLESYNC_TYPE:        emcTrajSetSpindlesyncMsg = (EMC_TRAJ_SET_SPINDLESYNC *) cmd;        retval = emcTrajSetSpindleSync(emcTrajSetSpindlesyncMsg->spindlesync);        break;    case EMC_TRAJ_SET_OFFSET_TYPE:	// update tool offset	emcStatus->task.toolOffset.tran.z =	    ((EMC_TRAJ_SET_OFFSET *) cmd)->offset.tran.z;	retval = 0;	break;    case EMC_TRAJ_SET_ORIGIN_TYPE:	// struct-copy program origin	emcStatus->task.origin = ((EMC_TRAJ_SET_ORIGIN *) cmd)->origin;	retval = 0;	break;/*! \todo Another #if 0 */#if 0    case EMC_TRAJ_SET_PROBE_INDEX_TYPE:	retval =	    emcTrajSetProbeIndex(((EMC_TRAJ_SET_PROBE_INDEX *) cmd)->				 index);	break;    case EMC_TRAJ_SET_PROBE_POLARITY_TYPE:	retval =	    emcTrajSetProbePolarity(((EMC_TRAJ_SET_PROBE_POLARITY *) cmd)->				    polarity);	break;#endif    case EMC_TRAJ_CLEAR_PROBE_TRIPPED_FLAG_TYPE:	retval = emcTrajClearProbeTrippedFlag();	break;    case EMC_TRAJ_PROBE_TYPE:	retval = emcTrajProbe(((EMC_TRAJ_PROBE *) cmd)->pos);	break;    case EMC_TRAJ_SET_TELEOP_ENABLE_TYPE:	if (((EMC_TRAJ_SET_TELEOP_ENABLE *) cmd)->enable) {	    retval = emcTrajSetMode(EMC_TRAJ_MODE_TELEOP);	} else {	    retval = emcTrajSetMode(EMC_TRAJ_MODE_FREE);	}	break;    case EMC_TRAJ_SET_TELEOP_VECTOR_TYPE:	retval =	    emcTrajSetTeleopVector(((EMC_TRAJ_SET_TELEOP_VECTOR *) cmd)->				   vector);	break;    case EMC_MOTION_SET_AOUT_TYPE:	retval = emcMotionSetAout(((EMC_MOTION_SET_AOUT *) cmd)->index,				  ((EMC_MOTION_SET_AOUT *) cmd)->start,				  ((EMC_MOTION_SET_AOUT *) cmd)->end,				  ((EMC_MOTION_SET_AOUT *) cmd)->now);	break;    case EMC_MOTION_SET_DOUT_TYPE:	retval = emcMotionSetDout(((EMC_MOTION_SET_DOUT *) cmd)->index,				  ((EMC_MOTION_SET_DOUT *) cmd)->start,				  ((EMC_MOTION_SET_DOUT *) cmd)->end,				  ((EMC_MOTION_SET_DOUT *) cmd)->now);	break;    case EMC_SET_DEBUG_TYPE:	/* set the debug level here */	EMC_DEBUG = ((EMC_SET_DEBUG *) cmd)->debug;	/* and in IO and motion */	emcIoSetDebug(EMC_DEBUG);	emcMotionSetDebug(EMC_DEBUG);	/* and reflect it in the status-- this isn't updated continually */	emcStatus->debug = EMC_DEBUG;	break;	// unimplemented ones	// IO commands    case EMC_SPINDLE_ON_TYPE:	spindle_on_msg = (EMC_SPINDLE_ON *) cmd;	retval = emcSpindleOn(spindle_on_msg->speed);	break;    case EMC_SPINDLE_OFF_TYPE:	retval = emcSpindleOff();	break;    case EMC_SPINDLE_BRAKE_RELEASE_TYPE:	retval = emcSpindleBrakeRelease();	break;    case EMC_SPINDLE_INCREASE_TYPE:	retval = emcSpindleIncrease();	break;    case EMC_SPINDLE_DECREASE_TYPE:	retval = emcSpindleDecrease();	break;    case EMC_SPINDLE_CONSTANT_TYPE:	retval = emcSpindleConstant();	break;    case EMC_SPINDLE_BRAKE_ENGAGE_TYPE:	retval = emcSpindleBrakeEngage();	break;    case EMC_COOLANT_MIST_ON_TYPE:	retval = emcCoolantMistOn();	break;    case EMC_COOLANT_MIST_OFF_TYPE:	retval = emcCoolantMistOff();	break;    case EMC_COOLANT_FLOOD_ON_TYPE:	retval = emcCoolantFloodOn();	break;    case EMC_COOLANT_FLOOD_OFF_TYPE:	retval = emcCoolantFloodOff();	break;    case EMC_LUBE_ON_TYPE:	retval = emcLubeOn();	break;    case EMC_LUBE_OFF_TYPE:	retval = emcLubeOff();	break;    case EMC_TOOL_PREPARE_TYPE:	tool_prepare_msg = (EMC_TOOL_PREPARE *) cmd;	retval = emcToolPrepare(tool_prepare_msg->tool);	break;    case EMC_TOOL_LOAD_TYPE:	retval = emcToolLoad();	break;    case EMC_TOOL_UNLOAD_TYPE:	retval = emcToolUnload();	break;    case EMC_TOOL_LOAD_TOOL_TABLE_TYPE:	load_tool_table_msg = (EMC_TOOL_LOAD_TOOL_TABLE *) cmd;	retval = emcToolLoadToolTable(load_tool_table_msg->file);	break;    case EMC_TOOL_SET_OFFSET_TYPE:	emc_tool_set_offset_msg = (EMC_TOOL_SET_OFFSET *) cmd;	retval = emcToolSetOffset(emc_tool_set_offset_msg->tool,				  emc_tool_set_offset_msg->length,				  emc_tool_set_offset_msg->diameter);	break;	// task commands    case EMC_TASK_INIT_TYPE:	retval = emcTaskInit();	break;    case EMC_TASK_ABORT_TYPE:	/*! \todo FIXME-- duplicate code for abort,	   also near end of main, when aborting on subordinate errors,	   and in emcTaskExecute() */	// abort everything	emcTaskAbort();	// clear out the pending command	emcTaskCommand = 0;	interp_list.clear();	// clear out the interpreter state	emcStatus->task.interpState = EMC_TASK_INTERP_IDLE;	emcStatus->task.execState = EMC_TASK_EXEC_DONE;	stepping = 0;	steppingWait = 0;	// now queue up command to resynch interpreter	emcTaskQueueCommand(&taskPlanSynchCmd);	// without emcTaskPlanClose(), a new run command resumes at	// aborted line-- feature that may be considered later	{	    int was_open = taskplanopen;	    emcTaskPlanClose();	    if (EMC_DEBUG & EMC_DEBUG_INTERP && was_open) {		rcs_print("emcTaskPlanClose() called at %s:%d\n", __FILE__,			  __LINE__);	    }	}	retval = 0;	break;	// mode and state commands    case EMC_TASK_SET_MODE_TYPE:	mode_msg = (EMC_TASK_SET_MODE *) cmd;	if (mode_msg->mode == EMC_TASK_MODE_MANUAL &&	    emcStatus->task.mode != EMC_TASK_MODE_MANUAL) {	    // leaving auto or mdi mode for manual	    /*! \todo FIXME-- duplicate code for abort,	       also near end of main, when aborting on subordinate errors,	       and in emcTaskExecute() */	    // abort everything	    emcTaskAbort();	    // without emcTaskPlanClose(), a new run command resumes at	    // aborted line-- feature that may be considered later	    {		int was_open = taskplanopen;		emcTaskPlanClose();		if (EMC_DEBUG & EMC_DEBUG_INTERP && was_open) {		    rcs_print("emcTaskPlanClose() called at %s:%d\n",