OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [main.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Top level stuff for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4
   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
5
   Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "top.h"
24
#include "target.h"
25
#include "inferior.h"
26
#include "symfile.h"
27
#include "gdbcore.h"
28
 
29
#include "exceptions.h"
30
#include "getopt.h"
31
 
32
#include <sys/types.h>
33
#include "gdb_stat.h"
34
#include <ctype.h>
35
 
36
#include "gdb_string.h"
37
#include "event-loop.h"
38
#include "ui-out.h"
39
 
40
#include "interps.h"
41
#include "main.h"
42
 
43
/* If nonzero, display time usage both at startup and for each command.  */
44
 
45
int display_time;
46
 
47
/* If nonzero, display space usage both at startup and for each command.  */
48
 
49
int display_space;
50
 
51
/* The selected interpreter.  This will be used as a set command
52
   variable, so it should always be malloc'ed - since
53
   do_setshow_command will free it. */
54
char *interpreter_p;
55
 
56
/* Whether xdb commands will be handled */
57
int xdb_commands = 0;
58
 
59
/* Whether dbx commands will be handled */
60
int dbx_commands = 0;
61
 
62
/* System root path, used to find libraries etc.  */
63
char *gdb_sysroot = 0;
64
 
65
struct ui_file *gdb_stdout;
66
struct ui_file *gdb_stderr;
67
struct ui_file *gdb_stdlog;
68
struct ui_file *gdb_stdin;
69
/* target IO streams */
70
struct ui_file *gdb_stdtargin;
71
struct ui_file *gdb_stdtarg;
72
struct ui_file *gdb_stdtargerr;
73
 
74
/* Support for the --batch-silent option.  */
75
int batch_silent = 0;
76
 
77
/* Support for --return-child-result option.
78
   Set the default to -1 to return error in the case
79
   that the program does not run or does not complete.  */
80
int return_child_result = 0;
81
int return_child_result_value = -1;
82
 
83
/* Whether to enable writing into executable and core files */
84
extern int write_files;
85
 
86
static void print_gdb_help (struct ui_file *);
87
 
88
/* These two are used to set the external editor commands when gdb is farming
89
   out files to be edited by another program. */
90
 
91
extern char *external_editor_command;
92
 
93
/* Call command_loop.  If it happens to return, pass that through as a
94
   non-zero return status. */
95
 
96
static int
97
captured_command_loop (void *data)
98
{
99
  current_interp_command_loop ();
100
  /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
101
     would clean things up (restoring the cleanup chain) to the state
102
     they were just prior to the call.  Technically, this means that
103
     the do_cleanups() below is redundant.  Unfortunately, many FUNCs
104
     are not that well behaved.  do_cleanups should either be replaced
105
     with a do_cleanups call (to cover the problem) or an assertion
106
     check to detect bad FUNCs code. */
107
  do_cleanups (ALL_CLEANUPS);
108
  /* If the command_loop returned, normally (rather than threw an
109
     error) we try to quit. If the quit is aborted, catch_errors()
110
     which called this catch the signal and restart the command
111
     loop. */
112
  quit_command (NULL, instream == stdin);
113
  return 1;
114
}
115
 
116 131 jeremybenn
/* JPB: Some picky Ubuntu GCC compilers don't like the result of getcwd being
117
   ignored (even if you cast it to void). So capture the value and ignore
118
   THAT. */
119 24 jeremybenn
static int
120
captured_main (void *data)
121
{
122 131 jeremybenn
  char *res;                    /* For getcwd result */
123
 
124 24 jeremybenn
  struct captured_main_args *context = data;
125
  int argc = context->argc;
126
  char **argv = context->argv;
127
  static int quiet = 0;
128
  static int batch = 0;
129
  static int set_args = 0;
130
 
131
  /* Pointers to various arguments from command line.  */
132
  char *symarg = NULL;
133
  char *execarg = NULL;
134
  char *pidarg = NULL;
135
  char *corearg = NULL;
136
  char *pid_or_core_arg = NULL;
137
  char *cdarg = NULL;
138
  char *ttyarg = NULL;
139
 
140
  /* These are static so that we can take their address in an initializer.  */
141
  static int print_help;
142
  static int print_version;
143
 
144
  /* Pointers to all arguments of --command option.  */
145
  struct cmdarg {
146
    enum {
147
      CMDARG_FILE,
148
      CMDARG_COMMAND
149
    } type;
150
    char *string;
151
  } *cmdarg;
152
  /* Allocated size of cmdarg.  */
153
  int cmdsize;
154
  /* Number of elements of cmdarg used.  */
155
  int ncmd;
156
 
157
  /* Indices of all arguments of --directory option.  */
158
  char **dirarg;
159
  /* Allocated size.  */
160
  int dirsize;
161
  /* Number of elements used.  */
162
  int ndir;
163
 
164
  struct stat homebuf, cwdbuf;
165
  char *homedir;
166
 
167
  int i;
168
 
169
  long time_at_startup = get_run_time ();
170
 
171
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
172
  setlocale (LC_MESSAGES, "");
173
#endif
174
#if defined (HAVE_SETLOCALE)
175
  setlocale (LC_CTYPE, "");
176
#endif
177
  bindtextdomain (PACKAGE, LOCALEDIR);
178
  textdomain (PACKAGE);
179
 
180
#ifdef HAVE_SBRK
181
  lim_at_start = (char *) sbrk (0);
182
#endif
183
 
184
  cmdsize = 1;
185
  cmdarg = (struct cmdarg *) xmalloc (cmdsize * sizeof (*cmdarg));
186
  ncmd = 0;
187
  dirsize = 1;
188
  dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
189
  ndir = 0;
190
 
191
  quit_flag = 0;
192
  line = (char *) xmalloc (linesize);
193
  line[0] = '\0';                /* Terminate saved (now empty) cmd line */
194
  instream = stdin;
195
 
196 131 jeremybenn
  res = getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));       /* JPB */
