int
main (void)
{
char **argv;
const char *const *test;
char **targs;
for (test = tests; *test != NULL; test++)
{
printf ("buildargv(\"%s\")\n", *test);
if ((argv = buildargv (*test)) == NULL)
{
printf ("failed!\n\n");
}
else
{
for (targs = argv; *targs != NULL; targs++)
{
printf ("\t\"%s\"\n", *targs);
}
printf ("\n");
}
freeargv (argv);
}
return 0;
}
static SCM
gdbscm_string_to_argv (SCM string_scm)
{
char *string;
char **c_argv;
int i;
SCM result = SCM_EOL;
gdbscm_parse_function_args (FUNC_NAME, SCM_ARG1, NULL, "s",
string_scm, &string);
if (string == NULL || *string == '\0')
{
xfree (string);
return SCM_EOL;
}
c_argv = gdb_buildargv (string);
for (i = 0; c_argv[i] != NULL; ++i)
result = scm_cons (gdbscm_scm_from_c_string (c_argv[i]), result);
freeargv (c_argv);
xfree (string);
return scm_reverse_x (result, SCM_EOL);
}
void
lscmd_del(lscmd_t *self) {
if (self) {
config_del(self->config);
freeargv(self->argc, self->argv);
free(self);
}
}
void test_argv_shell(const char *str) {
int i;
int argc;
char **argv;
makeargv_shell(str, &argc, &argv);
for(i=0;i<argc;i++) {
printf("argv[%d]=\"%s\"\n", i, argv[i]);
}
freeargv(argc, argv);
}
void
sim_do_command (SIM_DESC sd, char *cmd)
{
TRACE(trace_gdb, ("sim_do_commands(cmd=%s) called\n",
cmd ? cmd : "(null)"));
if (cmd != NULL) {
char **argv = buildargv(cmd);
psim_command(root_device, argv);
freeargv(argv);
}
}
static void make_argv(const wxString& cmd)
{
if(argc) {
freeargv(argv);
argc = 0;
}
argv = buildargv(cmd.mb_str(wxConvUTF8).data());
argc = 0;
for(char** targs = argv; *targs != NULL; targs++) {
argc++;
}
}
void
mi_parse_free (struct mi_parse *parse)
{
if (parse == NULL)
return;
if (parse->command != NULL)
xfree (parse->command);
if (parse->token != NULL)
xfree (parse->token);
if (parse->args != NULL)
xfree (parse->args);
if (parse->argv != NULL)
freeargv (parse->argv);
xfree (parse);
}
void process_command(char* string) {
prepare_shell();
if (((string != NULL) && (string[0] == '\0')) || !strlen(string))
return;
int argc;
char *sdup = strdup(string);
char **argv = buildargv(sdup, &argc);
kfree(sdup);
if (argc == 0) {
freeargv(argv);
return;
}
char* command = argv[0];
int i = findCommand(command);
if (i >= 0) {
void (*command_function)(int, char **) = (void(*)(int, char**))CommandTable[i].function;
command_function(argc, argv);
}
else {
//not a valid command
//are we trying to execute a binary?
FILE* stream = fopen(command, "r");
if (stream) {
int pid = sys_fork();
if (!pid) {
execve(command, 0, 0);
sys__exit(1);
}
else {
int status;
waitpid(pid, &status, 0);
}
}
else {
//invalid input
printf("Command '\e[9;%s\e[15;' not found.", command);
}
fclose(stream);
}
int check_pkg_install_mask(char *name)
{
int i, iargc, ret;
char **iargv;
i = iargc = ret = 0;
if (*name != '/')
return ret;
makeargv(pkg_install_mask, &iargc, &iargv);
for (i = 1; i < iargc; i++) {
if (fnmatch(iargv[i], name, 0) != 0)
continue;
ret = 1;
break;
}
freeargv(iargc, iargv);
return ret;
}
SIM_RC
sim_create_inferior (SIM_DESC sd, struct bfd *abfd,
char **argv, char **env)
{
SIM_CPU *cpu = STATE_CPU (sd, 0);
SIM_ADDR addr;
/* Set the PC. */
if (abfd != NULL)
addr = bfd_get_start_address (abfd);
else
addr = 0;
sim_pc_set (cpu, addr);
/* Standalone mode (i.e. `bfin-...-run`) will take care of the argv
for us in sim_open() -> sim_parse_args(). But in debug mode (i.e.
'target sim' with `bfin-...-gdb`), we need to handle it. */
if (STATE_OPEN_KIND (sd) == SIM_OPEN_DEBUG)
{
freeargv (STATE_PROG_ARGV (sd));
STATE_PROG_ARGV (sd) = dupargv (argv);
}
switch (STATE_ENVIRONMENT (sd))
{
case USER_ENVIRONMENT:
bfin_user_init (sd, cpu, abfd, (void *)argv, (void *)env);
break;
case OPERATING_ENVIRONMENT:
bfin_os_init (sd, cpu, (void *)argv);
break;
default:
bfin_virtual_init (sd, cpu);
break;
}
return SIM_RC_OK;
}
/* make sure you quote the single command-line arugment to this program, e.g.,
$ ./a.out "Parse this string into an argument vector."
*/
int argvmain(int argc, char** argv) {
int i, numtokens;
char** myargv;
// if (argc != 2) {
// fprintf(stderr, "Usage: %s string\n", argv[0]);
// return 1;
// }
if ((numtokens = makeargv(argv[1], DELIMITERS, &myargv)) == -1) {
fprintf(stderr, "Failed to construct an argument array for %s.\n", argv[1]);
return 1;
}
printf ("The constructed argument array contains:\n");
for (i=0; i < numtokens; i++)
printf("%d:%s:\n", i, myargv[i]);
execvp(myargv[0], &myargv[0]);
freeargv(myargv);
return 0;
}
int main (int argc, char *argv[])
{
int i, status;
for (i=1; i<argc; i++) { /* traiter argv[i] */
char **cmdargv;
char **arg;
/* création du argv de l'argument i */
status = makeargv(argv[i], " \t", &cmdargv);
assert(status>0);
/* test: affichage */
fprintf(stderr, "[%s]\t%% ", cmdargv[0]);
for (arg=cmdargv; *arg; arg++)
fprintf(stderr, "%s ", *arg);
fprintf(stderr, "\n");
/* libération mémoire */
freeargv(cmdargv);
}
exit(EXIT_SUCCESS);
}
static void
mi_parse_argv (char *args, struct mi_parse *parse)
{
char *chp = args;
int argc = 0;
char **argv = xmalloc ((argc + 1) * sizeof (char *));
argv[argc] = NULL;
while (1)
{
char *arg;
/* skip leading white space */
while (isspace (*chp))
chp++;
/* Three possibilities: EOF, quoted string, or other text. */
switch (*chp)
{
case '\0':
parse->argv = argv;
parse->argc = argc;
return;
case '"':
{
/* A quoted string. */
int len;
char *start = chp + 1;
/* Determine the buffer size. */
chp = start;
len = 0;
while (*chp != '\0' && *chp != '"')
{
if (*chp == '\\')
{
chp++;
if (parse_escape (&chp) <= 0)
{
/* Do not allow split lines or "\000" */
freeargv (argv);
return;
}
}
else
chp++;
len++;
}
/* Insist on a closing quote. */
if (*chp != '"')
{
freeargv (argv);
return;
}
/* Insist on trailing white space. */
if (chp[1] != '\0' && !isspace (chp[1]))
{
freeargv (argv);
return;
}
/* create the buffer. */
arg = xmalloc ((len + 1) * sizeof (char));
/* And copy the characters in. */
chp = start;
len = 0;
while (*chp != '\0' && *chp != '"')
{
if (*chp == '\\')
{
chp++;
arg[len] = parse_escape (&chp);
}
else
arg[len] = *chp++;
len++;
}
arg[len] = '\0';
chp++; /* that closing quote. */
break;
}
default:
{
/* An unquoted string. Accumulate all non blank
characters into a buffer. */
int len;
char *start = chp;
while (*chp != '\0' && !isspace (*chp))
{
chp++;
}
len = chp - start;
arg = xmalloc ((len + 1) * sizeof (char));
strncpy (arg, start, len);
arg[len] = '\0';
break;
}
}
/* Append arg to argv. */
argv = xrealloc (argv, (argc + 2) * sizeof (char *));
argv[argc++] = arg;
argv[argc] = NULL;
}
}
int
run_tests (const char **test_data)
{
int argc_after, argc_before;
char ** argv_before, ** argv_after;
int i, j, k, fails, failed;
i = j = fails = 0;
/* Loop over all the tests */
while (test_data[j])
{
/* Write test data */
writeout_test (i, test_data[j++]);
/* Copy argv before */
argv_before = dupargv ((char **) &test_data[j]);
/* Count argc before/after */
argc_before = 0;
argc_after = 0;
while (test_data[j + argc_before])
argc_before++;
j += argc_before + 1; /* Skip null */
while (test_data[j + argc_after])
argc_after++;
/* Copy argv after */
argv_after = dupargv ((char **) &test_data[j]);
/* Run all possible replaces */
for (k = 0; k < argc_before; k++)
run_replaces (argv_before[k]);
for (k = 0; k < argc_after; k++)
run_replaces (argv_after[k]);
/* Run test: Expand arguments */
expandargv (&argc_before, &argv_before);
failed = 0;
/* Compare size first */
if (argc_before != argc_after)
{
printf ("FAIL: test-expandargv-%d. Number of arguments don't match.\n", i);
failed++;
}
/* Compare each of the argv's ... */
else
for (k = 0; k < argc_after; k++)
if (strcmp (argv_before[k], argv_after[k]) != 0)
{
printf ("FAIL: test-expandargv-%d. Arguments don't match.\n", i);
failed++;
}
if (!failed)
printf ("PASS: test-expandargv-%d.\n", i);
else
fails++;
freeargv (argv_before);
freeargv (argv_after);
/* Advance to next test */
j += argc_after + 1;
/* Erase test file */
erase_test (i);
i++;
}
return fails;
}
CompilerCommandLineParser::~CompilerCommandLineParser()
{
freeargv(m_argv);
m_argv = NULL;
m_argc = 0;
}
IProcess* UnixProcessImpl::Execute(
wxEvtHandler* parent, const wxString& cmd, size_t flags, const wxString& workingDirectory, IProcessCallback* cb)
{
wxUnusedVar(flags);
make_argv(cmd);
if(argc == 0) {
return NULL;
}
// fork the child process
wxString curdir = wxGetCwd();
// Prentend that we are a terminal...
int master, slave;
openpty(&master, &slave, NULL, NULL, NULL);
int rc = fork();
if(rc == 0) {
login_tty(slave);
close(master); // close the un-needed master end
// at this point, slave is used as stdin/stdout/stderr
// Child process
if(workingDirectory.IsEmpty() == false) {
wxSetWorkingDirectory(workingDirectory);
}
// execute the process
execvp(argv[0], argv);
// if we got here, we failed...
exit(0);
} else if(rc < 0) {
// Error
// restore the working directory
wxSetWorkingDirectory(curdir);
return NULL;
} else {
// Parent
close(slave);
freeargv(argv);
argc = 0;
// disable ECHO
struct termios termio;
tcgetattr(master, &termio);
termio.c_lflag = ICANON;
termio.c_oflag = ONOCR | ONLRET;
tcsetattr(master, TCSANOW, &termio);
// restore the working directory
wxSetWorkingDirectory(curdir);
UnixProcessImpl* proc = new UnixProcessImpl(parent);
proc->m_callback = cb;
proc->SetReadHandle(master);
proc->SetWriteHandler(master);
proc->SetPid(rc);
proc->m_flags = flags; // Keep the creation flags
if(!(proc->m_flags & IProcessCreateSync)) {
proc->StartReaderThread();
}
return proc;
}
}