/**
 * \brief execute a subcommand
 */
void	guiderportcommand::operator()(const std::string& /* commandname */,
		const std::vector<std::string>& arguments) {
	debug(LOG_DEBUG, DEBUG_LOG, 0, "guiderport command");

	if (arguments.size() < 2) {
		throw command_error("guiderport command requires 2 arguments");
	}

	std::string	guiderportid = arguments[0];
	std::string	subcommandname = arguments[1];

	if (subcommandname == "activate") {
		activate(guiderportid, arguments);
		return;
	}

	if (subcommandname == "release") {
		release(guiderportid, arguments);
		return;
	}

	if (subcommandname == "assign") {
		assign(guiderportid, arguments);
		return;
	}

	throw command_error("guiderport subcommand not known");

}
void	filterwheelcommand::operator()(const std::string& /* commandname */,
		const std::vector<std::string>& arguments) {
	if (arguments.size() < 2) {
		throw command_error("filterwheel command requires 2 arguments");
	}
	std::string	filterwheelid = arguments[0];
	std::string	subcommandname = arguments[1];
	debug(LOG_DEBUG, DEBUG_LOG, 0,
		"filterwheel command for FW %s, subcommand %s",
		filterwheelid.c_str(), subcommandname.c_str());
	if (subcommandname == "release") {
		release(filterwheelid, arguments);
		return;
	}
	if (subcommandname == "assign") {
		assign(filterwheelid, arguments);
		return;
	}
	Filterwheels	filterwheels;
	FilterwheelWrapper	filterwheel
		= filterwheels.byname(filterwheelid);
	if (subcommandname == "info") {
		info(filterwheel, arguments);
		return;
	}
	if (subcommandname == "position") {
		position(filterwheel, arguments);
		return;
	}
	if (subcommandname == "wait") {
		wait(filterwheel, arguments);
		return;
	}
	throw command_error("unknown command");
}
/**
 * \brief start command
 *
 * This command initiates a calibration or guiding process. The command
 * takes an optional argument for the focallength or the gain
 */
void	guidercommand::start(GuiderWrapper& guider,
		const std::vector<std::string>& arguments) {
	if (arguments.size() < 3) {
		throw command_error("start command requires 2 arguments");
	}
	std::string	what = arguments[2];
	if (what == "calibration") {
		float	focallength = 0.600;
		if (arguments.size() >= 4) {
			focallength = stod(arguments[3]);
			debug(LOG_DEBUG, DEBUG_LOG, 0, "using focal length %f",
				focallength);
		}
		guider->startCalibration(focallength);
		return;
	}
	if (what == "guiding") {
		if (guider->getState() == Astro::Guider::GUIDER_GUIDING) {
			std::cout << "already guiding, ignored" << std::endl;
			return;
		}
		double	interval = 10;
		if (arguments.size() >= 4) {
			interval = stod(arguments[3]);
		}
		interval = std::max(1., interval);
		guider->startGuiding(interval);
		return;
	}
}
/**
 * \brief calibration command
 *
 * This command can be used to force a calibration, without actually going
 * through the calibration process on the server side. This allows to
 * reuse calibration settings when the next guide process is based on a
 * guide star close to the one previously used.
 */
void	guidercommand::calibration(GuiderWrapper& guider,
		const std::vector<std::string>& arguments) {
	if (arguments.size() < 3) {
		throw command_error("calibration command requires an argument");
	}
	long	cal = stod(arguments[2]);
	guider->useCalibration(cal);
}
/**
 * \brief Set exposure time command
 *
 * This command allows to change the exposure time
 */
void	guidercommand::exposuretime(GuiderWrapper& guider,
		const std::vector<std::string>& arguments) {
	if (arguments.size() < 3) {
		throw command_error("exposure time missing");
	}
	Astro::Exposure	exposure = guider->getExposure();
	exposure.exposuretime = stof(arguments[2]);
	guider->setExposure(exposure);
}
void	sleepcommand::operator()(const std::string& /* commandname */,
		const std::vector<std::string>& arguments) {
	if (arguments.size() < 1) {
		throw command_error("sleep command requires time argument");
	}

	std::string	timestring = arguments[0];
	useconds_t	sleeptime = 1000000 * stof(timestring);
	usleep(sleeptime);
}
void	filterwheelcommand::assign(const std::string& filterwheelid,
		const std::vector<std::string>& arguments) {
	debug(LOG_DEBUG, DEBUG_LOG, 0, "assign %s", filterwheelid.c_str());
	try {
		Filterwheels	filterwheels;
		filterwheels.assign(filterwheelid, arguments);
	} catch (std::exception& x) {
		throw command_error(x.what());
	}
}
/**
 * \brief star command
 *
 * This command sets the star point. The star point is used as a reference
 * during calibration, the calibration computes offsets from this point.
 * The guiding process then guides the telescope in such a way that the
 * guide star is at this position as precisely as possible.
 */
