static int _msh_exec_cmd(char *cmd, rt_size_t length, int *retp) { int argc; int cmd0_size = 0; cmd_function_t cmd_func; char *argv[RT_FINSH_ARG_MAX]; RT_ASSERT(cmd); RT_ASSERT(retp); /* find the size of first command */ while ((cmd[cmd0_size] != ' ' && cmd[cmd0_size] != '\t') && cmd0_size < length) cmd0_size ++; if (cmd0_size == 0) return -RT_ERROR; cmd_func = msh_get_cmd(cmd, cmd0_size); if (cmd_func == RT_NULL) return -RT_ERROR; /* split arguments */ memset(argv, 0x00, sizeof(argv)); argc = msh_split(cmd, length, argv); if (argc == 0) return -RT_ERROR; /* exec this command */ *retp = cmd_func(argc, argv); return 0; }
static int cmd_proc(void) { sys_sh_proc_t cmd_func; cmd_func = cmd_find(cmd_arg[0]); return cmd_func(cmd_arg_num, cmd_arg); }
void cmd_show_list (struct cmd_list_element *list, int from_tty, const char *prefix) { struct cleanup *showlist_chain; struct ui_out *uiout = current_uiout; showlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "showlist"); for (; list != NULL; list = list->next) { /* If we find a prefix, run its list, prefixing our output by its prefix (with "show " skipped). */ if (list->prefixlist && !list->abbrev_flag) { struct cleanup *optionlist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "optionlist"); char *new_prefix = strstr (list->prefixname, "show ") + 5; if (ui_out_is_mi_like_p (uiout)) ui_out_field_string (uiout, "prefix", new_prefix); cmd_show_list (*list->prefixlist, from_tty, new_prefix); /* Close the tuple. */ do_cleanups (optionlist_chain); } else { if (list->theclass != no_set_class) { struct cleanup *option_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "option"); ui_out_text (uiout, prefix); ui_out_field_string (uiout, "name", list->name); ui_out_text (uiout, ": "); if (list->type == show_cmd) do_show_command ((char *) NULL, from_tty, list); else cmd_func (list, NULL, from_tty); /* Close the tuple. */ do_cleanups (option_chain); } } } /* Close the tuple. */ do_cleanups (showlist_chain); }
int msh_exec(char* cmd, rt_size_t length) { int argc; char *argv[RT_FINSH_ARG_MAX]; int cmd0_size = 0; cmd_function_t cmd_func; /* strim the beginning of command */ while(*cmd == ' ' || *cmd == '\t'){cmd++; length--;} /* find the size of first command */ while ((cmd[cmd0_size] != ' ' && cmd[cmd0_size] != '\t') && cmd0_size < length) cmd0_size ++; if (cmd0_size == 0) return -1; /* no command found */ /* try to get built-in command */ cmd_func = msh_get_cmd(cmd, cmd0_size); if (cmd_func == RT_NULL) { #ifdef RT_USING_MODULE msh_exec_module(cmd, length); #else argv[0] = cmd; while(*cmd != ' ') { if (*cmd == 0) break; cmd++; } if (*cmd == ' ') *cmd = 0; rt_kprintf("%s: command not found.\n", argv[0]); #endif return -1; } /* split arguments */ memset(argv, 0x00, sizeof(argv)); argc = msh_split(cmd, length, argv); if (argc == 0) return -1; /* exec this command */ return cmd_func(argc, argv); }
int main(int argc, char **argv) { const char *cmd_name; int (*cmd_func)(int, char **) = NULL; if (argc < 2) { fprintf(stderr, "usage: arsc <command> [options]\n"); exit(1); } cmd_name = argv[1]; if (!strcmp(cmd_name, "dump")) cmd_func = cmd_dump; #ifndef NDEBUG else if (!strcmp(cmd_name, "test")) cmd_func = cmd_test; #endif if (!cmd_func) die("no command"); return cmd_func(argc - 2, argv + 2); }
static enum cmd_error_code track_untrack_pid(enum cmd_type cmd_type, const char *cmd_str, const char *session_name, const char *pid_string, int all, struct mi_writer *writer) { int ret, success = 1 , i; enum cmd_error_code retval = CMD_SUCCESS; int *pid_list = NULL; int nr_pids; struct lttng_domain dom; struct lttng_handle *handle = NULL; int (*cmd_func)(struct lttng_handle *handle, int pid); switch (cmd_type) { case CMD_TRACK: cmd_func = lttng_track_pid; break; case CMD_UNTRACK: cmd_func = lttng_untrack_pid; break; default: ERR("Unknown command"); retval = CMD_ERROR; goto end; } memset(&dom, 0, sizeof(dom)); if (opt_kernel) { dom.type = LTTNG_DOMAIN_KERNEL; } else if (opt_userspace) { dom.type = LTTNG_DOMAIN_UST; } else { /* Checked by the caller. */ assert(0); } ret = parse_pid_string(pid_string, all, &pid_list, &nr_pids); if (ret != CMD_SUCCESS) { ERR("Error parsing PID string"); retval = CMD_ERROR; goto end; } handle = lttng_create_handle(session_name, &dom); if (handle == NULL) { retval = CMD_ERROR; goto end; } if (writer) { /* Open process element */ ret = mi_lttng_targets_open(writer); if (ret) { retval = CMD_ERROR; goto end; } } for (i = 0; i < nr_pids; i++) { DBG("%s PID %d", cmd_str, pid_list[i]); ret = cmd_func(handle, pid_list[i]); if (ret) { switch (-ret) { case LTTNG_ERR_PID_TRACKED: WARN("PID %i already tracked in session %s", pid_list[i], session_name); success = 1; retval = CMD_SUCCESS; break; case LTTNG_ERR_PID_NOT_TRACKED: WARN("PID %i not tracked in session %s", pid_list[i], session_name); success = 1; retval = CMD_SUCCESS; break; default: ERR("%s", lttng_strerror(ret)); success = 0; retval = CMD_ERROR; break; } } else { MSG("PID %i %sed in session %s", pid_list[i], cmd_str, session_name); success = 1; } /* Mi */ if (writer) { ret = mi_lttng_pid_target(writer, pid_list[i], 1); if (ret) { retval = CMD_ERROR; goto end; } ret = mi_lttng_writer_write_element_bool(writer, mi_lttng_element_success, success); if (ret) { retval = CMD_ERROR; goto end; } ret = mi_lttng_writer_close_element(writer); if (ret) { retval = CMD_ERROR; goto end; } } } if (writer) { /* Close targets element */ ret = mi_lttng_writer_close_element(writer); if (ret) { retval = CMD_ERROR; goto end; } } end: if (handle) { lttng_destroy_handle(handle); } free(pid_list); return retval; }
/* * Command text input prompt callback. * * For executing a command via the text input prompt. This will * parse the command value and call the appropriate SARCmd*() * function. */ void SARCmdTextInputCB(const char *value, void *data) { char *s; const char *arg; Boolean matched_command = False; unsigned long flags = SAR_CMD_FLAG_VERBOSE | SAR_CMD_FLAG_ISUSER; char cmd[SAR_CMD_MAX]; const cmd_ref_struct *cmd_list_ptr, cmd_list[] = SAR_CMD_FUNC_REF_LIST; void (*cmd_func)(SAR_CMD_PROTOTYPE); sar_core_struct *core_ptr = SAR_CORE(data); if((value == NULL) || (core_ptr == NULL)) return; /* Parse command and value */ /* Get command */ strncpy(cmd, value, sizeof(cmd)); cmd[sizeof(cmd) - 1] = '\0'; s = strchr(cmd, ' '); if(s == NULL) s = strchr(cmd, '\t'); if(s != NULL) *s = '\0'; /* Get argument */ arg = strchr(value, ' '); if(arg == NULL) { arg = ""; } else { while(ISBLANK(*arg)) arg++; } /* Iterate through list of SARCmd*() functions to see which * command matches the command tagent from the value string */ for(cmd_list_ptr = cmd_list; cmd_list_ptr->name != NULL; cmd_list_ptr++ ) { const char *cmd_name = cmd_list_ptr->name; cmd_func = cmd_list_ptr->func; if(STRISEMPTY(cmd_name) || (cmd_func == NULL)) break; /* Commands match? */ if(!strcasecmp(cmd_name, cmd)) { /* Call the function */ cmd_func(core_ptr, arg, flags); matched_command = True; break; } } /* Did not match command? */ if(!matched_command) { if(SAR_CMD_IS_VERBOSE(flags)) { char *s = (char *)malloc( (80 + STRLEN(cmd)) * sizeof(char) ); sprintf( s, "%s: No such command.", cmd ); SARMessageAdd(core_ptr->scene, s); free(s); } } }
void gera(FILE *f, void **code, funcp *entry){ int c, i,j; int line = 1, idx = 0, funcIdx = -1; unsigned char * func[MAX_FUNCS]; int declaredVars[MAX_FUNCS][MAX_VARS]; unsigned char *codigo = (unsigned char *) malloc (TAM_COD); *code = codigo; for(i=0;i<MAX_FUNCS;i++) for(j=0;j<MAX_VARS;j++) declaredVars[i][j]=0; while ((c = fgetc(f)) != EOF) { switch (c){ case 'f': { /* function */ char c0; if (fscanf(f, "unction%c", &c0) != 1) error("comando invalido", line); printf("function\n"); cmd_func(func,&funcIdx,codigo,&idx); break; } case 'e': { /* end */ fscanf(f, "nd"); printf("end\n"); cmd_end(codigo,&idx); break; } case 'v': case 'p': { /* atribuicao */ int i0; char v0 = c, c0; if (fscanf(f, "%d = %c", &i0, &c0) != 2) error("comando invalido", line); if (c0 == 'c') { /* call */ int fc, i1; char v1; if (fscanf(f, "all %d %c%d", &fc, &v1, &i1) != 3) error("comando invalido", line); printf("%c%d = call %d %c%d\n", v0, i0, fc, v1, i1); cmd_call(fc,v1,i1,func,codigo,&idx); } else { /* operacao aritmetica */ int i1, i2; char v1 = c0, v2, op; if (fscanf(f, "%d %c %c%d", &i1, &op, &v2, &i2) != 4) error("comando invalido", line); printf("%c%d = %c%d %c %c%d\n", v0, i0, v1, i1, op, v2, i2); cmd_op(v1,i1,op,v2,i2,codigo,&idx,declaredVars,line,funcIdx); } cmd_atr(v0,i0,codigo,&idx,declaredVars,funcIdx); break; } case 'r': { /* ret */ int i0, i1; char v0, v1; if (fscanf(f, "et? %c%d %c%d", &v0, &i0, &v1, &i1) != 4) error("comando invalido", line); printf("ret? %c%d %c%d\n", v0, i0, v1, i1); cmd_ret(v0,i0,v1,i1,codigo,&idx,line); break; } default: error("comando desconhecido", line); } line++; fscanf(f, " "); } (*entry) = (funcp) func[funcIdx]; }