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

Subversion Repositories openrisc

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

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

powered by: WebSVN 2.1.0

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