197 24 jeremybenn
  current_directory = gdb_dirbuf;
198
 
199
  gdb_stdout = stdio_fileopen (stdout);
200
  gdb_stderr = stdio_fileopen (stderr);
201
  gdb_stdlog = gdb_stderr;      /* for moment */
202
  gdb_stdtarg = gdb_stderr;     /* for moment */
203
  gdb_stdin = stdio_fileopen (stdin);
204
  gdb_stdtargerr = gdb_stderr;  /* for moment */
205
  gdb_stdtargin = gdb_stdin;    /* for moment */
206
 
207
  /* Set the sysroot path.  */
208
#ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
209
  gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
210
  if (gdb_sysroot)
211
    {
212
      struct stat s;
213
      int res = 0;
214
 
215
      if (stat (gdb_sysroot, &s) == 0)
216
        if (S_ISDIR (s.st_mode))
217
          res = 1;
218
 
219
      if (res == 0)
220
        {
221
          xfree (gdb_sysroot);
222
          gdb_sysroot = xstrdup (TARGET_SYSTEM_ROOT);
223
        }
224
    }
225
  else
226
    gdb_sysroot = xstrdup (TARGET_SYSTEM_ROOT);
227
#else
228
  gdb_sysroot = xstrdup (TARGET_SYSTEM_ROOT);
229
#endif
230
 
231
  /* Canonicalize the sysroot path.  */
232
  if (*gdb_sysroot)
233
    {
234
      char *canon_sysroot = lrealpath (gdb_sysroot);
235
      if (canon_sysroot)
236
        {
237
          xfree (gdb_sysroot);
238
          gdb_sysroot = canon_sysroot;
239
        }
240
    }
241
 
242
#ifdef DEBUGDIR_RELOCATABLE
243
  debug_file_directory = make_relative_prefix (argv[0], BINDIR, DEBUGDIR);
244
  if (debug_file_directory)
245
    {
246
      struct stat s;
247
      int res = 0;
248
 
249
      if (stat (debug_file_directory, &s) == 0)
250
        if (S_ISDIR (s.st_mode))
251
          res = 1;
252
 
253
      if (res == 0)
254
        {
255
          xfree (debug_file_directory);
256
          debug_file_directory = xstrdup (DEBUGDIR);
257
        }
258
    }
259
  else
260
    debug_file_directory = xstrdup (DEBUGDIR);
261
#else
262
  debug_file_directory = xstrdup (DEBUGDIR);
263
#endif
264
 
265
  /* Canonicalize the debugfile path.  */
266
  if (*debug_file_directory)
267
    {
268
      char *canon_debug = lrealpath (debug_file_directory);
269
      if (canon_debug)
270
        {
271
          xfree (debug_file_directory);
272
          debug_file_directory = canon_debug;
273
        }
274
    }