void	guidercommand::star(GuiderWrapper& guider,
		const std::vector<std::string>& arguments) {
	if (arguments.size() < 4) {
		throw command_error("star coordinates missing");
	}
	Astro::Point	point;
	point.x = stoi(arguments[2]);
	point.y = stoi(arguments[3]);
	guider->setStar(point);
}
/**
 * \brief size command
 *
 * This command sets the size of the rectangle to track the guide star
 */
void	guidercommand::size(GuiderWrapper& guider,
		const std::vector<std::string>& arguments) {
	if (arguments.size() < 4) {
		throw command_error("viewport window missing");
	}
	Astro::Exposure	exposure = guider->getExposure();
	exposure.frame.size.width = stoi(arguments[2]);
	exposure.frame.size.height = stoi(arguments[3]);
	guider->setExposure(exposure);
}
/**
 * \brief Binning command
 *
 * This command allows to change the binning mode of the guiding exposure.
 * This is only reasonable if the guide camera has rather small pixels.
 */
void	guidercommand::binning(GuiderWrapper& guider,
		const std::vector<std::string>& arguments) {
	if (arguments.size() < 4) {
		throw command_error("binning mode missing");
	}
	Astro::Exposure	exposure = guider->getExposure();
	exposure.mode.x = stoi(arguments[2]);
	exposure.mode.y = stoi(arguments[3]);
	guider->setExposure(exposure);
}
示例#11
0
command_fn find_command_fn (const string& cmd) {
   // Note: value_type is pair<const key_type, mapped_type>
   // So: iterator->first is key_type (string)
   // So: iterator->second is mapped_type (command_fn)
   const auto result = cmd_hash.find (cmd);
   if (result == cmd_hash.end()) {
      throw command_error (cmd + ": no such function");
   }
   return result->second;
}
示例#12
0
 void on_message(connection_ptr connection,websocketpp::message::data_ptr msg) {
     typename std::set<connection_ptr>::iterator it;
     
     wscmd::cmd command = wscmd::parse(msg->get_payload());
     
     if (command.command == "close") {
         handle_close(connection,command);
     } else {
         command_error(connection,"Invalid Command");
     }
 }
示例#13
0
void fn_cat (inode_state& state, const wordvec& words){
   DEBUGF ('c', state);
   DEBUGF ('c', words);
   string filename = *(words.end()-1);
   inode_ptr ogcwd = state.getCwd();
   inode_ptr res = resolvePath(words[1], state.getCwd());
   if (res == nullptr){
      throw command_error ("cat: " + filename + ": file does not exist");
      return; }
   if (res->isDirectory()) return; //error here
   cout << res->getContents()->readfile() << endl;
}
示例#14
0
static void help() {
    int i;
    char *tok = strtok(NULL, DELIMS);
    if (tok != NULL) {
        Command *c = find_command(tok);
        if (c != NULL)
            printf("%s\n", c->help);
        else
            command_error(tok);
        return;
    }

    for (i = 0; commands[i].name != NULL; ++i)
        printf("%s: %s\n", commands[i].name, commands[i].help);
}
void	guiderfactorycommand::operator()(const std::string& /* command */,
		const std::vector<std::string>& arguments) {
	if (arguments.size() < 2) {
		throw command_error("guiderfactory command requires more "
			"arguments");
	}
	std::string	guiderid = arguments[0];
	std::string	subcommand = arguments[1];
	debug(LOG_DEBUG, DEBUG_LOG, 0, "guiderid: %s", guiderid.c_str());

	if (subcommand == "release") {
		release(guiderid, arguments);
		return;
	}

	if (subcommand == "assign") {
		assign(guiderid, arguments);
		return;
	}
}
/**
 * \brief wait command
 *
 * This command waits for the completion of the calibration process on the
 * server. It does not use the waitCalibration method, because this would
 * block a thread on the server side.
 */
