bool command_proc(uint8_t code)
{
switch (command_state) {
case ONESHOT:
if (!IS_COMMAND())
return false;
return (command_extra(code) || command_common(code));
break;
case CONSOLE:
if (IS_COMMAND())
return (command_extra(code) || command_common(code));
else
return (command_console_extra(code) || command_console(code));
break;
#ifdef MOUSEKEY_ENABLE
case MOUSEKEY:
mousekey_console(code);
break;
#endif
default:
command_state = ONESHOT;
return false;
}
return true;
}
int send_command( int comm, int param, int tmp_socket, int * error )
{
int len, ret;
ERROR err = NO_ERROR;
int close_socket = 0;
error[0] = 0;
if ( !IS_COMMAND(comm) )
return -1;
if ( tmp_socket == -1 )
{
tmp_socket = wpd_connect( port, &err );
if ( err != NO_ERROR )
{
error[0] = 1;
return -1;
}
close_socket = 1;
}
len = send_and_receive_param( tmp_socket,comm,param, (char*)&ret, &err );
if ( err != NO_ERROR ) {
error[0] = 1;
return -1;
}
if ( close_socket )
close( tmp_socket );
return ret;
}
void ControlCommandCallback(const char *cmd, const char *args, void *cbdata)
{
simulation_data *sim = (simulation_data *)cbdata;
#define IS_COMMAND(C) (strcmp(cmd, C) == 0)
if(IS_COMMAND("halt"))
sim->runMode = SIM_STOPPED;
else if(IS_COMMAND("step"))
simulate_one_timestep(sim);
else if(IS_COMMAND("run"))
sim->runMode = SIM_RUNNING;
else if(strcmp(cmd, "update") == 0)
{
VisItTimeStepChanged();
VisItUpdatePlots();
}
}
int hci_send_cmd_packet(uint8_t *packet, int size){
bd_addr_t addr;
hci_connection_t * conn;
// house-keeping
// create_connection?
if (IS_COMMAND(packet, hci_create_connection)){
bt_flip_addr(addr, &packet[3]);
log_info("Create_connection to %s\n", bd_addr_to_str(addr));
conn = connection_for_address(addr);
if (conn) {
// if connection exists
if (conn->state == OPEN) {
// and OPEN, emit connection complete command
hci_emit_connection_complete(conn, 0);
}
// otherwise, just ignore as it is already in the open process
return 0; // don't sent packet to controller
}
// create connection struct and register, state = SENT_CREATE_CONNECTION
conn = create_connection_for_addr(addr);
if (!conn){
// notify client that alloc failed
hci_emit_connection_complete(conn, BTSTACK_MEMORY_ALLOC_FAILED);
return 0; // don't sent packet to controller
}
conn->state = SENT_CREATE_CONNECTION;
}
if (IS_COMMAND(packet, hci_link_key_request_reply)){
hci_add_connection_flags_for_flipped_bd_addr(&packet[3], SENT_LINK_KEY_REPLY);
}
if (IS_COMMAND(packet, hci_link_key_request_negative_reply)){
hci_add_connection_flags_for_flipped_bd_addr(&packet[3], SENT_LINK_KEY_NEGATIVE_REQUEST);
}
if (IS_COMMAND(packet, hci_pin_code_request_reply)){
hci_add_connection_flags_for_flipped_bd_addr(&packet[3], SENT_PIN_CODE_REPLY);
}
if (IS_COMMAND(packet, hci_pin_code_request_negative_reply)){
hci_add_connection_flags_for_flipped_bd_addr(&packet[3], SENT_PIN_CODE_NEGATIVE_REPLY);
}
if (IS_COMMAND(packet, hci_delete_stored_link_key)){
if (hci_stack.remote_device_db){
bt_flip_addr(addr, &packet[3]);
hci_stack.remote_device_db->delete_link_key(&addr);
}
}
hci_stack.num_cmd_packets--;
return hci_stack.hci_transport->send_packet(HCI_COMMAND_DATA_PACKET, packet, size);
}
*/ void Do_Commands(REBSER *cmds, void *context)
/*
** Evaluate a block of commands as efficiently as possible.
** The arguments to each command must already be reduced or
** use only variable lookup.
**
** Returns the last evaluated value, if provided.
**
***********************************************************************/
{
REBVAL *blk;
REBCNT index = 0;
REBVAL *set_word = 0;
REBVAL *cmd_word;
REBSER *words;
REBVAL *args;
REBVAL *val;
REBVAL *func;
RXIFRM frm; // args stored here
REBCNT n;
REBEXT *ext;
REBCEC *ctx;
if ((ctx = context)) ctx->block = cmds;
blk = BLK_HEAD(cmds);
while (NOT_END(blk)) {
// var: command result
if IS_SET_WORD(blk) {
set_word = blk++;
index++;
};
// get command function
if (IS_WORD(cmd_word = blk)) {
// Optimized var fetch:
n = VAL_WORD_INDEX(blk);
if (n > 0) func = FRM_VALUES(VAL_WORD_FRAME(blk)) + n;
else func = Get_Var(blk); // fallback
} else func = blk;
if (!IS_COMMAND(func)) Trap2(RE_EXPECT_VAL, Get_Type_Word(REB_COMMAND), blk);
// Advance to next value
blk++;
if (ctx) ctx->index = index; // position of function
index++;
// get command arguments and body
words = VAL_FUNC_WORDS(func);
RXA_COUNT(&frm) = SERIES_TAIL(VAL_FUNC_ARGS(func))-1; // not self
// collect each argument (arg list already validated on MAKE)
n = 0;
for (args = BLK_SKIP(words, 1); NOT_END(args); args++) {
//Debug_Type(args);
val = blk++;
index++;
if (IS_END(val)) Trap2(RE_NO_ARG, cmd_word, args);
//Debug_Type(val);
// actual arg is a word, lookup?
if (VAL_TYPE(val) >= REB_WORD) {
if (IS_WORD(val)) {
if (IS_WORD(args)) val = Get_Var(val);
}
else if (IS_PATH(val)) {
if (IS_WORD(args)) val = Get_Any_Var(val); // volatile value!
}
else if (IS_PAREN(val)) {
val = Do_Blk(VAL_SERIES(val), 0); // volatile value!
}
// all others fall through
}
// check datatype
if (!TYPE_CHECK(args, VAL_TYPE(val)))
Trap3(RE_EXPECT_ARG, cmd_word, args, Of_Type(val));
// put arg into command frame
n++;
RXA_TYPE(&frm, n) = Reb_To_RXT[VAL_TYPE(val)];
frm.args[n] = Value_To_RXI(val);
}
// Call the command (also supports different extension modules):
func = BLK_HEAD(VAL_FUNC_BODY(func));
n = (REBCNT)VAL_INT64(func + 1);
ext = &Ext_List[VAL_I32(VAL_OBJ_VALUE(func, 1))]; // Handler
n = ext->call(n, &frm, context);
val = DS_RETURN;
switch (n) {
case RXR_VALUE:
RXI_To_Value(val, frm.args[1], RXA_TYPE(&frm, 1));
break;
case RXR_BLOCK:
RXI_To_Block(&frm, val);
break;
case RXR_UNSET:
SET_UNSET(val);
break;
case RXR_NONE:
SET_NONE(val);
break;
case RXR_TRUE:
SET_TRUE(val);
break;
case RXR_FALSE:
SET_FALSE(val);
break;
case RXR_ERROR:
default:
SET_UNSET(val);
}
if (set_word) {
Set_Var(set_word, val);
set_word = 0;
}
}
}
void
_ppt::_invoke_prompt(
std::vector<std::string> &arguments
)
{
TRACE_EVENT("+_ppt::_invoke_prompt", TRACE_TYPE_INFORMATION);
bool found;
in_arg args;
std::string input;
std::vector<sch>::iterator cmp_sch;
std::vector<arg> input_args, sub_args;
if(!_argument_action) {
THROW_PPT_EXC_W_MESS(PPT_HDL_ACTION_STRING(PPT_HDL_ACTION_ARGUMENTS), PPT_EXC_INVAL_HDL_ACTION_TYPE);
}
args = _argument_action(this, arguments);
switch(args.get_signal()) {
case PPT_ARG_SIG_EXIT:
break;
case PPT_ARG_SIG_INPUT:
_invoke_executor(args);
break;
case PPT_ARG_SIG_INTERACT:
signal(SIGINT, SIG_IGN);
PROMPT_HEADER(input);
std::cout << input << std::endl << std::endl;
while(_active) {
found = false;
input.clear();
sub_args.clear();
input_args.clear();
std::cout << CURSOR;
if(!std::cin) {
THROW_PPT_EXC(PPT_EXC_INPUT_PIPE_CLOSED);
}
getline(std::cin, input);
if(input.empty()) {
continue;
}
if(IS_COMMAND(input)) {
try {
input.erase(input.begin(), input.begin() + 1);
_parse_command_input(input, input_args);
sub_args = std::vector<arg>(input_args.begin() + 1, input_args.end());
for(cmp_sch = _schema.begin(); cmp_sch != _schema.end(); ++cmp_sch) {
if(cmp_sch->match(input_args.front().get_text(), sub_args)) {
if(cmp_sch->has_action()) {
cmp_sch->invoke_action(this, sub_args);
}
found = true;
break;
}
}
if(!found) {
THROW_PPT_EXC_W_MESS(input_args.front().get_text(), PPT_EXC_UNK_SCHEMA_CMD_TYPE);
}
} catch(std::runtime_error &exc) {
std::cerr << "Exception: " << exc.what() << std::endl << std::endl;
}
} else {
try {
if(!_generic_action) {
THROW_PPT_EXC_W_MESS(PPT_HDL_ACTION_STRING(PPT_HDL_ACTION_GENERIC), PPT_EXC_INVAL_HDL_ACTION_TYPE);
}
input_args.push_back(arg(input, ARG_TYPE_STRING));
_generic_action(this, input_args);
} catch(std::runtime_error &exc) {
if(_exception_action) {
_exception_action(this, exc);
}
std::cerr << "Exception: " << exc.what() << std::endl << std::endl;
}
}
}
break;
default:
THROW_PPT_EXC_W_MESS(args.get_signal(), PPT_EXC_INVAL_SIGNAL_TYPE);
}
TRACE_EVENT("-_ppt::_invoke_prompt", TRACE_TYPE_INFORMATION);
}