275
 
276
  /* There will always be an interpreter.  Either the one passed into
277
     this captured main, or one specified by the user at start up, or
278
     the console.  Initialize the interpreter to the one requested by
279
     the application.  */
280
  interpreter_p = xstrdup (context->interpreter_p);
281
 
282
  /* Parse arguments and options.  */
283
  {
284
    int c;
285
    /* When var field is 0, use flag field to record the equivalent
286
       short option (or arbitrary numbers starting at 10 for those
287
       with no equivalent).  */
288
    enum {
289
      OPT_SE = 10,
290
      OPT_CD,
291
      OPT_ANNOTATE,
292
      OPT_STATISTICS,
293
      OPT_TUI,
294
      OPT_NOWINDOWS,
295
      OPT_WINDOWS
296
    };
297
    static struct option long_options[] =
298
    {
299
      {"tui", no_argument, 0, OPT_TUI},
300
      {"xdb", no_argument, &xdb_commands, 1},
301
      {"dbx", no_argument, &dbx_commands, 1},
302
      {"readnow", no_argument, &readnow_symbol_files, 1},
303
      {"r", no_argument, &readnow_symbol_files, 1},
304
      {"quiet", no_argument, &quiet, 1},
305
      {"q", no_argument, &quiet, 1},
306
      {"silent", no_argument, &quiet, 1},
307
      {"nx", no_argument, &inhibit_gdbinit, 1},
308
      {"n", no_argument, &inhibit_gdbinit, 1},
309
      {"batch-silent", no_argument, 0, 'B'},
310
      {"batch", no_argument, &batch, 1},
311
      {"epoch", no_argument, &epoch_interface, 1},
312
 
313
    /* This is a synonym for "--annotate=1".  --annotate is now preferred,
314
       but keep this here for a long time because people will be running
315
       emacses which use --fullname.  */
316
      {"fullname", no_argument, 0, 'f'},
317
      {"f", no_argument, 0, 'f'},
318
 
319
      {"annotate", required_argument, 0, OPT_ANNOTATE},
320
      {"help", no_argument, &print_help, 1},
321
      {"se", required_argument, 0, OPT_SE},
322
      {"symbols", required_argument, 0, 's'},
323
      {"s", required_argument, 0, 's'},
324
      {"exec", required_argument, 0, 'e'},
325
      {"e", required_argument, 0, 'e'},
326
      {"core", required_argument, 0, 'c'},
327
      {"c", required_argument, 0, 'c'},
328
      {"pid", required_argument, 0, 'p'},
329
      {"p", required_argument, 0, 'p'},
330
      {"command", required_argument, 0, 'x'},
331
      {"eval-command", required_argument, 0, 'X'},
332
      {"version", no_argument, &print_version, 1},
333
      {"x", required_argument, 0, 'x'},
334
      {"ex", required_argument, 0, 'X'},
335
#ifdef GDBTK
336
      {"tclcommand", required_argument, 0, 'z'},
337
      {"enable-external-editor", no_argument, 0, 'y'},
338
      {"editor-command", required_argument, 0, 'w'},
339
#endif
340
      {"ui", required_argument, 0, 'i'},
341
      {"interpreter", required_argument, 0, 'i'},
342
      {"i", required_argument, 0, 'i'},
343
      {"directory", required_argument, 0, 'd'},
344
      {"d", required_argument, 0, 'd'},
345
      {"cd", required_argument, 0, OPT_CD},
346
      {"tty", required_argument, 0, 't'},
347
      {"baud", required_argument, 0, 'b'},
348
      {"b", required_argument, 0, 'b'},
349
      {"nw", no_argument, NULL, OPT_NOWINDOWS},
350
      {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
351
      {"w", no_argument, NULL, OPT_WINDOWS},
352
      {"windows", no_argument, NULL, OPT_WINDOWS},
353
      {"statistics", no_argument, 0, OPT_STATISTICS},
354
      {"write", no_argument, &write_files, 1},
355
      {"args", no_argument, &set_args, 1},
356
     {"l", required_argument, 0, 'l'},
357
      {"return-child-result", no_argument, &return_child_result, 1},
358
      {0, no_argument, 0, 0}
359
    };
360
 
361
    while (1)
362
      {
363
        int option_index;
364
 
365
        c = getopt_long_only (argc, argv, "",
366
                              long_options, &option_index);
367
        if (c == EOF || set_args)
368
          break;
369
 
370
        /* Long option that takes an argument.  */
371
        if (c == 0 && long_options[option_index].flag == 0)
372
          c = long_options[option_index].val;
373
 
374
        switch (c)
375
          {
376
          case 0:
377
            /* Long option that just sets a flag.  */
378
            break;
379
          case OPT_SE:
380
            symarg = optarg;
381
            execarg = optarg;
382
            break;
383
          case OPT_CD:
384
            cdarg = optarg;
385
            break;
386
          case OPT_ANNOTATE:
387
            /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
388
            annotation_level = atoi (optarg);
389
            break;
390
          case OPT_STATISTICS:
391
            /* Enable the display of both time and space usage.  */
392
            display_time = 1;
393
            display_space = 1;
394
            break;
395
          case OPT_TUI:
396
            /* --tui is equivalent to -i=tui.  */
397
#ifdef TUI
398
            xfree (interpreter_p);
399
            interpreter_p = xstrdup (INTERP_TUI);
400
#else
401
            fprintf_unfiltered (gdb_stderr,
402
                                _("%s: TUI mode is not supported\n"),
403
                                argv[0]);
404
            exit (1);
405
#endif
406
            break;
407
          case OPT_WINDOWS:
408
            /* FIXME: cagney/2003-03-01: Not sure if this option is
409
               actually useful, and if it is, what it should do.  */
410
#ifdef GDBTK
411
            /* --windows is equivalent to -i=insight.  */
412
            xfree (interpreter_p);
413
            interpreter_p = xstrdup (INTERP_INSIGHT);
414
#endif
415
            use_windows = 1;
416
            break;
417
          case OPT_NOWINDOWS:
418
            /* -nw is equivalent to -i=console.  */
419
            xfree (interpreter_p);
420
            interpreter_p = xstrdup (INTERP_CONSOLE);
421
            use_windows = 0;
422
            break;
423
          case 'f':
424
            annotation_level = 1;
425
/* We have probably been invoked from emacs.  Disable window interface.  */
426
            use_windows = 0;
427
            break;
428
          case 's':
429
            symarg = optarg;
430
            break;
431
          case 'e':
432
            execarg = optarg;
433
            break;
434
          case 'c':
435
            corearg = optarg;
436
            break;
437
          case 'p':
438
            pidarg = optarg;
439
            break;
440
          case 'x':
441
            cmdarg[ncmd].type = CMDARG_FILE;
442
            cmdarg[ncmd++].string = optarg;
443
            if (ncmd >= cmdsize)
444
              {
445
                cmdsize *= 2;
446
                cmdarg = xrealloc ((char *) cmdarg,
447
                                   cmdsize * sizeof (*cmdarg));
448
              }
449
            break;
450
          case 'X':
451
            cmdarg[ncmd].type = CMDARG_COMMAND;
452
            cmdarg[ncmd++].string = optarg;
453
            if (ncmd >= cmdsize)
454
              {
455
                cmdsize *= 2;
456
                cmdarg = xrealloc ((char *) cmdarg,
457
                                   cmdsize * sizeof (*cmdarg));
458
              }
459
            break;
460
          case 'B':
461
            batch = batch_silent = 1;
462
            gdb_stdout = ui_file_new();
463
            break;
464
#ifdef GDBTK
465
          case 'z':
466
            {
467
extern int gdbtk_test (char *);
468
              if (!gdbtk_test (optarg))
469
                {
470
                  fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
471
                                      argv[0], optarg);
472
                  exit (1);
473
                }
474
              break;
475
            }
476
          case 'y':
477
            /* Backwards compatibility only.  */
478
            break;
479
          case 'w':
480
            {
481
              external_editor_command = xstrdup (optarg);
482
              break;
483
            }
484
#endif /* GDBTK */
485
          case 'i':
486
            xfree (interpreter_p);
487
            interpreter_p = xstrdup (optarg);
488
            break;
489
          case 'd':
490
            dirarg[ndir++] = optarg;
491
            if (ndir >= dirsize)
492
              {
493
                dirsize *= 2;
494
                dirarg = (char **) xrealloc ((char *) dirarg,
495
                                             dirsize * sizeof (*dirarg));
496
              }
497
            break;
498
          case 't':
499
            ttyarg = optarg;
500
            break;
501
          case 'q':
502
            quiet = 1;
503
            break;
504
          case 'b':
505
            {
506
              int i;
507
              char *p;
508
 
509
              i = strtol (optarg, &p, 0);
510
              if (i == 0 && p == optarg)
511
 
512
                /* Don't use *_filtered or warning() (which relies on
513
                   current_target) until after initialize_all_files(). */
514
 
515
                fprintf_unfiltered
516
                  (gdb_stderr,
517
                   _("warning: could not set baud rate to `%s'.\n"), optarg);
518
              else
519
                baud_rate = i;
520
            }
521
            break;
522
          case 'l':
523
            {
524
              int i;
525
              char *p;
526
 
527
              i = strtol (optarg, &p, 0);
528
              if (i == 0 && p == optarg)
529
 
530
                /* Don't use *_filtered or warning() (which relies on
531
                   current_target) until after initialize_all_files(). */
532
 
533
                fprintf_unfiltered
534
                  (gdb_stderr,
535
                 _("warning: could not set timeout limit to `%s'.\n"), optarg);
536
              else
537
                remote_timeout = i;
538
            }
539
            break;
540
 
541
          case '?':
542
            fprintf_unfiltered (gdb_stderr,
543
                        _("Use `%s --help' for a complete list of options.\n"),
544
                                argv[0]);
545
            exit (1);
546
          }
547
      }
548
 
549
    /* If --help or --version, disable window interface.  */
550
    if (print_help || print_version)
551
      {
552
        use_windows = 0;
553
      }
554
 
555
    if (set_args)
556
      {
557
        /* The remaining options are the command-line options for the
558
           inferior.  The first one is the sym/exec file, and the rest
559
           are arguments.  */
560
        if (optind >= argc)
561
          {
562
            fprintf_unfiltered (gdb_stderr,
563
                                _("%s: `--args' specified but no program specified\n"),
564
                                argv[0]);
565
            exit (1);
566
          }
567
        symarg = argv[optind];
568
        execarg = argv[optind];
569
        ++optind;
570
        set_inferior_args_vector (argc - optind, &argv[optind]);
571
      }
572
    else
573
      {
574
        /* OK, that's all the options.  */
575
 
576
        /* The first argument, if specified, is the name of the
577
           executable.  */
578
        if (optind < argc)
579
          {
580
            symarg = argv[optind];
581
            execarg = argv[optind];
582
            optind++;
583
          }
584
 
585
        /* If the user hasn't already specified a PID or the name of a
586
           core file, then a second optional argument is allowed.  If
587
           present, this argument should be interpreted as either a
588
           PID or a core file, whichever works.  */
589
        if (pidarg == NULL && corearg == NULL && optind < argc)
590
          {
591
            pid_or_core_arg = argv[optind];
592
            optind++;
593
          }
594
 
595
        /* Any argument left on the command line is unexpected and
596
           will be ignored.  Inform the user.  */
597
        if (optind < argc)
598
          fprintf_unfiltered (gdb_stderr, _("\
599
Excess command line arguments ignored. (%s%s)\n"),
600
                              argv[optind],
601
                              (optind == argc - 1) ? "" : " ...");
602
      }
603
    if (batch)
604
      quiet = 1;
605
  }
606
 
607
  /* Initialize all files.  Give the interpreter a chance to take
608
     control of the console via the deprecated_init_ui_hook ().  */
609
  gdb_init (argv[0]);
610
 
611
  /* Do these (and anything which might call wrap_here or *_filtered)
612
     after initialize_all_files() but before the interpreter has been
613
     installed.  Otherwize the help/version messages will be eaten by
614
     the interpreter's output handler.  */
615
 
616
  if (print_version)
617
    {
618
      print_gdb_version (gdb_stdout);
619
      wrap_here ("");
620
      printf_filtered ("\n");
621
      exit (0);
622
    }
623
 
624
  if (print_help)
625
    {
626
      print_gdb_help (gdb_stdout);
627
      fputs_unfiltered ("\n", gdb_stdout);
628
      exit (0);
629
    }
630
 
631
  /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
632
     GDB retain the old MI1 interpreter startup behavior.  Output the
633
     copyright message before the interpreter is installed.  That way
634
     it isn't encapsulated in MI output.  */
635
  if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
636
    {
637
      /* Print all the junk at the top, with trailing "..." if we are about
638
         to read a symbol file (possibly slowly).  */
639
      print_gdb_version (gdb_stdout);
640
      if (symarg)
641
        printf_filtered ("..");
642
      wrap_here ("");
643
      printf_filtered ("\n");
644
      gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
645
    }
646
 
647
 
648
  /* Install the default UI.  All the interpreters should have had a
649
     look at things by now.  Initialize the default interpreter. */
650
 
651
  {
652
    /* Find it.  */
653
    struct interp *interp = interp_lookup (interpreter_p);
654
    if (interp == NULL)
655
      error (_("Interpreter `%s' unrecognized"), interpreter_p);
656
    /* Install it.  */
657
    if (!interp_set (interp))
658
      {
659
        fprintf_unfiltered (gdb_stderr,
660
                            "Interpreter `%s' failed to initialize.\n",
661
                            interpreter_p);
662
        exit (1);
663
      }
664
  }
665
 
666
  /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
667
     GDB retain the old MI1 interpreter startup behavior.  Output the
668
     copyright message after the interpreter is installed when it is
669
     any sane interpreter.  */
670
  if (!quiet && !current_interp_named_p (INTERP_MI1))
671
    {
672
      /* Print all the junk at the top, with trailing "..." if we are about
673
         to read a symbol file (possibly slowly).  */
674
      print_gdb_version (gdb_stdout);
675
      if (symarg)
676
        printf_filtered ("..");
677
      wrap_here ("");
678
      printf_filtered ("\n");
679
      gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
680
    }
681
 
682
  /* Set off error and warning messages with a blank line.  */
683
  error_pre_print = "\n";
684
  quit_pre_print = error_pre_print;
685
  warning_pre_print = _("\nwarning: ");
686
 
687
  /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
688
     *before* all the command line arguments are processed; it sets
689
     global parameters, which are independent of what file you are
690
     debugging or what directory you are in.  */
691
  homedir = getenv ("HOME");
692
  if (homedir)
693
    {
694
      char *homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
695
 
696
      if (!inhibit_gdbinit)
697
        {
698
          catch_command_errors (source_script, homeinit, 0, RETURN_MASK_ALL);
699
        }
700
 
701
      /* Do stats; no need to do them elsewhere since we'll only
702
         need them if homedir is set.  Make sure that they are
703
         zero in case one of them fails (this guarantees that they
704
         won't match if either exists).  */
705
 
706
      memset (&homebuf, 0, sizeof (struct stat));
707
      memset (&cwdbuf, 0, sizeof (struct stat));
708
 
709
      stat (homeinit, &homebuf);
710
      stat (gdbinit, &cwdbuf);  /* We'll only need this if
711
                                   homedir was set.  */
712
      xfree (homeinit);
713
    }
714
 
715
  /* Now perform all the actions indicated by the arguments.  */
716
  if (cdarg != NULL)
717
    {
718
      catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
719
    }
720
 
721
  for (i = 0; i < ndir; i++)
722
    catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
723
  xfree (dirarg);
724
 
725
  if (execarg != NULL
726
      && symarg != NULL
727
      && strcmp (execarg, symarg) == 0)
728
    {
729
      /* The exec file and the symbol-file are the same.  If we can't
730
         open it, better only print one error message.
731
         catch_command_errors returns non-zero on success! */
732
      if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
733
        catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
734
    }
735
  else
736
    {
737
      if (execarg != NULL)
738
        catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
739
      if (symarg != NULL)
740
        catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
741
    }
742
 
743
  if (corearg && pidarg)
744
    error (_("\
745
Can't attach to process and specify a core file at the same time."));
746
 
747
  if (corearg != NULL)
748
    catch_command_errors (core_file_command, corearg,
749
                          !batch, RETURN_MASK_ALL);
750
  else if (pidarg != NULL)
751
    catch_command_errors (attach_command, pidarg,
752
                          !batch, RETURN_MASK_ALL);
753
  else if (pid_or_core_arg)
754
    {
755
      /* The user specified 'gdb program pid' or gdb program core'.
756
         If pid_or_core_arg's first character is a digit, try attach
757
         first and then corefile.  Otherwise try just corefile.  */
758
 
759
      if (isdigit (pid_or_core_arg[0]))
760
        {
761
          if (catch_command_errors (attach_command, pid_or_core_arg,
762
                                    !batch, RETURN_MASK_ALL) == 0)
763
            catch_command_errors (core_file_command, pid_or_core_arg,
764
                                  !batch, RETURN_MASK_ALL);
765
        }
766
      else /* Can't be a pid, better be a corefile.  */
767
        catch_command_errors (core_file_command, pid_or_core_arg,
768
                              !batch, RETURN_MASK_ALL);
769
    }
770
 
771
  if (ttyarg != NULL)
772
    catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
773
 
774
  /* Error messages should no longer be distinguished with extra output. */
775
  error_pre_print = NULL;
776
  quit_pre_print = NULL;
777
  warning_pre_print = _("warning: ");
778
 
779
  /* Read the .gdbinit file in the current directory, *if* it isn't
780
     the same as the $HOME/.gdbinit file (it should exist, also).  */
781
 
782
  if (!homedir
783
      || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
784
    if (!inhibit_gdbinit)
785
      {
786
        catch_command_errors (source_script, gdbinit, 0, RETURN_MASK_ALL);
787
      }
788
 
789
  for (i = 0; i < ncmd; i++)
790
    {
791
#if 0
792
      /* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
793
         expanded into a call to setjmp().  */
794
      if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
795
        {
796
          /* NOTE: I am commenting this out, because it is not clear
797
             where this feature is used. It is very old and
798
             undocumented. ezannoni: 1999-05-04 */
799
#if 0
800
          if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
801
            read_command_file (stdin);
802
          else
803
#endif
804
            source_script (cmdarg[i], !batch);
805
          do_cleanups (ALL_CLEANUPS);
806
        }
807
#endif
808
      if (cmdarg[i].type == CMDARG_FILE)
809
        catch_command_errors (source_script, cmdarg[i].string,
810
                              !batch, RETURN_MASK_ALL);
811
      else  /* cmdarg[i].type == CMDARG_COMMAND */
812
        catch_command_errors (execute_command, cmdarg[i].string,
813
                              !batch, RETURN_MASK_ALL);
814
    }
815
  xfree (cmdarg);
816
 
817
  /* Read in the old history after all the command files have been read. */
818
  init_history ();
819
 
820
  if (batch)
821
    {
822
      /* We have hit the end of the batch file.  */
823
      quit_force (NULL, 0);
824
    }
825
 
826
  /* Do any host- or target-specific hacks.  This is used for i960 targets
827
     to force the user to set a nindy target and spec its parameters.  */
828
 
829
#ifdef BEFORE_MAIN_LOOP_HOOK
830
  BEFORE_MAIN_LOOP_HOOK;
831
#endif
832
 
833
  /* Show time and/or space usage.  */
834
 
835
  if (display_time)
836
    {
837
      long init_time = get_run_time () - time_at_startup;
838
 
839
      printf_unfiltered (_("Startup time: %ld.%06ld\n"),
840
                         init_time / 1000000, init_time % 1000000);
841
    }
842
 
843
  if (display_space)
844
    {
845
#ifdef HAVE_SBRK
846
      extern char **environ;
847
      char *lim = (char *) sbrk (0);
848
 
849
      printf_unfiltered (_("Startup size: data size %ld\n"),
850
                         (long) (lim - (char *) &environ));
851
#endif
852
    }
853
 
854
#if 0
855
  /* FIXME: cagney/1999-11-06: The original main loop was like: */
856
  while (1)
857
    {
858
      if (!SET_TOP_LEVEL ())
859
        {
860
          do_cleanups (ALL_CLEANUPS);   /* Do complete cleanup */
861
          /* GUIs generally have their own command loop, mainloop, or
862
             whatever.  This is a good place to gain control because
863
             many error conditions will end up here via longjmp().  */
864
          if (deprecated_command_loop_hook)
865
            deprecated_command_loop_hook ();
866
          else
867
            deprecated_command_loop ();
868
          quit_command ((char *) 0, instream == stdin);
869
        }
870
    }
871
  /* NOTE: If the command_loop() returned normally, the loop would
872
     attempt to exit by calling the function quit_command().  That
873
     function would either call exit() or throw an error returning
874
     control to SET_TOP_LEVEL. */
875
  /* NOTE: The function do_cleanups() was called once each time round
876
     the loop.  The usefulness of the call isn't clear.  If an error
877
     was thrown, everything would have already been cleaned up.  If
878
     command_loop() returned normally and quit_command() was called,
879
     either exit() or error() (again cleaning up) would be called. */
880
#endif
881
  /* NOTE: cagney/1999-11-07: There is probably no reason for not
882
     moving this loop and the code found in captured_command_loop()
883
     into the command_loop() proper.  The main thing holding back that
884
     change - SET_TOP_LEVEL() - has been eliminated. */
885
  while (1)
886
    {
887
      catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
888
    }
889
  /* No exit -- exit is through quit_command.  */
890
}
891
 
892
int
893
gdb_main (struct captured_main_args *args)
894
{
895
  use_windows = args->use_windows;
896
  catch_errors (captured_main, args, "", RETURN_MASK_ALL);
897
  /* The only way to end up here is by an error (normal exit is
898
     handled by quit_force()), hence always return an error status.  */
899
  return 1;
900
}
901
 
902
 
903
/* Don't use *_filtered for printing help.  We don't want to prompt
904
   for continue no matter how small the screen or how much we're going
905
   to print.  */
906
 
907
static void
908
print_gdb_help (struct ui_file *stream)
909
{
910
  fputs_unfiltered (_("\
911
This is the GNU debugger.  Usage:\n\n\
912
    gdb [options] [executable-file [core-file or process-id]]\n\
913
    gdb [options] --args executable-file [inferior-arguments ...]\n\n\
914
Options:\n\n\
915
"), stream);
916
  fputs_unfiltered (_("\
917
  --args             Arguments after executable-file are passed to inferior\n\
918
"), stream);
919
  fputs_unfiltered (_("\
920
  -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
921
  --batch            Exit after processing options.\n\
922
  --batch-silent     As for --batch, but suppress all gdb stdout output.\n\
923
  --return-child-result\n\
924
                     GDB exit code will be the child's exit code.\n\
925
  --cd=DIR           Change current directory to DIR.\n\
926
  --command=FILE, -x Execute GDB commands from FILE.\n\
927
  --eval-command=COMMAND, -ex\n\
928
                     Execute a single GDB command.\n\
929
                     May be used multiple times and in conjunction\n\
930
                     with --command.\n\
931
  --core=COREFILE    Analyze the core dump COREFILE.\n\
932
  --pid=PID          Attach to running process PID.\n\
933
"), stream);
934
  fputs_unfiltered (_("\
935
  --dbx              DBX compatibility mode.\n\
936
  --directory=DIR    Search for source files in DIR.\n\
937
  --epoch            Output information used by epoch emacs-GDB interface.\n\
938
  --exec=EXECFILE    Use EXECFILE as the executable.\n\
939
  --fullname         Output information used by emacs-GDB interface.\n\
940
  --help             Print this message.\n\
941
"), stream);
942
  fputs_unfiltered (_("\
943
  --interpreter=INTERP\n\
944
                     Select a specific interpreter / user interface\n\
945
"), stream);
946
  fputs_unfiltered (_("\
947
  -l TIMEOUT         Set timeout in seconds for remote debugging.\n\
948
  --nw               Do not use a window interface.\n\
949
  --nx               Do not read "), stream);
950
  fputs_unfiltered (gdbinit, stream);
951
  fputs_unfiltered (_(" file.\n\
952
  --quiet            Do not print version number on startup.\n\
953
  --readnow          Fully read symbol files on first access.\n\
954
"), stream);
955
  fputs_unfiltered (_("\
956
  --se=FILE          Use FILE as symbol file and executable file.\n\
957
  --symbols=SYMFILE  Read symbols from SYMFILE.\n\
958
  --tty=TTY          Use TTY for input/output by the program being debugged.\n\
959
"), stream);
960
#if defined(TUI)
961
  fputs_unfiltered (_("\
962
  --tui              Use a terminal user interface.\n\
963
"), stream);
964
#endif
965
  fputs_unfiltered (_("\
966
  --version          Print version information and then exit.\n\
967
  -w                 Use a window interface.\n\
968
  --write            Set writing into executable and core files.\n\
969
  --xdb              XDB compatibility mode.\n\
970
"), stream);
971
  fputs_unfiltered (_("\n\
972
For more information, type \"help\" from within GDB, or consult the\n\
973
GDB manual (available as on-line info or a printed manual).\n\
974
Report bugs to \"bug-gdb@gnu.org\".\
975
"), stream);
976
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.