void	guidercommand::wait(GuiderWrapper& guider,
		const std::vector<std::string>& arguments) {
	if (arguments.size() < 3) {
		throw command_error("stop command requires 2 arguments");
	}
	std::string	what = arguments[2];
	double	timeout = 60;
	if (arguments.size() >= 4) {
		timeout = stod(arguments[3]);
	}
	double	timeouttime = astro::Timer::gettime() + timeout;

	if (what == "calibration") {
		while ((guider->getState() == Astro::Guider::GUIDER_CALIBRATING)
			&& (astro::Timer::gettime() < timeouttime)) {
			usleep(1000000);
		}
		switch (guider->getState()) {
		case Astro::Guider::GUIDER_CALIBRATED:
			std::cout << "calibration complete" << std::endl;
			break;
		default:
			std::cout << "calibration failed" << std::endl;
			break;
		}
		return;
	}
	if (what == "guiding") {
		while ((guider->getState() == Astro::Guider::GUIDER_GUIDING)
			&& (astro::Timer::gettime() < timeouttime)) {
			usleep(1000000);
		}
		if (guider->getState() == Astro::Guider::GUIDER_GUIDING) {
			std::cout << "still guiding" << std::endl;
		}
		return;
	}
}
/**
 * \brief stop command
 *
 * The stop command can be used to stop a calibraiton or guiding process.
 */
void	guidercommand::stop(GuiderWrapper& guider,
		const std::vector<std::string>& arguments) {
	if (arguments.size() < 3) {
		throw command_error("start command requires 2 arguments");
	}
	std::string	what = arguments[2];
	if (what == "calibration") {
		if (guider->getState() != Astro::Guider::GUIDER_CALIBRATING) {
			std::cout << "not currently calibrating" << std::endl;
			return;
		}
		guider->cancelCalibration();
		return;
	}
	if (what == "guiding") {
		if (guider->getState() != Astro::Guider::GUIDER_GUIDING) {
			std::cout << "not currently guiding" << std::endl;
			return;
		}
		guider->stopGuiding();
		return;
	}
}
示例#18
0
int
_start (int a1, int a2)
{
	char buf[100];

	for (;;) {
		printf ("sendexample> ");
		lineinput (buf, 100);
		switch (buf[0]) {
		case 'h':
			print_help (buf);
			break;
		case 's':
			sendex (buf);
			break;
		case 'q':
			exitprocess (0);
			break;
		default:
			command_error ();
			break;
		}
	}
}
/**
 * \brief Main command interpreter function
 *
 * This operator analyzes the command arguments and calls the appropriate
 * subcommand method.
 */
