void simple_shell()
{ int n_args, i;
//memory space for user command is always the same, freed on quit
char * * sarray = malloc(max_arg_c * sizeof(*sarray));
for (i = 0; i < max_arg_c; i += 1)
sarray[i] = malloc(max_arg_length + 1);
print_commands();
while (1)
{ printf("\n---> ");
for (i = 0; i < max_arg_c; i += 1)
*sarray[i] = (char *)NULL;
n_args = get_command_line(sarray);
if (quit_command(sarray[0]))
{ printf("exiting shell \n");
for (i = 0; i < max_arg_c; i += 1)
free(sarray[i]);
free(sarray);
break; }
else if (!strcmp(sarray[0], "help"))
print_commands();
else if (!strcmp(sarray[0], "echo"))
{ for (i = 1; i < n_args && sarray[i] != NULL; i += 1)
printf("%s ", sarray[i]); }
else if (!strcmp(sarray[0], "run"))
run_program(sarray, n_args);
else
printf("command not found. "); } }
/**
* Main function.
*
* @return error code (0 - no error)
*/
int
main (int argc, /**< number of arguments */
char **argv) /**< argument list */
{
cli_state_t cli_state = cli_init (main_opts, argc - 1, argv + 1);
for (int id = cli_consume_option (&cli_state); id != CLI_OPT_END; id = cli_consume_option (&cli_state))
{
switch (id)
{
case OPT_MERGE_HELP:
{
/* Help is always printed if no command is provided. */
break;
}
case CLI_OPT_DEFAULT:
{
const char *command_p = cli_consume_string (&cli_state);
if (cli_state.error != NULL)
{
break;
}
if (!strcmp ("merge", command_p))
{
return process_merge (&cli_state, argc, argv[0]);
}
else if (!strcmp ("generate", command_p))
{
return process_generate (&cli_state, argc, argv[0]);
}
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: unknown command: %s\n\n", command_p);
print_commands (argv[0]);
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
default:
{
cli_state.error = "Internal error";
break;
}
}
}
if (check_cli_error (&cli_state))
{
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
print_commands (argv[0]);
return JERRY_STANDALONE_EXIT_CODE_OK;
} /* main */
void Parser_qhelp(int argc, char *argv[]) {
printf("Available commands are:\n");
print_commands(NULL, top_level);
printf("For more help type: help command-name\n");
}
int main(int argc, const char **argv)
{
if (argc < 2) {
print_commands();
return -1;
}
const char *cmd = argv[1];
int cmd_index = find_command(cmd);
if (cmd_index == -1) {
printf("Command %s not found\n", cmd);
return -1;
}
argc -= 2;
++argv;
++argv;
if (argc != s_commands[cmd_index].args_count) {
printf("Invalid number of arguments supplied (%d instead of %d)\n",
argc, s_commands[cmd_index].args_count);
return -1;
}
s_commands[cmd_index].handler(argv);
return 0;
}
void Summary::print()
{
print_versions();
print_pools();
print_bind();
print_commands();
}
int
main(int argc, char *argv[])
{
int arg_c;
char *cmd, *line = NULL;
char *arg_v[256];
COMMAND *cmd_func;
while (1) {
/* If the buffer has already been allocated, return the memory
to the free pool. */
if (line) {
free (line);
line = (char *)NULL;
}
/* Get a line from the user. */
line = readline ("> ");
/* If the line has any text in it, save it on the history. */
if (line && *line) {
add_history (line);
arg_c = parse_line(line, arg_v);
cmd = arg_v[0];
if (!(cmd_func = find_command(cmd))) {
printf("no such command\n");
print_commands();
}
else {
(*(cmd_func->impl))(arg_c, arg_v);
}
}
}
}
/*************************************************************************
* COMMANDS *
*************************************************************************/
static void print_commands(char * str, command_t * table) {
command_t * cmds;
char buf[80];
for (cmds = table; cmds->pc_name; cmds++) {
if (cmds->pc_func) {
if (str) printf("\t%s %s\n", str, cmds->pc_name);
else printf("\t%s\n", cmds->pc_name);
}
if (cmds->pc_sub_cmd) {
if (str) {
sprintf(buf, "%s %s", str, cmds->pc_name);
print_commands(buf, cmds->pc_sub_cmd);
} else {
print_commands(cmds->pc_name, cmds->pc_sub_cmd);
}
}
}
}
static
void usage(void)
{
printf("occtl: [OPTIONS...] {COMMAND}\n\n");
printf(" -s --socket-file Specify the server's occtl socket file\n");
printf(" -h --help Show this help\n");
printf(" -v --version Show the program's version\n");
printf(" -j --json Use JSON formatting for output\n");
printf("\n");
print_commands(0);
printf("\n");
}
void Summary::print(xmrig::Controller *controller)
{
print_versions(controller);
print_mode(controller);
print_algo(controller);
printPools(controller->config());
print_bind(controller);
# ifndef XMRIG_NO_API
print_api(controller);
# endif
print_commands(controller);
}
void Summary::print()
{
print_versions();
print_memory();
print_cpu();
print_threads();
print_pools();
# ifndef XMRIG_NO_API
print_api();
# endif
print_commands();
}
void bltin_completion(t_prompt *prompt, char **env)
{
int count;
int ret;
if ((prompt->offset =
get_offset(prompt->line, prompt->count_char, &ret)) == -1)
return ;
if (ret == 0
&& (count = count_commands(prompt, env)))
print_commands(prompt, env, count);
else
print_files(prompt);
}
static errcode_t exec_command(struct command_s *c)
{
errcode_t ret = 0;
unsigned int bytes, len;
switch (c->c_type) {
case REGISTER:
ret = o2dlm_initialize(dlmfs_path, c->c_domain, &dlm_ctxt);
break;
case UNREGISTER:
ret = o2dlm_destroy(dlm_ctxt);
dlm_ctxt = NULL;
break;
case LOCK:
ret = o2dlm_lock(dlm_ctxt, c->c_id, 0, c->c_level);
break;
case UNLOCK:
ret = o2dlm_unlock(dlm_ctxt, c->c_id);
break;
case TRYLOCK:
ret = o2dlm_lock(dlm_ctxt, c->c_id, O2DLM_TRYLOCK, c->c_level);
break;
case GETLVB:
ret = o2dlm_read_lvb(dlm_ctxt, c->c_id, lvb_buf, LVB_LEN,
&bytes);
if (!ret) {
printf("%u bytes read. LVB begins on following "
"line and is terminated by a newline\n",
bytes);
printf("%.*s\n", bytes, lvb_buf);
}
break;
case SETLVB:
len = strlen(c->c_lvb);
ret = o2dlm_write_lvb(dlm_ctxt, c->c_id, c->c_lvb, len,
&bytes);
if (!ret)
printf("%u bytes written.\n", bytes);
break;
case HELP:
default:
print_commands();
}
return ret;
}
void do_list (void)
{ header *hd;
int lcount=0;
output(" *** Builtin functions:\n");
print_builtin();
output(" *** Commands:\n");
print_commands();
output(" *** Your functions:\n");
hd=(header *)ramstart;
while ((char *)hd<udfend)
{ if (hd->type!=s_udf) break;
if (lcount+(int)strlen(hd->name)+2>=linelength)
{ lcount=0; output("\n"); }
output1("%s ",hd->name);
lcount+=(int)strlen(hd->name)+1;
hd=nextof(hd);
}
output("\n");
}
void PaintApp::Initialize()
{
// HACK for ubuntu1024: https://github.com/DrMcCoy/xoreos/commit/9a6c84d5458256ac5a0ff7525055ef2d8761e683
if (!XInitThreads()) {
throw "Failed to initialize Xlib muti-threading support";
}
mCurrentVideoMode = VideoMode::OpenGL;
mCurrentResolution = {640_px, 480_px};
InitVideo();
InitKinect("");
SelectRenderer(); // Kinect has to be set up for this!
mWindow = std::make_shared<kinex::Window>("paint");
mKinectBg = std::make_shared<NuiBackground>(mKinect);
mState = std::make_shared<PaintStatus>();
print_commands();
}
PROCESS_THREAD(command_process, ev, data)
{
static struct etimer commandTimeout;
static unsigned char buttonCount = 0;
PROCESS_BEGIN();
SENSORS_ACTIVATE(button_sensor);
while(1)
{
PROCESS_WAIT_EVENT();
if(ev == sensors_event && data == &button_sensor){
++buttonCount;
printf("Button pressed %d times\n", buttonCount);
if(buttonCount == 1)//first press, set the timer
{
etimer_set( &commandTimeout, COMMAND_TIMEOUT * CLOCK_SECOND );
}
else
{
etimer_restart(&commandTimeout);
}
}
else if(ev == PROCESS_EVENT_TIMER)
{
if(buttonCount != 0 && etimer_expired(&commandTimeout))
{
printf("Timer expired: count is %d\n", buttonCount);
etimer_stop(&commandTimeout);
command_switch(buttonCount);
buttonCount = 0;
print_commands();
}
}
}
PROCESS_END();
}
void show_usage_and_exit( void )
{
printf( "Specify one of the following commands:\n" );
print_commands();
exit( 1 );
}
void track_server_code (){
RegisterAs("TRACKSERVER");
// Server data
sw_info sw_infos [NUM_SWITCHES];
int sensor_info [NUM_SENSORS]; // time when the sensor is hit
int broken_sensors[NUM_SENSORS] = {0};
// Server's track data
track_node track[TRACK_MAX];
init_track(track);
init_broken_sensors(broken_sensors);
track_node *src, *dst;
// Received stuff
track_receive rcv_buff;
int sender_tid;
int request_type;
int sensor_index = 0;
//Reply buffs
int reply_dist = 0;
int reply_index = 0;
struct track_loc reply_loc;
char reply_buff;
int reply_buff_loc_dist [2];
struct train_server_request tsr;
int train_server_id;
while((train_server_id = WhoIs("TRAINSERVER")) == -1);
int track_to_train_courier_tid = Create(PR_COURIER, track_to_train_courier_code);
int track_to_train_courier_ready = 0;
Queue train_serverQ;
struct train_server_request allocated_buff[TRACK_TO_TRAIN_QUEUE_SIZE];
Queue_init (&train_serverQ, allocated_buff, TRACK_TO_TRAIN_QUEUE_SIZE, sizeof(struct train_server_request));
//things for shortest path request
track_node* path[TRACK_MAX] = {0};
int dist[TRACK_MAX] = {0};
int shortest_dist = 0;
routing_command commands[TRACK_MAX];
init_routing_commands(commands);
// switch_command sw_commands[NUM_MAX_SWITCH_ROUTE_COMMANDS];
// memset(sw_commands, 0, NUM_MAX_SWITCH_ROUTE_COMMANDS * sizeof(switch_command));
//things for changing switches when train goes
//within a specified route
Queue switch_queues[NUM_TRAINS];
Queue *Q;
switch_command switch_queue_buffers[NUM_TRAINS][NUM_MAX_SWITCH_ROUTE_COMMANDS];
memset(switch_queue_buffers, 0, NUM_TRAINS * NUM_MAX_SWITCH_ROUTE_COMMANDS * sizeof(switch_command));
int trnum;
for (trnum = 0; trnum < NUM_TRAINS; trnum++) {
Queue_init(&switch_queues[trnum], switch_queue_buffers[trnum], NUM_MAX_SWITCH_ROUTE_COMMANDS, sizeof(switch_command));
}
//
//Reservation data structures
track_reservation track_reservations[TRACK_MAX];
train_reservation_info tr_reservation_infos[NUM_TRAINS];
memset(track_reservations, 0, TRACK_MAX * sizeof(track_reservation));
memset(tr_reservation_infos, -1, NUM_TRAINS * sizeof(train_reservation_info));
//
Queue isReservableQueue;
isReservableQueueItem isReservableQueueItems[NUM_TRAINS];
Queue_init(&isReservableQueue, isReservableQueueItems, NUM_TRAINS, sizeof(isReservableQueueItem));
isReservableQueueItem irqi;
int reserve_ret = -1;
int ret;
while(1){
Receive(&sender_tid, &rcv_buff, sizeof(track_receive));
request_type = rcv_buff.type;
switch (request_type){
case TRACK_TYPE_COURIER_RTS:
track_to_train_courier_ready = 1;
break;
case TRACK_TYPE_SENSOR_INFO:
sensor_index = (rcv_buff.data.track_data.data2 - 'A')*16+rcv_buff.data.track_data.data1-1;
//if (sensor_index == 56) {HardDebug("D9 is hit. Hit time:%d. Rcv Time:%d", rcv_buff.data.track_data.time, Time());}
sensor_info[sensor_index] = rcv_buff.data.track_data.time;
Reply(sender_tid, &reply_buff, sizeof(char));
tsr.type = TRAIN_TYPE_SENSOR_UPDATE;
memcpy(&tsr.data, &rcv_buff.data.track_data, sizeof(track_info));
if (!broken_sensors[sensor_index]) {
//Send(train_server_id, &tsr, sizeof(struct train_server_request), &reply_buff, sizeof(char));
ret = Queue_push(&train_serverQ, &tsr);
Warning(ret == 0, "TRACKSERVER: Queue_push failed");
}
break;
case TRACK_TYPE_SWITCH_INFO:
(sw_infos[(int)rcv_buff.data.track_data.data1]).swdir = rcv_buff.data.track_data.data2;
(sw_infos[(int)rcv_buff.data.track_data.data1]).time = rcv_buff.data.track_data.time;
Reply(sender_tid, &reply_buff, sizeof(char));
tsr.type = TRAIN_TYPE_SWITCH_UPDATE;
memcpy(&tsr.data, &rcv_buff.data.track_data, sizeof(track_info));
//Send(train_server_id, &tsr, sizeof(struct train_server_request), &reply_buff, sizeof(char));
ret = Queue_push(&train_serverQ, &tsr);
Warning(ret == 0, "TRACKSERVER: Queue_push failed");
break;
case TRACK_TYPE_DIST:
if((int)rcv_buff.data.track_data.data1 >= TRACK_MAX || (int)rcv_buff.data.track_data.data2 >= TRACK_MAX) {
reply_dist = 0;
}
else {
src = &track[(int)rcv_buff.data.track_data.data1];
dst = &track[(int)rcv_buff.data.track_data.data2];
reply_dist = get_dist_between_nodes(src, dst, sw_infos);
}
Reply(sender_tid, &reply_dist, sizeof(int));
break;
case TRACK_TYPE_NEXT_LOC:
//get current loc_index and find next node
__get_next_node((int)rcv_buff.data.track_data.data1, track, sw_infos, &reply_loc.index, reply_loc.name);
Reply(sender_tid, &reply_loc, sizeof(struct track_loc));
break;
case TRACK_TYPE_NEXT_SENSOR:
reply_index = get_next_sensor_index((int)rcv_buff.data.track_request_data.data1, track, sw_infos, broken_sensors, &tsr.data.spd.spd_val);
Assert(reply_index == tsr.data.spd.spd_val.next_expected_sensor_index, "reply_index != result->next_expected_sensor_index");
//Debug("TRACKSERVER: Got next expected sensor %d, after that %d", tsr.data.spd.spd_val.next_expected_sensor_index, tsr.data.spd.spd_val.sensor_after_expected_sensor);
Reply(sender_tid, &reply_index, sizeof(int));
tsr.type = TRAIN_TYPE_SENSOR_PREDICTION;
tsr.data.spd.trnum = (int)rcv_buff.data.track_request_data.data2;
if (rcv_buff.data.track_request_data.data3) {
//Send(train_server_id, &tsr, sizeof(train_server_request), &reply_buff, sizeof(char));
ret = Queue_push(&train_serverQ, &tsr);
Warning(ret == 0, "TRACKSERVER: Queue_push failed");
}
break;
case TRACK_TYPE_LOC_NAME:
Reply(sender_tid, (char*)track[(int)rcv_buff.data.track_data.data1].name, 6 * sizeof(char));
break;
case TRACK_TYPE_SENSOR_REVERSE:
reply_index = get_reverse_sensor((int)rcv_buff.data.track_request_data.data1, track, sw_infos, broken_sensors, &tsr.data.spd.spd_val);
Reply(sender_tid, &reply_index, sizeof(int));
tsr.data.spd.trnum = (int)rcv_buff.data.track_request_data.data2;
if (rcv_buff.data.track_request_data.data3) {
//Send(train_server_id, &tsr, sizeof(train_server_request), &reply_buff, sizeof(char));
ret = Queue_push(&train_serverQ, &tsr);
Warning(ret == 0, "TRACKSERVER: Queue_push failed");
}
break;
case TRACK_TYPE_UPDATE_LOC_AND_DISTANCE:
translate_sensor_loc(rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data2, track, sw_infos, reply_buff_loc_dist);
Reply(sender_tid, reply_buff_loc_dist, 2*sizeof(int));
break;
case TRACK_TYPE_FIND_ROUTE:
Warning(((0 <= rcv_buff.data.track_request_data.data2 && rcv_buff.data.track_request_data.data2 < TRACK_MAX) &&
(0 <= rcv_buff.data.track_request_data.data3 && rcv_buff.data.track_request_data.data3 < TRACK_MAX)),
"TRACKSERVER: TRACK_TYPE_FIND_ROUTE - Source(%d) or destination(%d) is invalid", rcv_buff.data.track_request_data.data2, rcv_buff.data.track_request_data.data3);
//Debug("FINDING ROUTE:trnum:%d ~ src:%s ~ dest:%s ~ offset:%d",rcv_buff.data.track_request_data.data1, track[rcv_buff.data.track_request_data.data2].name, track[rcv_buff.data.track_request_data.data3].name, rcv_buff.data.track_request_data.data4);
shortest_dist = shortest_path((int)rcv_buff.data.track_request_data.data2, (int)rcv_buff.data.track_request_data.data3, track, path, dist, track_reservations);
if (shortest_dist == __INFINITY)
{
shortest_path((int)rcv_buff.data.track_request_data.data2, (int)rcv_buff.data.track_request_data.data3, track, path, dist, 0);
}
generate_commands(path, track, commands);
print_commands(commands);
pull_out_switch_orders(commands, tsr.data.path_commands.sw_commands, &switch_queues[rcv_buff.data.track_request_data.data1]);
pull_out_reverse_orders(commands, tsr.data.path_commands.rv_commands);
tsr.type = TRAIN_TYPE_ROUTE_SWITCH_ORDERS;
Reply(sender_tid, &tsr, sizeof(train_server_request));
break;
case TRACK_TYPE_RESERVATION_INIT:
reserve_ret = reserve_inital_piece (track_reservations,
track,
tr_reservation_infos,
sw_infos,
&switch_queues[rcv_buff.data.track_request_data.data1],
rcv_buff.data.track_request_data.data1,
rcv_buff.data.track_request_data.data2,
rcv_buff.data.track_request_data.data3,
rcv_buff.data.track_request_data.data4);
Debug("TRACKSERVER: Received reservation initialization request for train %d", rcv_buff.data.track_request_data.data1);
tsr.type = TRAIN_TYPE_RESERVATION_SUCCESS;
Reply(sender_tid, &tsr, sizeof(train_server_request));
break;
case TRACK_TYPE_RESERVATION:
Q = &switch_queues[rcv_buff.data.track_request_data.data1];
reserve_ret = reserve_track(track_reservations, track, tr_reservation_infos, sw_infos, Q, rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data2);
ret = release_track(track_reservations, track, tr_reservation_infos, sw_infos, rcv_buff.data.track_request_data.data1, rcv_buff.data.track_request_data.data3);
Assert (ret != -1, "TRACKSERVER: release failed: ret:%d", ret);
tsr.type = (reserve_ret == -1) ? TRAIN_TYPE_RESERVATION_FAILURE : TRAIN_TYPE_RESERVATION_SUCCESS;
Reply(sender_tid, &tsr, sizeof(train_server_request));
if (/*rcv_buff.data.track_request_data.data2 < 0 ||*/ rcv_buff.data.track_request_data.data3 > 0) {
check_isReservableRequests(&isReservableQueue, &train_serverQ, track, sw_infos, track_reservations, tr_reservation_infos, train_server_id);
}
print_total_reserved_dist(track_reservations, tr_reservation_infos, rcv_buff.data.track_request_data.data1);
break;
case TRACK_TYPE_RESERVATION_REVERSE:
reserve_ret = reverse_reservation (track,
tr_reservation_infos,
sw_infos,
rcv_buff.data.track_request_data.data1);
tsr.type = TRAIN_TYPE_RESERVATION_SUCCESS;
Reply(sender_tid, &tsr, sizeof(train_server_request));
break;
case TRACK_TYPE_RESERVATION_SENSOR_UPDATE:
reserve_ret = reservation_sensor_update(track_reservations,
track,
tr_reservation_infos,
sw_infos,
&switch_queues[rcv_buff.data.track_request_data.data1],
rcv_buff.data.track_request_data.data1,
rcv_buff.data.track_request_data.data2,
rcv_buff.data.track_request_data.data3,
rcv_buff.data.track_request_data.data4,
rcv_buff.data.track_request_data.data5);
tsr.type = (reserve_ret == -1) ? TRAIN_TYPE_RESERVATION_FAILURE : TRAIN_TYPE_RESERVATION_SUCCESS;
Reply(sender_tid, &tsr, sizeof(train_server_request));
//check_isReservableRequests(&isReservableQueue, &train_serverQ, track, sw_infos, track_reservations, tr_reservation_infos, train_server_id);
break;
case TRACK_TYPE_RESERVATION_STOP_UPDATE:
reserve_ret = reservation_stop_update ( track_reservations,
track,
tr_reservation_infos,
sw_infos,
&switch_queues[rcv_buff.data.track_request_data.data1],
rcv_buff.data.track_request_data.data1,
rcv_buff.data.track_request_data.data2,
rcv_buff.data.track_request_data.data3,
rcv_buff.data.track_request_data.data4,
rcv_buff.data.track_request_data.data5);
tsr.type = /*(reserve_ret == -1) ? TRAIN_TYPE_RESERVATION_FAILURE :*/ TRAIN_TYPE_RESERVATION_SUCCESS;
Reply(sender_tid, &tsr, sizeof(train_server_request));
break;
case TRACK_TYPE_IS_RESERVABLE:
tsr.type = TRAIN_TYPE_REQ_IN_PROGRESS;
Reply(sender_tid, &tsr, sizeof(train_server_request));
irqi.trnum = rcv_buff.data.track_request_data.data1;
irqi.mm = rcv_buff.data.track_request_data.data2;
ret = Queue_push(&isReservableQueue, &irqi);
Warning(ret == 0, "TRACKSERVER: Queue_push failed");
break;
case TRACK_TYPE_PRINT_RESERVATIONS:
Reply(sender_tid, &reply_buff, sizeof(char));
print_reservations(track_reservations, track, tr_reservation_infos);
break;
default:
Reply(sender_tid, &reply_buff, sizeof(char));
Warning(0,"Unknown receive in track_server_code: type=%d from %d", request_type, sender_tid);
break;
}
if (track_to_train_courier_ready && !Queue_pop(&train_serverQ, &tsr)){
Reply(track_to_train_courier_tid, &tsr, sizeof(train_server_request));
track_to_train_courier_ready = 0;
}
}
Exit();
Warning(0,"Unexpected return from Exit() at track_server_code\n\r");
}
void commands(char** args, int argc) {
printf("Available commands are: \n");
print_commands();
}
static void run_tester_help(int argc, char **argv)
{
print_commands(tester_commands, TESTER_SUPPORTED_COMMANDS);
exit(EXIT_SUCCESS);
}
static void process_command(int *quit)
{
char inbuf[132];
int x = 0, y = 0;
if (!opt_cmd) {
fgets(inbuf, sizeof(inbuf), stdin);
sscanf(inbuf, "%s %d %d", cmd, &x, &y);
}
if (!strncmp(cmd, "EXIT", 4)) {
*quit = 1;
unlock_all();
return;
}
if (!strncmp(cmd, "CLOSE", 5)) {
*quit = 1;
openclose_ls = 1;
unlock_all();
return;
}
if (!strncmp(cmd, "kill", 4)) {
printf("process exiting\n");
exit(0);
}
if (!strncmp(cmd, "lock", 4) && strlen(cmd) == 4) {
lock(x, y);
return;
}
if (!strncmp(cmd, "unlock", 6) && strlen(cmd) == 6) {
unlock(x);
return;
}
if (!strncmp(cmd, "unlockf", 7) && strlen(cmd) == 7) {
unlockf(x);
return;
}
if (!strncmp(cmd, "cancel", 6) && strlen(cmd) == 6) {
cancel(x);
return;
}
if (!strncmp(cmd, "canceld", 7) && strlen(cmd) == 7) {
canceld(x, y);
return;
}
if (!strncmp(cmd, "lock_sync", 9) && strlen(cmd) == 9) {
lock_sync(x, y);
return;
}
if (!strncmp(cmd, "unlock_sync", 11) && strlen(cmd) == 11) {
unlock_sync(x);
return;
}
if (!strncmp(cmd, "lock-kill", 9) && strlen(cmd) == 9) {
lock(x, y);
printf("process exiting\n");
exit(0);
}
if (!strncmp(cmd, "unlock-kill", 11) && strlen(cmd) == 11) {
unlock(x);
printf("process exiting\n");
exit(0);
}
if (!strncmp(cmd, "lock-cancel", 11) && strlen(cmd) == 11) {
lock(x, y);
/* usleep(1000 * z); */
cancel(x);
return;
}
if (!strncmp(cmd, "lock-unlockf", 12) && strlen(cmd) == 12) {
lock(x, y);
/* usleep(1000 * z); */
unlockf(x);
return;
}
if (!strncmp(cmd, "ex", 2)) {
lock(x, LKM_EXMODE);
return;
}
if (!strncmp(cmd, "pr", 2)) {
lock(x, LKM_PRMODE);
return;
}
if (!strncmp(cmd, "hold", 4) && strlen(cmd) == 4) {
lock_all(LKM_PRMODE);
return;
}
if (!strncmp(cmd, "hold-kill", 9) && strlen(cmd) == 9) {
lock_all(LKM_PRMODE);
exit(0);
}
if (!strncmp(cmd, "release", 7) && strlen(cmd) == 7) {
unlock_all();
return;
}
if (!strncmp(cmd, "release-kill", 12) && strlen(cmd) == 12) {
unlock_all();
exit(0);
}
if (!strncmp(cmd, "dump", 4) && strlen(cmd) == 4) {
dump();
return;
}
if (!strncmp(cmd, "stress", 6) && strlen(cmd) == 6) {
if (iterations && !x)
x = iterations;
stress(x);
return;
}
if (!strncmp(cmd, "tstress", 7) && strlen(cmd) == 7) {
tstress(x);
return;
}
if (!strncmp(cmd, "dstress", 7) && strlen(cmd) == 7) {
dstress(x);
return;
}
if (!strncmp(cmd, "stress_delay", 12) && strlen(cmd) == 12) {
stress_delay = x;
return;
}
if (!strncmp(cmd, "stress_lock_only", 16) && strlen(cmd) == 16) {
stress_lock_only = !stress_lock_only;
printf("stress_lock_only is %s\n", stress_lock_only ? "on" : "off");
return;
}
if (!strncmp(cmd, "stress_stop", 11) && strlen(cmd) == 11) {
stress_stop = !stress_stop;
printf("stress_stop is %d\n", stress_stop);
return;
}
if (!strncmp(cmd, "ignore_bast", 11) && strlen(cmd) == 11) {
ignore_bast = !ignore_bast;
printf("ignore_bast is %s\n", ignore_bast ? "on" : "off");
return;
}
if (!strncmp(cmd, "our_xid", 7) && strlen(cmd) == 7) {
our_xid = x;
printf("our_xid is %llx\n", (unsigned long long)our_xid);
return;
}
if (!strncmp(cmd, "purge", 5) && strlen(cmd) == 5) {
purge(x, y);
return;
}
if (!strncmp(cmd, "purgetest", 9) && strlen(cmd) == 9) {
purgetest(x, y);
return;
}
if (!strncmp(cmd, "noqueue", 7)) {
noqueue = !noqueue;
printf("noqueue is %s\n", noqueue ? "on" : "off");
return;
}
if (!strncmp(cmd, "persistent", 10)) {
persistent = !persistent;
printf("persistent is %s\n", persistent ? "on" : "off");
return;
}
if (!strncmp(cmd, "minhold", 7)) {
minhold = x;
return;
}
if (!strncmp(cmd, "timeout", 7)) {
timeout = (uint64_t) 100 * x; /* dlm takes it in centiseconds */
printf("timeout is %d\n", x);
return;
}
if (!strncmp(cmd, "quiet", 5)) {
quiet = !quiet;
printf("quiet is %d\n", quiet);
return;
}
if (!strncmp(cmd, "verbose", 7)) {
verbose = !verbose;
printf("verbose is %d\n", verbose);
return;
}
if (!strncmp(cmd, "help", 4)) {
print_commands();
return;
}
if (!strncmp(cmd, "settings", 8)) {
print_settings();
return;
}
printf("unknown command %s\n", cmd);
}
int main(int argc, char **argv)
{
program_name = argv[0];
static char stderr_buf[BUFSIZ];
setbuf(stderr, stderr_buf);
assert(NCOMMANDS <= MAX_COMMANDS);
string Pargs, Largs, Fargs;
int vflag = 0;
int Vflag = 0;
int zflag = 0;
int iflag = 0;
int Xflag = 0;
int oflag = 0;
int safer_flag = 1;
int opt;
const char *command_prefix = getenv("GROFF_COMMAND_PREFIX");
if (!command_prefix)
command_prefix = PROG_PREFIX;
commands[TROFF_INDEX].set_name(command_prefix, "troff");
static const struct option long_options[] = {
{ "help", no_argument, 0, 'h' },
{ "version", no_argument, 0, 'v' },
{ NULL, 0, 0, 0 }
};
while ((opt = getopt_long(argc, argv,
"abcCd:eEf:F:gGhiI:lL:m:M:n:No:pP:r:RsStT:UvVw:W:XzZ",
long_options, NULL))
!= EOF) {
char buf[3];
buf[0] = '-';
buf[1] = opt;
buf[2] = '\0';
switch (opt) {
case 'i':
iflag = 1;
break;
case 'I':
commands[SOELIM_INDEX].set_name(command_prefix, "soelim");
commands[SOELIM_INDEX].append_arg(buf, optarg);
// .psbb may need to search for files
commands[TROFF_INDEX].append_arg(buf, optarg);
// \X'ps:import' may need to search for files
Pargs += buf;
Pargs += optarg;
Pargs += '\0';
break;
case 't':
commands[TBL_INDEX].set_name(command_prefix, "tbl");
break;
case 'p':
commands[PIC_INDEX].set_name(command_prefix, "pic");
break;
case 'g':
commands[GRN_INDEX].set_name(command_prefix, "grn");
break;
case 'G':
commands[GRAP_INDEX].set_name(command_prefix, "grap");
break;
case 'e':
commands[EQN_INDEX].set_name(command_prefix, "eqn");
break;
case 's':
commands[SOELIM_INDEX].set_name(command_prefix, "soelim");
break;
case 'R':
commands[REFER_INDEX].set_name(command_prefix, "refer");
break;
case 'z':
case 'a':
commands[TROFF_INDEX].append_arg(buf);
// fall through
case 'Z':
zflag++;
break;
case 'l':
lflag++;
break;
case 'V':
Vflag++;
break;
case 'v':
vflag = 1;
{
printf("GNU groff version %s\n", Version_string);
printf("Copyright (C) 2004 Free Software Foundation, Inc.\n"
"GNU groff comes with ABSOLUTELY NO WARRANTY.\n"
"You may redistribute copies of groff and its subprograms\n"
"under the terms of the GNU General Public License.\n"
"For more information about these matters, see the file named COPYING.\n");
printf("\ncalled subprograms:\n\n");
fflush(stdout);
}
commands[POST_INDEX].append_arg(buf);
// fall through
case 'C':
commands[SOELIM_INDEX].append_arg(buf);
commands[REFER_INDEX].append_arg(buf);
commands[PIC_INDEX].append_arg(buf);
commands[GRAP_INDEX].append_arg(buf);
commands[TBL_INDEX].append_arg(buf);
commands[GRN_INDEX].append_arg(buf);
commands[EQN_INDEX].append_arg(buf);
commands[TROFF_INDEX].append_arg(buf);
break;
case 'N':
commands[EQN_INDEX].append_arg(buf);
break;
case 'h':
help();
break;
case 'E':
case 'b':
commands[TROFF_INDEX].append_arg(buf);
break;
case 'c':
commands[TROFF_INDEX].append_arg(buf);
break;
case 'S':
safer_flag = 1;
break;
case 'U':
safer_flag = 0;
break;
case 'T':
if (strcmp(optarg, "html") == 0) {
// force soelim to aid the html preprocessor
commands[SOELIM_INDEX].set_name(command_prefix, "soelim");
}
if (strcmp(optarg, "Xps") == 0) {
warning("-TXps option is obsolete: use -X -Tps instead");
device = "ps";
Xflag++;
}
else
device = optarg;
break;
case 'F':
font::command_line_font_dir(optarg);
if (Fargs.length() > 0) {
Fargs += PATH_SEP_CHAR;
Fargs += optarg;
}
else
Fargs = optarg;
break;
case 'o':
oflag = 1;
case 'f':
case 'm':
case 'r':
case 'd':
case 'n':
case 'w':
case 'W':
commands[TROFF_INDEX].append_arg(buf, optarg);
break;
case 'M':
commands[EQN_INDEX].append_arg(buf, optarg);
commands[GRAP_INDEX].append_arg(buf, optarg);
commands[GRN_INDEX].append_arg(buf, optarg);
commands[TROFF_INDEX].append_arg(buf, optarg);
break;
case 'P':
Pargs += optarg;
Pargs += '\0';
break;
case 'L':
append_arg_to_string(optarg, Largs);
break;
case 'X':
Xflag++;
break;
case '?':
usage(stderr);
exit(1);
break;
default:
assert(0);
break;
}
}
if (safer_flag)
commands[PIC_INDEX].append_arg("-S");
else
commands[TROFF_INDEX].insert_arg("-U");
font::set_unknown_desc_command_handler(handle_unknown_desc_command);
if (!font::load_desc())
fatal("invalid device `%1'", device);
if (!postdriver)
fatal("no `postpro' command in DESC file for device `%1'", device);
if (predriver && !zflag) {
commands[TROFF_INDEX].insert_arg(commands[TROFF_INDEX].get_name());
commands[TROFF_INDEX].set_name(predriver);
// pass the device arguments to the predrivers as well
commands[TROFF_INDEX].insert_args(Pargs);
if (vflag)
commands[TROFF_INDEX].insert_arg("-v");
}
const char *real_driver = 0;
if (Xflag) {
real_driver = postdriver;
postdriver = (char *)GXDITVIEW;
commands[TROFF_INDEX].append_arg("-r" XREG "=", "1");
}
if (postdriver)
commands[POST_INDEX].set_name(postdriver);
int gxditview_flag = postdriver && strcmp(xbasename(postdriver), GXDITVIEW) == 0;
if (gxditview_flag && argc - optind == 1) {
commands[POST_INDEX].append_arg("-title");
commands[POST_INDEX].append_arg(argv[optind]);
commands[POST_INDEX].append_arg("-xrm");
commands[POST_INDEX].append_arg("*iconName:", argv[optind]);
string filename_string("|");
append_arg_to_string(argv[0], filename_string);
append_arg_to_string("-Z", filename_string);
for (int i = 1; i < argc; i++)
append_arg_to_string(argv[i], filename_string);
filename_string += '\0';
commands[POST_INDEX].append_arg("-filename");
commands[POST_INDEX].append_arg(filename_string.contents());
}
if (gxditview_flag && Xflag) {
string print_string(real_driver);
if (spooler) {
print_string += " | ";
print_string += spooler;
print_string += Largs;
}
print_string += '\0';
commands[POST_INDEX].append_arg("-printCommand");
commands[POST_INDEX].append_arg(print_string.contents());
}
const char *p = Pargs.contents();
const char *end = p + Pargs.length();
while (p < end) {
commands[POST_INDEX].append_arg(p);
p = strchr(p, '\0') + 1;
}
if (gxditview_flag)
commands[POST_INDEX].append_arg("-");
if (lflag && !vflag && !Xflag && spooler) {
commands[SPOOL_INDEX].set_name(BSHELL);
commands[SPOOL_INDEX].append_arg(BSHELL_DASH_C);
Largs += '\0';
Largs = spooler + Largs;
commands[SPOOL_INDEX].append_arg(Largs.contents());
}
if (zflag) {
commands[POST_INDEX].set_name(0);
commands[SPOOL_INDEX].set_name(0);
}
commands[TROFF_INDEX].append_arg("-T", device);
// html renders equations as images via ps
if (strcmp(device, "html") == 0) {
if (oflag)
fatal("`-o' option is invalid with device `html'");
commands[EQN_INDEX].append_arg("-Tps:html");
}
else
commands[EQN_INDEX].append_arg("-T", device);
commands[GRN_INDEX].append_arg("-T", device);
int first_index;
for (first_index = 0; first_index < TROFF_INDEX; first_index++)
if (commands[first_index].get_name() != 0)
break;
if (optind < argc) {
if (argv[optind][0] == '-' && argv[optind][1] != '\0')
commands[first_index].append_arg("--");
for (int i = optind; i < argc; i++)
commands[first_index].append_arg(argv[i]);
if (iflag)
commands[first_index].append_arg("-");
}
if (Fargs.length() > 0) {
string e = "GROFF_FONT_PATH";
e += '=';
e += Fargs;
char *fontpath = getenv("GROFF_FONT_PATH");
if (fontpath && *fontpath) {
e += PATH_SEP_CHAR;
e += fontpath;
}
e += '\0';
if (putenv(strsave(e.contents())))
fatal("putenv failed");
}
{
// we save the original path in GROFF_PATH__ and put it into the
// environment -- troff will pick it up later.
char *path = getenv("PATH");
string e = "GROFF_PATH__";
e += '=';
if (path && *path)
e += path;
e += '\0';
if (putenv(strsave(e.contents())))
fatal("putenv failed");
char *binpath = getenv("GROFF_BIN_PATH");
string f = "PATH";
f += '=';
if (binpath && *binpath)
f += binpath;
else
f += BINPATH;
if (path && *path) {
f += PATH_SEP_CHAR;
f += path;
}
f += '\0';
if (putenv(strsave(f.contents())))
fatal("putenv failed");
}
if (Vflag)
print_commands(Vflag == 1 ? stdout : stderr);
if (Vflag == 1)
exit(0);
return run_commands(vflag);
}
/**
* Handler to check user input, and see if it matches any avaible commands.
* Will call the right methods for executing commands
*/
void handle_keyboard(sp_session *session, struct play_queue* node)
{
char buffer[1024];
fgets(buffer, sizeof(buffer), stdin);
strtok(buffer, "\n");
if (strcmp(buffer, "search") == 0) {
player_reset();
run_search(session);
} else if ((strcmp(buffer, "list") == 0) || (strcmp(buffer, "ls") == 0 )) {
print_playlists(session, pc);
} else if(strcmp(buffer, "qshuffle") == 0) {
queue_shuffle();
} else if (strcmp(buffer, "queueadd") == 0) {
sp_playlist* pl = parse_play_command(session, buffer, node);
printf("done finding playlist \n");
if(pl != NULL) printf("queueadd: %s\n", sp_playlist_name(pl));
else {
printf("no playlist\n");
return;
}
int index;
char input[10];
fputs("Song number: ", stdout);
fgets(input, sizeof(input) - 1, stdin);
sscanf(input, "%d", &index);
if(sp_playlist_num_tracks(pl) < index) {
printf("index too high!\n");
return;
}
sp_track* track = pl_find_song_by_id(pl, index);
if(track != NULL) queue_add_first(track);
} else if (strcmp(buffer, "list songs") == 0 ) {
//release all threads
sp_playlist* pl = playlist_find_by_num(session, pc);
print_tracks_in_playlist(session, pl);
} else if (strcmp(buffer, "help") == 0) {
print_commands();
} else if (strcmp(buffer, "queue") == 0) {
queue_print(node);
} else if (strcmp(buffer, "shuffle mode") == 0) {
print_commands();
} else if(strncmp(buffer, "play", strlen("play")) == 0) {
player_reset();
sp_playlist* pl = parse_play_command(session, buffer, node);
if(pl!=NULL) queue_add_playlist(pl);
else {
printf("ERROR playlist is null\n");
return;
}
queue_go_next(session);
} else if(strncmp(buffer, "shuffle", strlen("shuffle")) == 0) {
player_reset();
shuffle_mode = TRUE;
sp_playlist* pl = parse_play_command(session, buffer, node);
if(pl!=NULL) queue_add_playlist(pl);
else {
printf("ERROR playlist is null\n");
return;
}
queue_shuffle();
queue_go_next(session);
} else if(strcmp(buffer, "pause") == 0 || strcmp(buffer, "p") == 0) {
player_pause(session);
play_info();
} else if (strcmp(buffer, "next") == 0 || strcmp(buffer, "n") == 0) {
end_track(session);
} else if (strcmp(buffer, "stop") == 0) {
} else if (strcmp(buffer, "info") == 0) {
play_info();
} else if (strcmp(buffer, "quit") == 0) {
queue_free();
quit_program(session);
} else {
printf("Unkown command!\n");
}
printf("> ");
fflush(stdout);
return;
}
void Parser_qhelp(int argc, char *argv[]) {
printf("Available commands are:\n");
print_commands(NULL, top_level);
}
int main(int argc, char *argv[]) {
int opt = 0;
int longIndex = 0;
int rows = 5;
int cols = 5;
int pop = 10;
int rand = 0;
opt = getopt_long(argc, argv, optString, build_args, &longIndex);
while(opt != -1) {
switch(opt) {
case 'R':
printf("%c\n", (char)opt);
rows = atoi(optarg);
break;
case 'C':
printf("%c\n", (char)opt);
cols = atoi(optarg);
break;
case 'N':
printf("%c\n", (char)opt);
pop = atoi(optarg);
break;
case 'h':
case '?':
print_help();
break;
case 0:
if(strcmp("rand", build_args[longIndex].name) == 0) {
printf("random\n");
rand = 1;
}
break;
default:
break;
}
opt = getopt_long(argc, argv, optString, build_args, &longIndex);
}
char *command = malloc(sizeof(char) * 256);
int a1 = 0;
int a2 = 0;
int a3 = 0;
GW world = malloc(sizeof(GW));
world = gw_build(rows, cols, pop, rand);
print_commands();
while(1) {
printf("Enter a command: ");
scanf("%s %d %d %d", command, &a1, &a2, &a3);
if(strcmp("q", command) == 0) {
printf("\n\nExiting...\n");
return 0;
}
else if(strcmp("kill", command) == 0) {
printf("hey\n");
printf("%d\n", a1);
}
}
}
void main()
{
RBTree *t = new RBTree();
int n;
RBNode *node;
char c;
do
{
print_commands();
c = getch();
if (c == 0)
c = getch();
if (c != 27)
printf("%c\n\n", c);
switch (c)
{
case 'i':
printf("Node to insert: ");
scanf("%d", &n);
t->addNode(new RBNode(n));
printf("Node inserted.");
break;
case 's':
printf("Node to search for: ");
scanf("%d", &n);
if (t->findNode(n, t->getRoot()) == NULL)
printf("Can't find node with key %d.", n);
else
printf("Found a node with key %d.", n);
break;
case 'd':
printf("Node to delete: ");
scanf("%d", &n);
node = t->findNode(n, t->getRoot());
if (node == NULL)
printf("Can't find node with key %d.", n);
else
{
t->deleteNode(node);
printf("Node %d deleted.", n);
}
break;
case 'p':
clrscr();
printf("Tree is: \n\n");
t->prettyPrint(t->getRoot());
break;
case 27:
break;
default:
printf("Unknown command.");
break;
}
if (c != 27)
{
printf("\n\nPress any key to continue.");
if (getch() == 0)
getch();
}
}
while (c != 27);
delete t;
}
void human_game() {
printf("Welcome to 2048!\n");
print_commands();
//char buf[MAXLINE];
Game g = init_game(squaresum_heuristic);
print_game(g);
char in;
int playing = 1;
while (playing) {
in = getc(stdin);
if (in == '\033') {
getc(stdin);
switch (getc(stdin)) {
case 'A':
in = 'u';
break;
case 'B':
in = 'd';
break;
case 'C':
in = 'r';
break;
case 'D':
in = 'l';
break;
default:
break;
}
}
switch (in) {
case 'q':
playing = 0;
break;
case 'u':
make_move(g, Up);
print_game(g);
break;
case 'd':
make_move(g, Down);
print_game(g);
break;
case 'l':
make_move(g, Left);
print_game(g);
break;
case 'r':
make_move(g, Right);
print_game(g);
break;
case 'h':
print_commands();
break;
default:
break;
}
PointList pl = open_spaces(g->board);
if (pl_empty(pl)) {
playing = 0;
}
pl_free(pl);
}
print_game(g);
printf("Game Over! Final Score: %d\n", g->score);
}
static int handle_help_cmd(CONN_TYPE * conn, const char *arg, cmd_params_st *params)
{
print_commands(1);
return 0;
}
void PaintApp::ProcessInput()
{
SDL_Event event;
if (!SDL_PollEvent(&event)) {
return;
}
if((SDL_QUIT == event.type) || (SDLK_ESCAPE == event.key.keysym.sym)) {
// The user closed the window or pressed ESC.
mQuitRequested = true;
return;
}
switch (event.type)
{
case SDL_VIDEORESIZE:
{
// FIXME: SDL_VIDEORESIZE is buggy in SDL 1.2.15, see:
// http://bugzilla.libsdl.org/show_bug.cgi?id=1430
mCurrentResolution = {event.resize.w, event.resize.h};
InitVideo();
}
break;
case SDL_KEYDOWN:
{
if (SDLK_h == event.key.keysym.sym) {
print_commands();
}
else if (SDLK_s == event.key.keysym.sym) {
mCurrentVideoMode = VideoMode::Software;
InitVideo();
SelectRenderer();
}
else if (SDLK_o == event.key.keysym.sym) {
mCurrentVideoMode = VideoMode::OpenGL;
InitVideo();
SelectRenderer();
}
else if (SDLK_b == event.key.keysym.sym) {
mKinectBg->SwitchMode();
}
}
break;
case SDL_MOUSEBUTTONDOWN:
{
if (event.button.button == SDL_BUTTON_LEFT) {
mState->drawing = true;
mState->active_line.push_back({event.button.x, event.button.y});
}
else if (event.button.button == SDL_BUTTON_RIGHT) {
mState->lines.clear();
}
}
break;
case SDL_MOUSEBUTTONUP:
mState->lines.push_back(mState->active_line);
mState->active_line.clear();
mState->drawing = false;
break;
case SDL_MOUSEMOTION:
{
if (mState->drawing) {
mState->active_line.push_back({event.motion.x, event.motion.y});
}
}
break;
default:
break;
}
}
/* returns:
* <0 for error
* -1 out of memory
* -2 other
* 0 for async dispatched
* 1 for command completed (connection can be closed)
*/
int execute_or_dispatch_command(client_conn_t *conn, enum commands cmd, const char *argument)
{
int desc = conn->sd;
char term = conn->term;
const struct cl_engine *engine = conn->engine;
/* execute commands that can be executed quickly on the recvloop thread,
* these must:
* - not involve any operation that can block for a long time, such as disk
* I/O
* - send of atomic message is allowed.
* Dispatch other commands */
if (conn->group) {
switch (cmd) {
case COMMAND_FILDES:
case COMMAND_SCAN:
case COMMAND_END:
case COMMAND_INSTREAM:
case COMMAND_INSTREAMSCAN:
case COMMAND_VERSION:
case COMMAND_PING:
case COMMAND_STATS:
case COMMAND_COMMANDS:
/* These commands are accepted inside IDSESSION */
break;
default:
/* these commands are not recognized inside an IDSESSION */
conn_reply_error(conn, "Command invalid inside IDSESSION.");
logg("$SESSION: command is not valid inside IDSESSION: %d\n", cmd);
conn->group = NULL;
return 1;
}
}
switch (cmd) {
case COMMAND_SHUTDOWN:
pthread_mutex_lock(&exit_mutex);
progexit = 1;
pthread_mutex_unlock(&exit_mutex);
return 1;
case COMMAND_RELOAD:
pthread_mutex_lock(&reload_mutex);
reload = 1;
pthread_mutex_unlock(&reload_mutex);
mdprintf(desc, "RELOADING%c", term);
/* we set reload flag, and we'll reload before closing the
* connection */
return 1;
case COMMAND_PING:
if (conn->group)
mdprintf(desc, "%u: PONG%c", conn->id, term);
else
mdprintf(desc, "PONG%c", term);
return conn->group ? 0 : 1;
case COMMAND_VERSION:
{
if (conn->group)
mdprintf(desc, "%u: ", conn->id);
print_ver(desc, conn->term, engine);
return conn->group ? 0 : 1;
}
case COMMAND_COMMANDS:
{
if (conn->group)
mdprintf(desc, "%u: ", conn->id);
print_commands(desc, conn->term, engine);
return conn->group ? 0 : 1;
}
case COMMAND_DETSTATSCLEAR:
{
detstats_clear();
return 1;
}
case COMMAND_DETSTATS:
{
detstats_print(desc, conn->term);
return 1;
}
case COMMAND_INSTREAM:
{
int rc = cli_gentempfd(optget(conn->opts, "TemporaryDirectory")->strarg, &conn->filename, &conn->scanfd);
if (rc != CL_SUCCESS)
return rc;
conn->quota = optget(conn->opts, "StreamMaxLength")->numarg;
conn->mode = MODE_STREAM;
return 0;
}
case COMMAND_STREAM:
case COMMAND_MULTISCAN:
case COMMAND_CONTSCAN:
case COMMAND_STATS:
case COMMAND_FILDES:
case COMMAND_SCAN:
case COMMAND_INSTREAMSCAN:
return dispatch_command(conn, cmd, argument);
case COMMAND_IDSESSION:
conn->group = thrmgr_group_new();
if (!conn->group)
return CL_EMEM;
return 0;
case COMMAND_END:
if (!conn->group) {
/* end without idsession? */
conn_reply_single(conn, NULL, "UNKNOWN COMMAND");
return 1;
}
/* need to close connection if we were last in group */
return 1;
/*case COMMAND_UNKNOWN:*/
default:
conn_reply_single(conn, NULL, "UNKNOWN COMMAND");
return 1;
}
}
/**
* Main function
* @return int
*/
int main(int argc, char **argv)
{
size_t size;
char *input;
comm_plugin = communication_plugin();
if (argc == 2) {
if (strcmp(argv[1], "--help") == 0) {
print_help();
exit(0);
} else if (strcmp(argv[1], "--dbus") == 0) {
dbus_mode();
} else if (strcmp(argv[1], "--tcp") == 0) {
tcp_mode();
} else {
fprintf(stderr, "ERROR: %s invalid option\n", argv[1]);
fprintf(stderr,
"Try `ieee_manager_console --help' for more information.\n");
exit(1);
}
} else if (argc > 2) {
fprintf(stderr, "ERROR: Invalid number of options\n");
fprintf(stderr, "Try `ieee_manager_console --help' for more information.\n");
exit(1);
} else {
// TCP is default mode
tcp_mode();
}
fprintf(stderr, "\nIEEE 11073 Test application\n");
size = 100;
input = (char *)malloc(size);
plugin_pthread_setup(&comm_plugin);
CommunicationPlugin *plugins[] = {&comm_plugin, 0};
manager_init(plugins);
ManagerListener listener = MANAGER_LISTENER_EMPTY;
listener.measurement_data_updated = &new_data_received;
listener.device_available = &device_associated;
manager_add_listener(listener);
plugin_pthread_manager_start();
while (1) {
fprintf(stderr, "--> ");
unsigned int read_bytes = getline(&input, &size, stdin);
input[read_bytes-1] = '\0';
if (strcmp(input, "exit") == 0) {
break;
} else if (strcmp(input, "start") == 0) {
plugin_pthread_manager_start();
} else if (strcmp(input, "stop") == 0) {
plugin_pthread_manager_stop();
} else if (strcmp(input, "print_mds") == 0) {
print_device_attributes();
}
/*
* Remote Operation Invokes
*/
else if (strcmp(input, "req_data") == 0) {
manager_request_measurement_data_transmission(DEFAULT_CONTEXT_ID, NULL);
} else if (strcmp(input, "get_all_mds") == 0) {
manager_request_get_all_mds_attributes(DEFAULT_CONTEXT_ID, NULL);
} else if (strcmp(input, "get_segment_info") == 0) {
manager_request_get_segment_info(DEFAULT_CONTEXT_ID, -1, NULL);
} else if (strcmp(input, "data_xfer") == 0) {
manager_request_get_segment_data(DEFAULT_CONTEXT_ID, -1, -1, NULL);
} else if (strcmp(input, "clear_segments") == 0) {
manager_request_clear_segments(DEFAULT_CONTEXT_ID, -1, NULL);
} else if (strcmp(input, "release") == 0) {
manager_request_association_release(DEFAULT_CONTEXT_ID);
} else if (strcmp(input, "start_scan") == 0) {
manager_set_operational_state_of_the_scanner(DEFAULT_CONTEXT_ID, 0X0037,
os_enabled, NULL); // TODO Change Handle
} else if (strcmp(input, "stop_scan") == 0) {
manager_set_operational_state_of_the_scanner(DEFAULT_CONTEXT_ID, 0X0037,
os_disabled, NULL); // TODO Change Handle
} else if (strcmp(input, "help") == 0) {
print_commands();
} else {
fprintf(stderr, "Command not recognized\n");
}
}
plugin_pthread_manager_stop();
manager_finalize();
free(input);
return 0;
}
