void InputManager::genKeyboardEvent(KeyboardEvent type, const KeyboardEventArgs &args) {
if(type == KeyboardEvent::DOWN) {
_call(_keyDownCallbacks, args);
}
if(type == KeyboardEvent::UP) {
_call(_keyUpCallbacks, args);
}
}
void InputManager::genPointerEvent(PointerEvent type, const PointerEventArgs &args) {
if(type == PointerEvent::PRESS) {
_call(_pointerPressCallbacks, args);
}
if(type == PointerEvent::RELEASE) {
_call(_pointerReleaseCallbacks, args);
}
if(type == PointerEvent::MOVE) {
_call(_pointerMoveCallbacks, args);
}
}
bool Object::call(const std::string& i_command,const int& i_parameter)
{
// clear the previous called objects
m_already_called_objects.clear() ;
return _call(i_command,i_parameter) ;
}
dispatch * call(size_t id, dispatch * disp) {
if (!_id_to_dispatch[id])
THROW_NOT_IMPL();
disp->id = id;
return _call(_id_to_dispatch[disp->id], disp);
}
bool Object::call(const std::string& i_command)
{
InternalMessage("Kernel","entering Object::call") ;
// clear the previous called objects
m_already_called_objects.clear() ;
return _call(i_command) ;
}
t_ptr call(t_closure* closure, t_ptr param)
{
t_list* list = 0;
t_list* cursor = 0;
list = malloc(sizeof(t_list));
if (list == 0)
return (0);
list->val = param;
list->next = 0;
for (cursor = closure->env; cursor->next != 0; cursor = cursor->next);
cursor->next = list;
return (_call(closure->fct, closure->env, param));
}
bool Menu::_mouse (int button, int x, int y)
{
if ((x < x0) or (x1 < x) or (y < y0) or (y1 < y)) return false;
if (menus_hidden) {
menus_hidden = false;
} else {
switch (button) {
case GLUT_LEFT_BUTTON:
_call((y1 - y) / m_font.height);
break;
default:
if (managed) delete this;
}
}
return true;
}
result_t List::array::forEach(v8::Local<v8::Function> func,
v8::Local<v8::Object> thisp)
{
int i, len;
len = (int)m_array.size();
for (i = 0; i < len; i++)
{
v8::Local<v8::Value> r = _call(func, thisp, i);
if (r.IsEmpty())
return CALL_E_JAVASCRIPT;
}
return 0;
}
/*
* Get ME data information from MNG client
*/
HECI_STATUS
MNGCommand::GetMEInfo(MNG_GET_ME_INFORMATION_RESPONSE &infoMsg)
{
UINT8 *readBuffer = NULL;
UINT32 command_size = sizeof(MNG_GET_ME_INFO_HEADER);
UINT32 replySize = 0;
MNG_REQUEST msg = MNG_GET_ME_INFO_HEADER;
HECI_STATUS status;
status = _call((const unsigned char *)&msg, command_size,
&readBuffer, &replySize);
if (status != HECI_STATUS_OK)
{
goto mngend;
}
if (replySize != sizeof(MNG_GET_ME_INFORMATION_RESPONSE))
{
if (_verbose)
{
fprintf(stderr, "Error: Size of MEI response is not as expected\n");
}
status = HECI_STATUS_UNEXPECTED_RESPONSE;
goto mngend;
}
if (((MNG_GET_ME_INFORMATION_RESPONSE *)readBuffer)->Version != MNG_GET_ME_INFO_Version)
{
if (_verbose)
{
fprintf(stderr, "Error: MEI response size is not as expected\n");
}
status = HECI_STATUS_UNEXPECTED_RESPONSE;
goto mngend;
}
memcpy(&infoMsg, readBuffer, sizeof(MNG_GET_ME_INFORMATION_RESPONSE));
mngend:
if (readBuffer != NULL)
{
free(readBuffer);
}
return status;
}
SentCodeCall::SentCodeCall(QObject *parent, base::lambda_once<void()> callCallback, base::lambda<void()> updateCallback)
: _timer(parent)
, _call(std::move(callCallback))
, _update(std::move(updateCallback)) {
_timer->connect(_timer, &QTimer::timeout, [this] {
if (_status.state == State::Waiting) {
if (--_status.timeout <= 0) {
_status.state = State::Calling;
_timer->stop();
if (_call) {
_call();
}
}
}
if (_update) {
_update();
}
});
}
void JitFragmentWriter::_emitOSRPoint(RewriterVar* result, RewriterVar* node_var) {
RewriterVar::SmallVector args;
args.push_back(getInterp());
args.push_back(node_var);
_call(result, false, (void*)ASTInterpreterJitInterface::doOSRHelper, args, RewriterVar::SmallVector());
auto result_reg = result->getInReg(assembler::RDX);
result->bumpUse();
assembler->test(result_reg, result_reg);
{
assembler::ForwardJump je(*assembler, assembler::COND_EQUAL);
assembler->mov(assembler::Immediate(0ul), assembler::RAX); // TODO: use xor
assembler->add(assembler::Immediate(JitCodeBlock::sp_adjustment), assembler::RSP);
assembler->pop(assembler::R12);
assembler->pop(assembler::R14);
assembler->retq();
}
assertConsistent();
}
static void push_test(void **state)
{
IntVec* vec = new_int_vec(2);
_call(vec, push, 7);
_call(vec, push, 42);
_call(vec, push, 8);
assert_int_equal(7, _call(vec, nth, 0));
assert_int_equal(42, _call(vec, nth, 1));
assert_int_equal(8, _call(vec, nth, 2));
assert_int_equal(4, vec->limit);
destroy_int_vec(vec);
}
result_t List::array::map(v8::Local<v8::Function> func,
v8::Local<v8::Object> thisp, obj_ptr<List_base> &retVal)
{
obj_ptr<List> a;
int i, len;
a = new List();
len = (int)m_array.size();
for (i = 0; i < len; i++)
{
v8::Local<v8::Value> r = _call(func, thisp, i);
if (r.IsEmpty())
return CALL_E_JAVASCRIPT;
a->push(r);
}
retVal = a;
return 0;
}
result_t List::array::every(v8::Local<v8::Function> func,
v8::Local<v8::Object> thisp, bool &retVal)
{
int i, len;
len = (int)m_array.size();
for (i = 0; i < len; i++)
{
v8::Local<v8::Value> r = _call(func, thisp, i);
if (r.IsEmpty())
return CALL_E_JAVASCRIPT;
if (!r->BooleanValue())
{
retVal = false;
return 0;
}
}
retVal = true;
return 0;
}
void Form_Scene::mouseMoveEvent(QMouseEvent* e)
{
_call(on_mouse_move, e);
QMdiSubWindow::mouseMoveEvent(e);
}
typename __bind_return_type<CallFun, BindArgs, typename std::tuple<CArgs&&...>>::type operator()(CArgs&&... c){
std::tuple<CArgs&&...> cargs(std::forward<CArgs>(c)...);
return _call(cargs, typename gen<std::tuple_size<BindArgs>::value>::type());
}
// run the menu
void
Menu::run(void)
{
int8_t ret;
uint8_t len, i;
uint8_t argc;
int c;
char *s;
if (_port == NULL) {
// default to main serial port
_port = &Serial;
}
// loop performing commands
for (;; ) {
// run the pre-prompt function, if one is defined
if ((NULL != _ppfunc) && !_ppfunc())
return;
// loop reading characters from the input
len = 0;
_port->printf_P(PSTR("%S] "), FPSTR(_prompt));
for (;; ) {
c = _port->read();
if (-1 == c)
continue;
// carriage return -> process command
if ('\r' == c) {
_inbuf[len] = '\0';
_port->write('\r');
_port->write('\n');
break;
}
// backspace
if ('\b' == c) {
if (len > 0) {
len--;
_port->write('\b');
_port->write(' ');
_port->write('\b');
continue;
}
}
// printable character
if (isprint(c) && (len < (MENU_COMMANDLINE_MAX - 1))) {
_inbuf[len++] = c;
_port->write((char)c);
continue;
}
}
// split the input line into tokens
argc = 0;
_argv[argc++].str = strtok_r(_inbuf, " ", &s);
// XXX should an empty line by itself back out of the current menu?
while (argc <= MENU_ARGS_MAX) {
_argv[argc].str = strtok_r(NULL, " ", &s);
if ('\0' == _argv[argc].str)
break;
_argv[argc].i = atol(_argv[argc].str);
_argv[argc].f = atof(_argv[argc].str); // calls strtod, > 700B !
argc++;
}
if (_argv[0].str == NULL) {
continue;
}
// populate arguments that have not been specified with "" and 0
// this is safer than NULL in the case where commands may look
// without testing argc
i = argc;
while (i <= MENU_ARGS_MAX) {
_argv[i].str = "";
_argv[i].i = 0;
_argv[i].f = 0;
i++;
}
bool cmd_found = false;
// look for a command matching the first word (note that it may be empty)
for (i = 0; i < _entries; i++) {
if (!strcasecmp_P(_argv[0].str, _commands[i].command)) {
ret = _call(i, argc);
cmd_found=true;
if (-2 == ret)
return;
break;
}
}
// implicit commands
if (i == _entries) {
if (!strcmp(_argv[0].str, "?") || (!strcasecmp_P(_argv[0].str, PSTR("help")))) {
_help();
cmd_found=true;
} else if (!strcasecmp_P(_argv[0].str, PSTR("exit"))) {
return;
}
}
if (cmd_found==false)
{
_port->println_P(PSTR("Invalid command, type 'help'"));
}
}
}
void InputManager::genMiscEvent(MiscEvent type, int arg) {
if(type == MiscEvent::MOUSE_WHEEL) {
_call(_mouseWheelCallbacks, arg);
}
}
void Form_Scene::wheelEvent(QWheelEvent* e)
{
_call(on_mouse_wheel, e);
QMdiSubWindow::wheelEvent(e);
}
void Form_Scene::mousePressEvent(QMouseEvent* e)
{
_call(on_mouse_press, e);
QMdiSubWindow::mousePressEvent(e);
}
void Form_Scene::mouseReleaseEvent(QMouseEvent* e)
{
_call(on_mouse_release, e);
QMdiSubWindow::mouseReleaseEvent(e);
}
// run the menu
bool
Menu::_run_command(bool prompt_on_enter)
{
int8_t ret;
uint8_t i;
uint8_t argc;
char *s = NULL;
_input_len = 0;
// split the input line into tokens
argc = 0;
s = NULL;
_argv[argc++].str = strtok_r(_inbuf, " ", &s);
// XXX should an empty line by itself back out of the current menu?
while (argc <= _args_max) {
_argv[argc].str = strtok_r(NULL, " ", &s);
if (_argv[argc].str == NULL || '\0' == _argv[argc].str[0])
break;
_argv[argc].i = atol(_argv[argc].str);
_argv[argc].f = atof(_argv[argc].str); // calls strtod, > 700B !
argc++;
}
if (_argv[0].str == NULL) {
// we got a blank line, re-display the prompt
if (prompt_on_enter) {
_display_prompt();
}
return false;
}
// populate arguments that have not been specified with "" and 0
// this is safer than NULL in the case where commands may look
// without testing argc
i = argc;
while (i <= _args_max) {
_argv[i].str = "";
_argv[i].i = 0;
_argv[i].f = 0;
i++;
}
bool cmd_found = false;
// look for a command matching the first word (note that it may be empty)
for (i = 0; i < _entries; i++) {
if (!strcasecmp(_argv[0].str, _commands[i].command)) {
ret = _call(i, argc);
cmd_found=true;
if (-2 == ret)
return true;
break;
}
}
// implicit commands
if (i == _entries) {
if (!strcmp(_argv[0].str, "?") || (!strcasecmp(_argv[0].str, "help"))) {
_help();
cmd_found=true;
} else if (!strcasecmp(_argv[0].str, "exit")) {
// exit the menu
return true;
}
}
if (cmd_found==false)
{
_port->println("Invalid command, type 'help'");
}
return false;
}
void Form_Scene::resizeEvent(QResizeEvent* e)
{
_call(on_resize, e);
QMdiSubWindow::resizeEvent(e);
}
/**
* Perform the registered call, the result may be queried via result(). The previous result, if
* present is discarded.
**/
virtual void call() { reset(); _res = new R(_call(typename internals_indirectcall::gens<sizeof...(Params)>::type())); }
/**
* Perform the registered call to the procedure
**/
virtual void call() { _sta = false; _call(typename internals_indirectcall::gens<sizeof...(Params)>::type()); _sta = true; }
/**
* Construct the object. the adress of the object may be queried via adress().
* Should be called only once !
**/
virtual void construct() { MTOOLS_ASSERT((T*)_res == nullptr); _res = _call(typename internals_indirectcall::gens<sizeof...(Params)>::type()); }
dispatch * call(dispatch * disp) {
if (!_id_to_dispatch[disp->id])
THROW_NOT_IMPL();
return _call(_id_to_dispatch[disp->id], disp);
}
//-----------------------------------------------------------------------------
//
// 命令コマンドを解釈してバイナリに変換
//
//-----------------------------------------------------------------------------
bool encode(char* instName, char* buffer, map<uint32_t, string>& labelNames, uint32_t currentLine, uint32_t& code, bool& useLabel)
{
uint32_t rs = 0;
uint32_t rt = 0;
uint32_t rd = 0;
uint32_t imm = 0;
double d = 0;
char label[MAX_LINE_SIZE];
char dummy[MAX_LINE_SIZE];
if (eq(instName, "add"))
{
int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _add(rs, rt, rd);
return true;
}
}
if (eq(instName, "sub"))
{
int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _sub(rs, rt, rd);
return true;
}
}
if (eq(instName, "mul"))
{
int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _mul(rs, rt, rd);
return true;
}
}
if (eq(instName, "and"))
{
int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _and(rs, rt, rd);
return true;
}
}
if (eq(instName, "or"))
{
int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _or(rs, rt, rd);
return true;
}
}
if (eq(instName, "nor"))
{
int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _nor(rs, rt, rd);
return true;
}
}
if (eq(instName, "xor"))
{
int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _xor(rs, rt, rd);
return true;
}
}
if (eq(instName, "addi"))
{
int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _addi(rs, rt, imm);
return true;
}
}
if (eq(instName, "subi"))
{
int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _subi(rs, rt, imm);
return true;
}
}
if (eq(instName, "muli"))
{
int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _muli(rs, rt, imm);
return true;
}
}
if (eq(instName, "slli"))
{
int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _slli(rs, rt, imm);
return true;
}
}
if (eq(instName, "srai"))
{
int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _srai(rs, rt, imm);
return true;
}
}
if (eq(instName, "andi"))
{
int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _andi(rs, rt, imm);
return true;
}
}
if (eq(instName, "ori"))
{
int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _ori(rs, rt, imm);
return true;
}
}
if (eq(instName, "nori"))
{
int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _nori(rs, rt, imm);
return true;
}
}
if (eq(instName, "xori"))
{
int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _xori(rs, rt, imm);
return true;
}
}
if (eq(instName, "fadd"))
{
int n = sscanf(buffer, formFFF, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _fadd(rs, rt, rd);
return true;
}
}
if (eq(instName, "fsub"))
{
int n = sscanf(buffer, formFFF, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _fsub(rs, rt, rd);
return true;
}
}
if (eq(instName, "fmul"))
{
int n = sscanf(buffer, formFFF, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _fmul(rs, rt, rd);
return true;
}
}
if (eq(instName, "fmuln"))
{
int n = sscanf(buffer, formFFF, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _fmuln(rs, rt, rd);
return true;
}
}
if (eq(instName, "finv"))
{
int n = sscanf(buffer, formFF, dummy, &rd, &rs);
if (n == 3)
{
code = _finv(rs, rt, rd);
return true;
}
}
if (eq(instName, "fsqrt"))
{
int n = sscanf(buffer, formFF, dummy, &rd, &rs);
if (n == 3)
{
code = _fsqrt(rs, rt, rd);
return true;
}
}
if (eq(instName, "fmov"))
{
int n = sscanf(buffer, formFF, dummy, &rd, &rs);
if (n == 3)
{
code = _fmov(rs, rt, rd);
return true;
}
}
if (eq(instName, "fneg"))
{
int n = sscanf(buffer, formFF, dummy, &rd, &rs);
if (n == 3)
{
code = _fneg(rs, rt, rd);
return true;
}
}
if (eq(instName, "imovf"))
{
int n = sscanf(buffer, formFR, dummy, &rt, &rs);
if (n == 3)
{
code = _imovf(rs, rt, rd);
return true;
}
}
if (eq(instName, "fmovi"))
{
int n = sscanf(buffer, formRF, dummy, &rt, &rs);
if (n == 3)
{
code = _fmovi(rs, rt, rd);
return true;
}
}
// to use ALU
if (eq(instName, "mvlo"))
{
int n = sscanf(buffer, formRI, dummy, &rt, &imm);
if (n == 3)
{
code = _mvlo(rt, rt, imm);
return true;
}
}
if (eq(instName, "mvhi"))
{
int n = sscanf(buffer, formRI, dummy, &rt, &imm);
if (n == 3)
{
code = _mvhi(rt, rt, imm);
return true;
}
}
if (eq(instName, "fmvlo"))
{
int n = sscanf(buffer, formFI, dummy, &rt, &imm);
if (n == 3)
{
code = _fmvlo(rt, rt, imm);
return true;
}
}
if (eq(instName, "fmvhi"))
{
int n = sscanf(buffer, formFI, dummy, &rt, &imm);
if (n == 3)
{
code = _fmvhi(rt, rt, imm);
return true;
}
}
if (eq(instName, "j"))
{
int n = sscanf(buffer, formL, dummy, label);
if (n == 2)
{
labelNames[currentLine] = string(label);
// cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
useLabel = true;
code = _j(0);
return true;
}
}
if (eq(instName, "beq"))
{
int n = sscanf(buffer, formRRL, dummy, &rs, &rt, label);
if (n == 4)
{
labelNames[currentLine] = string(label);
// cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
useLabel = true;
code = _beq(rs, rt, imm);
return true;
}
}
if (eq(instName, "blt"))
{
int n = sscanf(buffer, formRRL, dummy, &rs, &rt, label);
if (n == 4)
{
labelNames[currentLine] = string(label);
// cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
useLabel = true;
code = _blt(rs, rt, imm);
return true;
}
}
if (eq(instName, "ble"))
{
int n = sscanf(buffer, formRRL, dummy, &rs, &rt, label);
if (n == 4)
{
labelNames[currentLine] = string(label);
// cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
useLabel = true;
code = _ble(rs, rt, imm);
return true;
}
}
if (eq(instName, "fbeq"))
{
int n = sscanf(buffer, formFFL, dummy, &rs, &rt, label);
if (n == 4)
{
labelNames[currentLine] = string(label);
// cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
useLabel = true;
code = _fbeq(rs, rt, imm);
return true;
}
}
if (eq(instName, "fblt"))
{
int n = sscanf(buffer, formFFL, dummy, &rs, &rt, label);
if (n == 4)
{
labelNames[currentLine] = string(label);
// cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
useLabel = true;
code = _fblt(rs, rt, imm);
return true;
}
}
if (eq(instName, "fble"))
{
int n = sscanf(buffer, formFFL, dummy, &rs, &rt, label);
if (n == 4)
{
labelNames[currentLine] = string(label);
// cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
useLabel = true;
code = _fble(rs, rt, imm);
return true;
}
}
if (eq(instName, "jr"))
{
int n = sscanf(buffer, formR, dummy, &rs);
if (n == 2)
{
code = _jr(rs, rt, rd);
return true;
}
}
if (eq(instName, "call"))
{
int n = sscanf(buffer, formL, dummy, label);
if (n == 2)
{
labelNames[currentLine] = string(label);
// cerr << "assigned (" << currentLine << ", " << string(label) << ") in labelNames" << endl;
useLabel = true;
code = _call(0);
return true;
}
}
if (eq(instName, "callr"))
{
int n = sscanf(buffer, formR, dummy, &rs);
if (n == 2)
{
code = _callr(rs, rt, rd);
return true;
}
}
if (eq(instName, "return"))
{
int n = sscanf(buffer, form, dummy);
if (n == 1)
{
code = _return(rs, rt, rd);
return true;
}
}
if (eq(instName, "ldr"))
{
int n = sscanf(buffer, formRRR, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _ldr(rs, rt, rd);
return true;
}
}
if (eq(instName, "fldr"))
{
int n = sscanf(buffer, formFRR, dummy, &rd, &rs, &rt);
if (n == 4)
{
code = _fldr(rs, rt, rd);
return true;
}
}
if (eq(instName, "sti"))
{
int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _sti(rs, rt, imm);
return true;
}
}
if (eq(instName, "ldi"))
{
int n = sscanf(buffer, formRRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _ldi(rs, rt, imm);
return true;
}
}
if (eq(instName, "fsti"))
{
int n = sscanf(buffer, formFRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _fsti(rs, rt, imm);
return true;
}
}
if (eq(instName, "fldi"))
{
int n = sscanf(buffer, formFRI, dummy, &rt, &rs, &imm);
if (n == 4)
{
code = _fldi(rs, rt, imm);
return true;
}
}
if (eq(instName, "inputb"))
{
int n = sscanf(buffer, formR, dummy, &rt);
if (n == 2)
{
code = _inputb(rs, rt, rd);
return true;
}
}
if (eq(instName, "outputb"))
{
int n = sscanf(buffer, formR, dummy, &rt);
if (n == 2)
{
code = _outputb(rs, rt, rd);
return true;
}
}
if (eq(instName, "halt"))
{
int n = sscanf(buffer, form, dummy);
if (n == 1)
{
code = _halt(rs, rt, rd);
return true;
}
}
if (eq(instName, "dump"))
{
int n = sscanf(buffer, form, dummy);
if (n == 1)
{
code = _dump(rs, rt, rd);
return true;
}
}
return false;
}
dispatch * call(std::string & name, dispatch * disp) {
if (!_name_to_dispatch[name])
THROW_NOT_IMPL();
return _call(_name_to_dispatch[name], disp);
}
// run the menu
void
Menu::run(void)
{
uint8_t len, i, ret;
uint8_t argc;
int c;
char *s;
// loop performing commands
for (;;) {
// run the pre-prompt function, if one is defined
if ((NULL != _ppfunc) && !_ppfunc())
return;
// loop reading characters from the input
len = 0;
Serial.printf("%S] ", _prompt);
for (;;) {
c = Serial.read();
if (-1 == c)
continue;
// carriage return -> process command
if ('\r' == c) {
_inbuf[len] = '\0';
Serial.write('\r');
Serial.write('\n');
break;
}
// backspace
if ('\b' == c) {
if (len > 0) {
len--;
Serial.write('\b');
Serial.write(' ');
Serial.write('\b');
continue;
}
}
// printable character
if (isprint(c) && (len < (MENU_COMMANDLINE_MAX - 1))) {
_inbuf[len++] = c;
Serial.write((char)c);
continue;
}
}
// split the input line into tokens
argc = 0;
_argv[argc++].str = strtok_r(_inbuf, " ", &s);
// XXX should an empty line by itself back out of the current menu?
while (argc <= MENU_ARGS_MAX) {
_argv[argc].str = strtok_r(NULL, " ", &s);
if ('\0' == _argv[argc].str)
break;
_argv[argc].i = atol(_argv[argc].str);
_argv[argc].f = atof(_argv[argc].str); // calls strtod, > 700B !
argc++;
}
// look for a command matching the first word (note that it may be empty)
for (i = 0; i < _entries; i++) {
if (!strcasecmp_P(_argv[0].str, _commands[i].command)) {
ret = _call(i, argc);
if (-2 == ret)
return;
break;
}
}
// implicit commands
if (i == _entries) {
if (!strcmp(_argv[0].str, "?") || (!strcasecmp_P(_argv[0].str, PSTR("help")))) {
_help();
} else if (!strcasecmp_P(_argv[0].str, PSTR("exit"))) {
return;
}
}
}
}