void	guidercommand::operator()(const std::string& /* command */,
		const std::vector<std::string>& arguments) {
	if (arguments.size() < 2) {
		throw command_error("guider command requires more "
			"arguments");
	}
	std::string	guiderid = arguments[0];
	std::string	subcommand = arguments[1];
	debug(LOG_DEBUG, DEBUG_LOG, 0, "guiderid: %s", guiderid.c_str());

	Guiders	guiders;
	GuiderWrapper	guider = guiders.byname(guiderid);

	if (subcommand == "info") {
		info(guider, arguments);
		return;
	}

	if (subcommand == "exposure") {
		exposure(guider, arguments);
		return;
	}

	if (subcommand == "exposuretime") {
		exposuretime(guider, arguments);
		return;
	}

	if (subcommand == "binning") {
		binning(guider, arguments);
		return;
	}

	if (subcommand == "size") {
		size(guider, arguments);
		return;
	}

	if (subcommand == "offset") {
		offset(guider, arguments);
		return;
	}

	if (subcommand == "star") {
		star(guider, arguments);
		return;
	}

	if (subcommand == "calibration") {
		calibration(guider, arguments);
		return;
	}

	if (subcommand == "start") {
		start(guider, arguments);
		return;
	}

	if (subcommand == "stop") {
		stop(guider, arguments);
		return;
	}

	if (subcommand == "wait") {
		wait(guider, arguments);
		return;
	}

	if (subcommand == "image") {
		image(guider, arguments);
		return;
	}
}
示例#20
0
文件: eval.c 项目: xyzy/bash-4.3
/* Read and execute commands until EOF is reached.  This assumes that
   the input source has already been initialized. */
   int
   reader_loop ()
   {
    //printf("reader_loop  ------>  Start\n");
    int our_indirection_level;
    COMMAND * volatile current_command;

    USE_VAR(current_command);

    current_command = (COMMAND *)NULL;

    our_indirection_level = ++indirection_level;

    while (EOF_Reached == 0)
    {
      //printf("EOF_Reached == 0   =======>   Start\n");
      int code;

      code = setjmp_nosigs (top_level);

#if defined (PROCESS_SUBSTITUTION)
      unlink_fifo_list ();
#endif /* PROCESS_SUBSTITUTION */

      /* XXX - why do we set this every time through the loop? */
      if (interactive_shell && signal_is_ignored (SIGINT) == 0)
      {
        //printf("if (interactive_shell && signal_is_ignored (SIGINT) == 0)\n");
       set_signal_handler (SIGINT, sigint_sighandler);
      }

     if (code != NOT_JUMPED)
     {
      //printf("if (code != NOT_JUMPED)\n");
       indirection_level = our_indirection_level;

       switch (code)
       {
	      /* Some kind of throw to top_level has occurred. */
         case FORCE_EOF:
         case ERREXIT:
         case EXITPROG:
         //printf("case EXITPROG:\n");
         current_command = (COMMAND *)NULL;
         if (exit_immediately_on_error)
          {
            //printf("if (exit_immediately_on_error)\n");
            variable_context = 0; /* not in a function */
          }

           EOF_Reached = EOF;
         goto exec_done;

         case DISCARD:
         //printf("case DISCARD:\n");
	      /* Make sure the exit status is reset to a non-zero value, but
		 leave existing non-zero values (e.g., > 128 on signal)
		 alone. */
    if (last_command_exit_value == 0)
    {
      //printf("if (last_command_exit_value == 0)\n");
      last_command_exit_value = EXECUTION_FAILURE;
    }

    if (subshell_environment)
    {
      //printf("if (subshell_environment)\n");
      current_command = (COMMAND *)NULL;
      EOF_Reached = EOF;
      goto exec_done;
    }
	      /* Obstack free command elements, etc. */
    if (current_command)
    {
      //printf("if (current_command)\n");
      dispose_command (current_command);
      current_command = (COMMAND *)NULL;
    }
#if defined (HAVE_POSIX_SIGNALS)
    sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL);
#endif
    break;

    default:
    command_error ("reader_loop", CMDERR_BADJUMP, code, 0);
  }
}

executing = 0;
if (temporary_env)
{
  //printf("if (temporary_env)\n");
	dispose_used_env_vars ();
}

#if (defined (ultrix) && defined (mips)) || defined (C_ALLOCA)
      /* Attempt to reclaim memory allocated with alloca (). */
(void) alloca (0);
#endif

if (read_command () == 0)
{
  //printf("read_command () == 0\n");
  if (interactive_shell == 0 && read_but_dont_execute)
  {
    //printf("if (interactive_shell == 0 && read_but_dont_execute)");
    last_command_exit_value = EXECUTION_SUCCESS;
    dispose_command (global_command);
    global_command = (COMMAND *)NULL;
  }
  else if (current_command = global_command)
  {
    //printf("else if (current_command:%d = global_command:%d)\n",current_command, global_command);
    global_command = (COMMAND *)NULL;
    current_command_number++;

    executing = 1;
    stdin_redir = 0;
    execute_command (current_command);

    exec_done:
    QUIT;

    if (current_command)
    {
      //printf("if (current_command)\n");
      dispose_command (current_command);
      current_command = (COMMAND *)NULL;
    }
  }
}
else
{
	       /* Parse error, maybe discard rest of stream if not interactive. */
  if (interactive == 0)
  {
    //printf("if (interactive == 0)\n");
    EOF_Reached = EOF;
  }
}

if (just_one_command)
{
 //printf("just_one_command\n");
 EOF_Reached = EOF;
}
//printf("EOF_Reached == 0   =======>   Exit\n");
}
indirection_level--;
  //printf("reader_loop  ------>  Exit\n");

return (last_command_exit_value);
}