/**
* List all programs stored on the terminal host over the serial line.
* DIR
*/
void cmd_dir(char *) {
unsigned char first = 1;
acia_puts("*DIR\n");
for(;;) {
acia_puts("*NEXT\n");
acia_gets(readline_buffer, 255);
if (strncmp("*EOF", readline_buffer, 4) == 0) {
break;
} else {
if (first) {
first = 0;
} else {
do {
if (is_interrupted()) {
acia_puts("*BREAK\n");
print_interrupted();
return;
}
keys_update();
} while (keys_get_code() == KEY_NONE);
}
lcd_puts(readline_buffer);
lcd_put_newline();
}
}
print_ready();
}
/**
* List the program.
* LiST [<from>]
*/
void cmd_list(char *args) {
unsigned char range = 0;
unsigned int from_number;
unsigned int to_number;
program_line *line;
unsigned char first = 1;
if (isdigit(args[0])) {
sscanf(args, "%u", &from_number);
to_number = from_number;
range = 1;
}
line = program;
while (line) {
if (range == 0 || (line->number >= from_number && line->number <= to_number)) {
if (first) {
first = 0;
} else {
do {
if (is_interrupted()) {
print_interrupted();
return;
}
keys_update();
} while (keys_get_code() == KEY_NONE);
}
sprintf(print_buffer, "%u %s %s\n", line->number, keywords[line->command], line->args);
lcd_puts(print_buffer);
}
line = line->next;
}
print_ready();
}
/**
* Run the program.
* RUN
*/
void cmd_run(char *) {
unsigned char command;
error = 0;
running = 1;
current_line = program;
current_line_changed = 0;
while (current_line) {
if (is_interrupted()) {
print_interrupted();
lcd_cursor_blink();
break;
}
command = current_line->command;
command_functions[command](current_line->args);
if (error) {
break;
}
if (current_line_changed) {
current_line_changed = 0;
if (! current_line) {
break;
}
} else {
current_line = current_line->next;
}
}
print_ready();
}
void run()
{
if (!is_interrupted())
{
boost::mutex::scoped_lock lock(m_mutex);
m_state = 3;
}
}
/**
* Pause the program for some specified amount of time.
* SLEEP <milliseconds>
*/
void cmd_sleep(char *args) {
static unsigned long delay;
static unsigned long sleep_end_millis;
if (isdigit(args[0])) {
sscanf(args, "%ul", &delay);
sleep_end_millis = time_millis() + delay;
while (time_millis() < sleep_end_millis) {
if (is_interrupted()) {
break;
}
}
} else {
syntax_error();
}
}
bool worker_check(const worker_options_t *options, const worker_snapshot_t *snapshot) {
if (is_interrupted()) {
return false;
}
if (likely(options->duration_type == TEST_TIME)) {
if (likely(snapshot->now.tv_sec <= options->duration.time.end.tv_sec)) {
return true;
}
} else {
if (likely(snapshot->count < options->duration.count)) {
return true;
}
}
return false;
}
/**
* Input a variable from the keyboard.
* INPUT <variable> [ONERROR <command]
*/
void cmd_input(char *args) {
unsigned int var_name;
unsigned char var_type;
args = parse_variable(args, &var_name, &var_type);
if (args) {
if (var_type == VAR_TYPE_STRING) {
char *line = readline(INTERRUPTIBLE);
create_variable(var_name, var_type, line);
} else if (var_type == VAR_TYPE_INTEGER) {
for (;;) {
int value = 0;
char *line = readline(INTERRUPTIBLE);
if (is_interrupted()) {
break;
}
if (parse_integer(line, &value)) {
create_variable(var_name, var_type, &value);
break;
} else {
if (next_token(args) == TOKEN_ONERROR) {
args = consume_token(args, TOKEN_ONERROR);
execute(args);
break;
} else {
syntax_error_invalid_number();
lcd_puts("Enter again: ");
}
}
}
} else {
syntax_error_invalid_argument();
}
} else {
syntax_error_invalid_argument();
}
}
/*----------------------------------------------------------
LPRPort.eventLoop
accept: none
perform: periodically check for ParallelPortEvents
return: none
exceptions: none
comments: lots of work needed here. Yes its a mess.
struct lp_stats
{
unsigned long chars;
unsigned long sleeps;
unsigned int maxrun;
unsigned int maxwait;
unsigned int meanwait;
unsigned int mdev;
};
----------------------------------------------------------*/
JNIEXPORT void JNICALL LPRPort(eventLoop)( JNIEnv *env,
jobject jobj )
{
int fd, ret;
unsigned int pflags = 0;
fd_set rfds;
struct timeval sleep;
jboolean interrupted = 0;
fd = get_java_var( env, jobj,"fd","I" );
interrupted = is_interrupted(env, jobj);
FD_ZERO( &rfds );
while( !interrupted )
{
FD_SET( fd, &rfds );
/* Check every 1 second, or on receive data */
sleep.tv_sec = 1;
sleep.tv_usec = 0;
do {
ret = select( fd + 1, &rfds, NULL, NULL, &sleep );
}
while (ret < 0 && errno == EINTR);
if( ret < 0 ) break;
interrupted = is_interrupted(env, jobj);
if(interrupted) {
return;
}
#if defined(LPGETSTATUS)
ioctl( fd, LPGETSTATUS, &pflags );
#elif defined(WIN32)
pflags = getWin32ParallelStatusFlags(fd);
#else
/* FIXME?? */
printf("ParallelImp.c LPGETSTATUS is undefined!\n");
#endif
/*
PAR_EV_BUFFER:
PAR_EV_ERROR:
*/
#if defined(PARALLEL_BUSY)
if (pflags & PARALLEL_BUSY)
send_event( env, jobj, PAR_EV_ERROR, JNI_TRUE );
#elif defined(LP_BUSY)
if (pflags&LP_BUSY) /* inverted input, active high */
send_event( env, jobj, PAR_EV_ERROR, JNI_TRUE );
#elif defined(EBUSY)
if (pflags&EBUSY) /* inverted input, active high */
send_event( env, jobj, PAR_EV_ERROR, JNI_TRUE );
#endif /* EBUSY LP_BUSY */
/* FIXME this has moved into the ifdef __kernel__? Need to get the
posix documentation on this.
if (pflags&LP_ACK)
send_event( env, jobj, PAR_EV_ERROR, JNI_TRUE );
*/
#if defined (__linux__)
/* unchanged input, active low */
if (pflags&LP_NOPA) /* unchanged input, active high */
send_event( env, jobj, PAR_EV_ERROR, 1 );
if (pflags&LP_SELEC) /* unchanged input, active high */
send_event( env, jobj, PAR_EV_ERROR, 1 );
if (pflags&LP_ERR) /* unchanged input, active low */
send_event( env, jobj, PAR_EV_ERROR, 1 );
#else
/* FIXME?? */
printf("ParallelImp.c LPGETSTATUS is undefined!\n");
#endif
usleep(1000);
}
return;
}
