static void
gdbsim_load (char *args, int fromtty)
{
char **argv = buildargv (args);
char *prog;
if (argv == NULL)
nomem (0);
make_cleanup_freeargv (argv);
prog = tilde_expand (argv[0]);
if (argv[1] != NULL)
error (_("GDB sim does not yet support a load offset."));
if (sr_get_debug ())
printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
/* FIXME: We will print two messages on error.
Need error to either not print anything if passed NULL or need
another routine that doesn't take any arguments. */
if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
error (_("unable to load program"));
/* FIXME: If a load command should reset the targets registers then
a call to sim_create_inferior() should go here. */
program_loaded = 1;
}
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 void
exec_file_command (char *args, int from_tty)
{
char **argv;
char *filename;
if (from_tty && target_has_execution
&& !query (_("A program is being debugged already.\n"
"Are you sure you want to change the file? ")))
error (_("File not changed."));
if (args)
{
/* Scan through the args and pick up the first non option arg
as the filename. */
argv = buildargv (args);
if (argv == NULL)
nomem (0);
make_cleanup_freeargv (argv);
for (; (*argv != NULL) && (**argv == '-'); argv++)
{;
}
if (*argv == NULL)
error (_("No executable file name was specified"));
filename = tilde_expand (*argv);
make_cleanup (xfree, filename);
exec_file_attach (filename, from_tty);
}
else
exec_file_attach (NULL, from_tty);
}
static void
exec_file_command (char *args, int from_tty)
{
char **argv;
char *filename;
target_preopen (from_tty);
if (args)
{
/* Scan through the args and pick up the first non option arg
as the filename. */
argv = buildargv (args);
if (argv == NULL)
nomem (0);
make_cleanup_freeargv (argv);
for (; (*argv != NULL) && (**argv == '-'); argv++)
{;
}
if (*argv == NULL)
error (_("No executable file name was specified"));
filename = tilde_expand (*argv);
make_cleanup (xfree, filename);
exec_file_attach (filename, from_tty);
}
else
exec_file_attach (NULL, from_tty);
}
static void
metrowerks_step_command (char *args, int from_tty)
{
int async_exec = 0;
CORE_ADDR range_start = 0;
CORE_ADDR range_stop = 0;
int step_into = 0;
int num_args = 0;
char **argv = NULL;
if (args != NULL)
async_exec = strip_bg_char (&args);
if (event_loop_p && async_exec && !target_can_async_p ())
error ("Asynchronous execution not supported on this target.");
/* If we do NOT get a request of running in the bg, then we need
* to simulate synchronous (fg) execution. */
if (event_loop_p && !async_exec && target_can_async_p ())
{
async_disable_stdin ();
}
argv = buildargv (args);
if (argv == NULL)
{
num_args = 0;
}
else
{
num_args = 0;
while (argv[num_args] != NULL)
num_args++;
}
if (num_args != 3 && num_args != 5)
error ("Usage: metrowerks-step <start> <stop> <step-into> ?<func_start> <func_end>?");
range_start = strtoul (argv[0], NULL, 16);
range_stop = strtoul (argv[1], NULL, 16);
step_into = strtoul (argv[2], NULL, 16);
if (num_args == 5)
{
metrowerks_step_func_start = strtoul (argv[3], NULL, 16);
metrowerks_step_func_end = strtoul (argv[4], NULL, 16);
}
else
{
metrowerks_step_func_start = 0;
metrowerks_step_func_end = 0;
}
if (!target_has_execution)
error ("The program is not being run.");
metrowerks_step (range_start, range_stop, step_into);
}
void
colon(char *addr, char *cp)
{
int argc;
char *argv[100];
char tbuf[512];
cp = nextc(cp);
switch(*cp) {
default:
Bprint(bioout, "?\n");
return;
case 'b':
breakpoint(addr, cp+1);
return;
case 'd':
delbpt(addr);
return;
/* These fall through to print the stopped address */
case 'r':
reset();
argc = buildargv(cp+1, argv, 100);
initstk(argc, argv);
count = 0;
atbpt = 0;
run();
break;
case 'c':
count = 0;
atbpt = 0;
run();
break;
case 's':
cp = nextc(cp+1);
count = 0;
if(*cp)
count = strtoul(cp, 0, 0);
if(count == 0)
count = 1;
atbpt = 0;
run();
break;
}
dot = reg.pc;
Bprint(bioout, "%s at #%lux ", atbpt ? "breakpoint" : "stopped", dot);
symoff(tbuf, sizeof(tbuf), dot, CTEXT);
Bprint(bioout, tbuf);
if(fmt == 'z')
printsource(dot);
Bprint(bioout, "\n");
}
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);
}
}
void build_effective_args(int argc, char *argv[], effective_args_t *effective_args)
{
int i;
char *linebuffer = (char *) malloc(MAX_CMDLINE_BUFFER_LENGTH);
if (!linebuffer)
{
traceError("Unable to allocate memory");
exit(1);
}
snprintf(linebuffer, MAX_CMDLINE_BUFFER_LENGTH, "%s", argv[0]);
#ifdef WIN32
for (i = 0; i < (int) strlen(linebuffer); i++)
if (linebuffer[i] == '\\')
linebuffer[i] = '/';
#endif
for (i = 1; i < argc; ++i)
{
if (argv[i][0] == '@')
{
if (readConfFile(&argv[i][1], linebuffer) < 0)
exit(1); /* <<<<----- check */
}
else if ((strlen(linebuffer) + strlen(argv[i]) + 2) < MAX_CMDLINE_BUFFER_LENGTH)
{
strncat(linebuffer, " ", 1);
strncat(linebuffer, argv[i], strlen(argv[i]));
}
else
{
traceError("too many argument");
exit(1);
}
}
/* strip trailing spaces */
while (strlen(linebuffer) && linebuffer[ strlen(linebuffer) - 1 ] == ' ')
linebuffer[ strlen(linebuffer) - 1 ] = '\0';
/* build the new argv from the linebuffer */
buildargv(linebuffer, effective_args);
if (linebuffer)
{
free(linebuffer);
linebuffer = NULL;
}
/* {int k;for(k=0;k<effectiveargc;++k) printf("%s\n",effectiveargv[k]);} */
}
External_Process*
spawn_external (char* cmd)
{
External_Process* ep;
int rc;
ep = alloc_ep ();
if (!ep) return 0;
/* Create the pipes */
rc = pipe (ep->mypipe);
if (rc) {
fprintf (stderr, "Can't open pipes\n");
free (ep);
return 0;
}
/* Create the child process. */
ep->pid = fork ();
if (ep->pid == (pid_t) 0) {
/* This is the child process. */
int i = 0;
char** argv;
close (ep->mypipe[0]);
dup2 (ep->mypipe[1],1);
close (ep->mypipe[1]);
argv = buildargv (cmd);
while (argv[i]) {
debug_printf ("argv[%d] = %s\n", i, argv[i]);
i++;
}
execvp (argv[0],&argv[0]);
/* Doesn't return */
fprintf (stderr, "Error, returned from execlp\n");
exit (-1);
} else if (ep->pid < (pid_t) 0) {
/* The fork failed. */
close (ep->mypipe[0]);
close (ep->mypipe[1]);
fprintf (stderr, "Fork failed.\n");
free (ep);
return 0;
} else {
/* This is the parent process. */
close (ep->mypipe[1]);
rc = fcntl (ep->mypipe[0], F_SETFL, O_NONBLOCK);
return ep;
}
}
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++;
}
}
int main()
{
char **args;
char input[256];
int i;
strcpy(input, " a b");
args = buildargv(input);
if (strcmp (args[0], "a"))
abort ();
if (strcmp (args[1], "b"))
abort ();
if (args[2] != NULL)
abort ();
exit (0);
}
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);
}
static void
gdbsim_create_inferior (char *exec_file, char *args, char **env, int from_tty)
{
int len;
char *arg_buf, **argv;
if (exec_file == 0 || exec_bfd == 0)
warning ("No executable file specified.");
if (!program_loaded)
warning ("No program loaded.");
if (sr_get_debug ())
printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
(exec_file ? exec_file : "(NULL)"),
args);
gdbsim_kill ();
remove_breakpoints ();
init_wait_for_inferior ();
if (exec_file != NULL)
{
len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
arg_buf = (char *) alloca (len);
arg_buf[0] = '\0';
strcat (arg_buf, exec_file);
strcat (arg_buf, " ");
strcat (arg_buf, args);
argv = buildargv (arg_buf);
make_cleanup_freeargv (argv);
}
else
argv = NULL;
sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
inferior_ptid = pid_to_ptid (42);
insert_breakpoints (); /* Needed to get correct instruction in cache */
clear_proceed_status ();
/* NB: Entry point already set by sim_create_inferior. */
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
}
void
execproc(void *v)
{
struct Exec *e;
int p[2], q[2];
char *prog;
char *argv[NARGS+1], args[NARGCHAR];
e = v;
p[0] = e->p[0];
p[1] = e->p[1];
q[0] = e->q[0];
q[1] = e->q[1];
prog = e->prog; /* known not to be malloc'ed */
rfork(RFFDG);
sendul(e->sync, 1);
buildargv(e->argv, argv, args);
free(e->argv);
chanfree(e->sync);
free(e);
dup(p[0], 0);
close(p[0]);
close(p[1]);
if(q[0]){
dup(q[1], 1);
close(q[0]);
close(q[1]);
}
procexec(nil, prog, argv);
//fprint(2, "exec: %s", e->prog);
//{int i;
//for(i=0; argv[i]; i++) print(" '%s'", argv[i]);
//print("\n");
//}
//argv[0] = "cat";
//argv[1] = nil;
//procexec(nil, "/bin/cat", argv);
fprint(2, "Mail: can't exec %s: %r\n", prog);
threadexits("can't exec");
}
void
testTortureExecute (void)
{
char **args;
#if !defined(__SDCC_mcs51)
char input[256];
#else
char input[8];
#endif
int i;
strcpy(input, " a b");
args = buildargv(input);
if (strcmp (args[0], "a"))
ASSERT (0);
if (strcmp (args[1], "b"))
ASSERT (0);
if (args[2] != NULL)
ASSERT (0);
return;
}
void
/* APPLE LOCAL arguments to corefile */
core_file_command (char *args, int from_tty)
{
/* APPLE LOCAL begin refactor corefile */
struct cleanup *cleanups;
char *filename;
char **argv;
dont_repeat ();
if (args == NULL)
{
cleanups = NULL;
filename = NULL;
}
else
{
argv = buildargv (args);
if (argv == NULL)
nomem (0);
cleanups = make_cleanup_freeargv (argv);
if (argv[0] == NULL)
internal_error (__FILE__, __LINE__, "buildargv returned empty vector");
else if (argv[1] != NULL)
error ("more than one core filename was specified");
else
filename = argv[0];
}
core_file_attach (filename, from_tty);
if (cleanups != NULL)
do_cleanups (cleanups);
}
void
execproc(void *v)
{
struct Exec *e;
int p[2], q[2];
char *prog;
char *argv[NARGS+1], args[NARGCHAR];
int fd[3];
e = v;
p[0] = e->p[0];
p[1] = e->p[1];
q[0] = e->q[0];
q[1] = e->q[1];
prog = e->prog; /* known not to be malloc'ed */
fd[0] = dup(p[0], -1);
if(q[0])
fd[1] = dup(q[1], -1);
else
fd[1] = dup(1, -1);
fd[2] = dup(2, -2);
sendul(e->sync, 1);
buildargv(e->argv, argv, args);
free(e->argv);
chanfree(e->sync);
free(e);
threadexec(nil, fd, prog, argv);
close(fd[0]);
close(fd[1]);
close(fd[2]);
fprint(2, "Mail: can't exec %s: %r\n", prog);
threadexits("can't exec");
}
static void
gdbsim_open (char *args, int from_tty)
{
int len;
char *arg_buf;
char **argv;
if (sr_get_debug ())
printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
/* Remove current simulator if one exists. Only do this if the simulator
has been opened because sim_close requires it.
This is important because the call to push_target below will cause
sim_close to be called if the simulator is already open, but push_target
is called after sim_open! We can't move the call to push_target before
the call to sim_open because sim_open may invoke `error'. */
if (gdbsim_desc != NULL)
unpush_target (&gdbsim_ops);
len = (7 + 1 /* gdbsim */
+ strlen (" -E little")
+ strlen (" --architecture=xxxxxxxxxx")
+ (args ? strlen (args) : 0)
+ 50) /* slack */ ;
arg_buf = (char *) alloca (len);
strcpy (arg_buf, "gdbsim"); /* 7 */
/* Specify the byte order for the target when it is both selectable
and explicitly specified by the user (not auto detected). */
switch (selected_byte_order ())
{
case BFD_ENDIAN_BIG:
strcat (arg_buf, " -E big");
break;
case BFD_ENDIAN_LITTLE:
strcat (arg_buf, " -E little");
break;
case BFD_ENDIAN_UNKNOWN:
break;
}
/* Specify the architecture of the target when it has been
explicitly specified */
if (selected_architecture_name () != NULL)
{
strcat (arg_buf, " --architecture=");
strcat (arg_buf, selected_architecture_name ());
}
/* finally, any explicit args */
if (args)
{
strcat (arg_buf, " "); /* 1 */
strcat (arg_buf, args);
}
argv = buildargv (arg_buf);
if (argv == NULL)
error ("Insufficient memory available to allocate simulator arg list.");
make_cleanup_freeargv (argv);
init_callbacks ();
gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
if (gdbsim_desc == 0)
error ("unable to create simulator instance");
push_target (&gdbsim_ops);
target_fetch_registers (-1);
printf_filtered ("Connected to the simulator.\n");
}
CompilerCommandLineParser::CompilerCommandLineParser(const wxString& cmdline, const wxString& workingDirectory)
{
m_argc = 0;
m_argv = NULL;
wxString c = cmdline;
// HACK
// Since our code does not handle \ properly when its part of a directory name
// we replace it with forward slash
c.Replace(wxT("\\\""), wxT("@@GERESH@@"));
c.Replace(wxT("\\"), wxT("/"));
c.Replace(wxT("@@GERESH@@"), wxT("\\\""));
// Check for makefile directory changes lines
if(cmdline.Contains(wxT("Entering directory `"))) {
wxString currentDir = cmdline.AfterFirst(wxT('`'));
m_diretory = currentDir.BeforeLast(wxT('\''));
} else {
m_argv = buildargv(c.mb_str(wxConvUTF8).data(), m_argc);
for(int i=0; i<m_argc; i++) {
wxString opt = wxString(m_argv[i], wxConvUTF8);
opt.Trim().Trim(false);
wxString rest;
if ( opt.StartsWith("@") && (opt.Contains("includes_C.rsp") || opt.Contains("includes_CXX.rsp") ) ) {
// The include folders are inside the file - read the file and process its content
wxFileName fnIncludes( workingDirectory + "/" + opt.Mid(1) );
if ( fnIncludes.Exists() ) {
AddIncludesFromFile( fnIncludes );
}
} else if ( opt == "-isystem" && (i+1 < m_argc) ) {
// the next arg is the include folder
wxString include_path = m_argv[i+1];
include_path.Trim().Trim(false);
m_includes.Add( include_path );
m_includesWithPrefix.Add( wxString() << "-I" << include_path );
++i;
} else if( opt.StartsWith(wxT("-I"), &rest)) {
m_includes.Add(rest);
m_includesWithPrefix.Add(opt);
}
else if(opt.StartsWith(wxT("-D"), &rest)) {
m_macros.Add(rest);
m_macrosWithPrefix.Add(opt);
}
else if(opt.StartsWith(wxT("-include-path"), &rest)) {
m_includesWithPrefix.Add(opt);
rest.Trim().Trim(false);
m_pchFile = rest;
}
// Support for Apple's Framework include paths
else if(opt.StartsWith(wxT("-F"), &rest)) {
m_includesWithPrefix.Add(opt);
rest.Trim().Trim(false);
m_framworks.Add(rest);
}
// Support for Apple's Framework include paths
else if(opt.StartsWith(wxT("-std"), &rest)) {
wxString stds = rest.AfterFirst(wxT('='));
stds.Trim().Trim(false);
if ( stds.IsEmpty() == false ) {
m_standard = stds;
}
} else {
m_otherOptions.Add( opt );
}
}
}
}
void
expandargv (int *argcp, char ***argvp)
{
/* The argument we are currently processing. */
int i = 0;
/* Non-zero if ***argvp has been dynamically allocated. */
int argv_dynamic = 0;
/* Limit the number of response files that we parse in order
to prevent infinite recursion. */
unsigned int iteration_limit = 2000;
/* Loop over the arguments, handling response files. We always skip
ARGVP[0], as that is the name of the program being run. */
while (++i < *argcp)
{
/* The name of the response file. */
const char *filename;
/* The response file. */
FILE *f;
/* An upper bound on the number of characters in the response
file. */
long pos;
/* The number of characters in the response file, when actually
read. */
size_t len;
/* A dynamically allocated buffer used to hold options read from a
response file. */
char *buffer;
/* Dynamically allocated storage for the options read from the
response file. */
char **file_argv;
/* The number of options read from the response file, if any. */
size_t file_argc;
/* We are only interested in options of the form "@file". */
filename = (*argvp)[i];
if (filename[0] != '@')
continue;
/* If we have iterated too many times then stop. */
if (-- iteration_limit == 0)
{
fprintf (stderr, "%s: error: too many @-files encountered\n", (*argvp)[0]);
xexit (1);
}
/* Read the contents of the file. */
f = fopen (++filename, "r");
if (!f)
continue;
if (fseek (f, 0L, SEEK_END) == -1)
goto error;
pos = ftell (f);
if (pos == -1)
goto error;
if (fseek (f, 0L, SEEK_SET) == -1)
goto error;
buffer = (char *) xmalloc (pos * sizeof (char) + 1);
len = fread (buffer, sizeof (char), pos, f);
if (len != (size_t) pos
/* On Windows, fread may return a value smaller than POS,
due to CR/LF->CR translation when reading text files.
That does not in-and-of itself indicate failure. */
&& ferror (f))
goto error;
/* Add a NUL terminator. */
buffer[len] = '\0';
/* If the file is empty or contains only whitespace, buildargv would
return a single empty argument. In this context we want no arguments,
instead. */
if (only_whitespace (buffer))
{
file_argv = (char **) xmalloc (sizeof (char *));
file_argv[0] = NULL;
}
else
/* Parse the string. */
file_argv = buildargv (buffer);
/* If *ARGVP is not already dynamically allocated, copy it. */
if (!argv_dynamic)
*argvp = dupargv (*argvp);
/* Count the number of arguments. */
file_argc = 0;
while (file_argv[file_argc])
++file_argc;
/* Now, insert FILE_ARGV into ARGV. The "+1" below handles the
NULL terminator at the end of ARGV. */
*argvp = ((char **)
xrealloc (*argvp,
(*argcp + file_argc + 1) * sizeof (char *)));
memmove (*argvp + i + file_argc, *argvp + i + 1,
(*argcp - i) * sizeof (char *));
memcpy (*argvp + i, file_argv, file_argc * sizeof (char *));
/* The original option has been replaced by all the new
options. */
*argcp += file_argc - 1;
/* Free up memory allocated to process the response file. We do
not use freeargv because the individual options in FILE_ARGV
are now in the main ARGV. */
free (file_argv);
free (buffer);
/* Rescan all of the arguments just read to support response
files that include other response files. */
--i;
error:
/* We're all done with the file now. */
fclose (f);
}
}
