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

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [gdb/] [top.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Top level stuff for GDB, the GNU debugger.
2
   Copyright 1986-2000 Free Software Foundation, Inc.
3
 
4
   This file is part of GDB.
5
 
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 2 of the License, or
9
   (at your option) any later version.
10
 
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 59 Temple Place - Suite 330,
19
   Boston, MA 02111-1307, USA.  */
20
 
21
#include "defs.h"
22
#include "gdbcmd.h"
23
#include "call-cmds.h"
24
#include "symtab.h"
25
#include "inferior.h"
26
#include "signals.h"
27
#include "target.h"
28
#include "breakpoint.h"
29
#include "gdbtypes.h"
30
#include "expression.h"
31
#include "value.h"
32
#include "language.h"
33
#include "terminal.h"           /* For job_control.  */
34
#include "annotate.h"
35
#include "top.h"
36
#include "version.h"
37
 
38
/* readline include files */
39
#include <readline/readline.h>
40
#include <readline/history.h>
41
 
42
/* readline defines this.  */
43
#undef savestring
44
 
45
#include <sys/types.h>
46
 
47
#include <setjmp.h>
48
 
49
#include "event-top.h"
50
#include "gdb_string.h"
51
#include "gdb_stat.h"
52
#include <ctype.h>
53
#ifdef UI_OUT
54
#include "ui-out.h"
55
#include "cli-out.h"
56
#endif
57
 
58
/* Prototypes for local functions */
59
 
60
static void dont_repeat_command PARAMS ((char *, int));
61
 
62
static void source_cleanup_lines PARAMS ((PTR));
63
 
64
static void user_defined_command PARAMS ((char *, int));
65
 
66
static void init_signals PARAMS ((void));
67
 
68
#ifdef STOP_SIGNAL
69
static void stop_sig PARAMS ((int));
70
#endif
71
 
72
static char *line_completion_function PARAMS ((char *, int, char *, int));
73
 
74
static char *readline_line_completion_function PARAMS ((char *, int));
75
 
76
/* NOTE 1999-04-29: this function will be static again, after we make the
77
   event loop be the default command loop for gdb, and we merge
78
   event-top.c into this file, top.c */
79
/* static */ void command_loop_marker PARAMS ((int));
80
 
81
static void while_command PARAMS ((char *, int));
82
 
83
static void if_command PARAMS ((char *, int));
84
 
85
static struct command_line *
86
  build_command_line PARAMS ((enum command_control_type, char *));
87
 
88
static struct command_line *
89
  get_command_line PARAMS ((enum command_control_type, char *));
90
 
91
static void realloc_body_list PARAMS ((struct command_line *, int));
92
 
93
static enum misc_command_type read_next_line PARAMS ((struct command_line **));
94
 
95
static enum command_control_type
96
recurse_read_control_structure PARAMS ((struct command_line *));
97
 
98
static struct cleanup *setup_user_args PARAMS ((char *));
99
 
100
static char *locate_arg PARAMS ((char *));
101
 
102
static char *insert_args PARAMS ((char *));
103
 
104
static void arg_cleanup PARAMS ((void));
105
 
106
static void init_main PARAMS ((void));
107
 
108
static void init_cmd_lists PARAMS ((void));
109
 
110
static void float_handler PARAMS ((int));
111
 
112
static void init_signals PARAMS ((void));
113
 
114
static void set_verbose PARAMS ((char *, int, struct cmd_list_element *));
115
 
116
static void show_history PARAMS ((char *, int));
117
 
118
static void set_history PARAMS ((char *, int));
119
 
120
static void set_history_size_command PARAMS ((char *, int,
121
                                              struct cmd_list_element *));
122
 
123
static void show_commands PARAMS ((char *, int));
124
 
125
static void echo_command PARAMS ((char *, int));
126
 
127
static void pwd_command PARAMS ((char *, int));
128
 
129
static void show_version PARAMS ((char *, int));
130
 
131
static void document_command PARAMS ((char *, int));
132
 
133
static void define_command PARAMS ((char *, int));
134
 
135
static void validate_comname PARAMS ((char *));
136
 
137
static void help_command PARAMS ((char *, int));
138
 
139
static void show_command PARAMS ((char *, int));
140
 
141
static void info_command PARAMS ((char *, int));
142
 
143
static void complete_command PARAMS ((char *, int));
144
 
145
static void do_nothing PARAMS ((int));
146
 
147
static void show_debug PARAMS ((char *, int));
148
 
149
static void set_debug PARAMS ((char *, int));
150
 
151
#ifdef SIGHUP
152
/* NOTE 1999-04-29: This function will be static again, once we modify
153
   gdb to use the event loop as the default command loop and we merge
154
   event-top.c into this file, top.c */
155
/* static */ int quit_cover PARAMS ((PTR));
156
 
157
static void disconnect PARAMS ((int));
158
#endif
159
 
160
static void source_cleanup PARAMS ((FILE *));
161
 
162
/* Default command line prompt.  This is overriden in some configs. */
163
 
164
#ifndef DEFAULT_PROMPT
165
#define DEFAULT_PROMPT  "(gdb) "
166
#endif
167
 
168
/* Initialization file name for gdb.  This is overridden in some configs.  */
169
 
170
#ifndef GDBINIT_FILENAME
171
#define GDBINIT_FILENAME        ".gdbinit"
172
#endif
173
char gdbinit[] = GDBINIT_FILENAME;
174
 
175
int inhibit_gdbinit = 0;
176
 
177
/* If nonzero, and GDB has been configured to be able to use windows,
178
   attempt to open them upon startup.  */
179
 
180
int use_windows = 1;
181
 
182
extern char lang_frame_mismatch_warn[];         /* language.c */
183
 
184
/* Flag for whether we want all the "from_tty" gubbish printed.  */
185
 
186
int caution = 1;                /* Default is yes, sigh. */
187
 
188
/* Define all cmd_list_elements.  */
189
 
190
/* Chain containing all defined commands.  */
191
 
192
struct cmd_list_element *cmdlist;
193
 
194
/* Chain containing all defined info subcommands.  */
195
 
196
struct cmd_list_element *infolist;
197
 
198
/* Chain containing all defined enable subcommands. */
199
 
200
struct cmd_list_element *enablelist;
201
 
202
/* Chain containing all defined disable subcommands. */
203
 
204
struct cmd_list_element *disablelist;
205
 
206
/* Chain containing all defined toggle subcommands. */
207
 
208
struct cmd_list_element *togglelist;
209
 
210
/* Chain containing all defined stop subcommands. */
211
 
212
struct cmd_list_element *stoplist;
213
 
214
/* Chain containing all defined delete subcommands. */
215
 
216
struct cmd_list_element *deletelist;
217
 
218
/* Chain containing all defined "enable breakpoint" subcommands. */
219
 
220
struct cmd_list_element *enablebreaklist;
221
 
222
/* Chain containing all defined set subcommands */
223
 
224
struct cmd_list_element *setlist;
225
 
226
/* Chain containing all defined unset subcommands */
227
 
228
struct cmd_list_element *unsetlist;
229
 
230
/* Chain containing all defined show subcommands.  */
231
 
232
struct cmd_list_element *showlist;
233
 
234
/* Chain containing all defined \"set history\".  */
235
 
236
struct cmd_list_element *sethistlist;
237
 
238
/* Chain containing all defined \"show history\".  */
239
 
240
struct cmd_list_element *showhistlist;
241
 
242
/* Chain containing all defined \"unset history\".  */
243
 
244
struct cmd_list_element *unsethistlist;
245
 
246
/* Chain containing all defined maintenance subcommands. */
247
 
248
struct cmd_list_element *maintenancelist;
249
 
250
/* Chain containing all defined "maintenance info" subcommands. */
251
 
252
struct cmd_list_element *maintenanceinfolist;
253
 
254
/* Chain containing all defined "maintenance print" subcommands. */
255
 
256
struct cmd_list_element *maintenanceprintlist;
257
 
258
struct cmd_list_element *setprintlist;
259
 
260
struct cmd_list_element *showprintlist;
261
 
262
struct cmd_list_element *setdebuglist;
263
 
264
struct cmd_list_element *showdebuglist;
265
 
266
struct cmd_list_element *setchecklist;
267
 
268
struct cmd_list_element *showchecklist;
269
 
270
/* stdio stream that command input is being read from.  Set to stdin normally.
271
   Set by source_command to the file we are sourcing.  Set to NULL if we are
272
   executing a user-defined command or interacting via a GUI.  */
273
 
274
FILE *instream;
275
 
276
/* Current working directory.  */
277
 
278
char *current_directory;
279
 
280
/* The directory name is actually stored here (usually).  */
281
char gdb_dirbuf[1024];
282
 
283
/* Function to call before reading a command, if nonzero.
284
   The function receives two args: an input stream,
285
   and a prompt string.  */
286
 
287
void (*window_hook) PARAMS ((FILE *, char *));
288
 
289
int epoch_interface;
290
int xgdb_verbose;
291
 
292
/* gdb prints this when reading a command interactively */
293
static char *gdb_prompt_string; /* the global prompt string */
294
extern char *get_prompt PARAMS ((void));        /* access function for prompt string */
295
 
296
/* Buffer used for reading command lines, and the size
297
   allocated for it so far.  */
298
 
299
char *line;
300
int linesize = 100;
301
 
302
/* Nonzero if the current command is modified by "server ".  This
303
   affects things like recording into the command history, commands
304
   repeating on RETURN, etc.  This is so a user interface (emacs, GUI,
305
   whatever) can issue its own commands and also send along commands
306
   from the user, and have the user not notice that the user interface
307
   is issuing commands too.  */
308
int server_command;
309
 
310
/* Baud rate specified for talking to serial target systems.  Default
311
   is left as -1, so targets can choose their own defaults.  */
312
/* FIXME: This means that "show remotebaud" and gr_files_info can print -1
313
   or (unsigned int)-1.  This is a Bad User Interface.  */
314
 
315
int baud_rate = -1;
316
 
317
/* Timeout limit for response from target. */
318
 
319
/* The default value has been changed many times over the years.  It
320
   was originally 5 seconds.  But that was thought to be a long time
321
   to sit and wait, so it was changed to 2 seconds.  That was thought
322
   to be plenty unless the connection was going through some terminal
323
   server or multiplexer or other form of hairy serial connection.
324
 
325
   In mid-1996, remote_timeout was moved from remote.c to top.c and
326
   it began being used in other remote-* targets.  It appears that the
327
   default was changed to 20 seconds at that time, perhaps because the
328
   Hitachi E7000 ICE didn't always respond in a timely manner.
329
 
330
   But if 5 seconds is a long time to sit and wait for retransmissions,
331
   20 seconds is far worse.  This demonstrates the difficulty of using
332
   a single variable for all protocol timeouts.
333
 
334
   As remote.c is used much more than remote-e7000.c, it was changed
335
   back to 2 seconds in 1999. */
336
 
337
int remote_timeout = 2;
338
 
339
/* Non-zero tells remote* modules to output debugging info.  */
340
 
341
int remote_debug = 0;
342
 
343
/* Non-zero means the target is running. Note: this is different from
344
   saying that there is an active target and we are stopped at a
345
   breakpoint, for instance. This is a real indicator whether the
346
   target is off and running, which gdb is doing something else. */
347
int target_executing = 0;
348
 
349
/* Level of control structure.  */
350
static int control_level;
351
 
352
/* Structure for arguments to user defined functions.  */
353
#define MAXUSERARGS 10
354
struct user_args
355
  {
356
    struct user_args *next;
357
    struct
358
      {
359
        char *arg;
360
        int len;
361
      }
362
    a[MAXUSERARGS];
363
    int count;
364
  }
365
 *user_args;
366
 
367
/* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT.  */
368
 
369
#ifndef STOP_SIGNAL
370
#ifdef SIGTSTP
371
#define STOP_SIGNAL SIGTSTP
372
static void stop_sig PARAMS ((int));
373
#endif
374
#endif
375
 
376
/* Some System V have job control but not sigsetmask(). */
377
#if !defined (HAVE_SIGSETMASK)
378
#if !defined (USG)
379
#define HAVE_SIGSETMASK 1
380
#else
381
#define HAVE_SIGSETMASK 0
382
#endif
383
#endif
384
 
385
#if 0 == (HAVE_SIGSETMASK)
386
#define sigsetmask(n)
387
#endif
388
 
389
/* Hooks for alternate command interfaces.  */
390
 
391
/* Called after most modules have been initialized, but before taking users
392
   command file.  */
393
 
394
void (*init_ui_hook) PARAMS ((char *argv0));
395
 
396
/* This hook is called from within gdb's many mini-event loops which could
397
   steal control from a real user interface's event loop. It returns
398
   non-zero if the user is requesting a detach, zero otherwise. */
399
 
400
int (*ui_loop_hook) PARAMS ((int));
401
 
402
/* Called instead of command_loop at top level.  Can be invoked via
403
   return_to_top_level.  */
404
 
405
void (*command_loop_hook) PARAMS ((void));
406
 
407
 
408
/* Called from print_frame_info to list the line we stopped in.  */
409
 
410
void (*print_frame_info_listing_hook) PARAMS ((struct symtab * s, int line,
411
                                               int stopline, int noerror));
412
/* Replaces most of query.  */
413
 
414
int (*query_hook) PARAMS ((const char *, va_list));
415
 
416
/* Replaces most of warning.  */
417
 
418
void (*warning_hook) PARAMS ((const char *, va_list));
419
 
420
/* These three functions support getting lines of text from the user.  They
421
   are used in sequence.  First readline_begin_hook is called with a text
422
   string that might be (for example) a message for the user to type in a
423
   sequence of commands to be executed at a breakpoint.  If this function
424
   calls back to a GUI, it might take this opportunity to pop up a text
425
   interaction window with this message.  Next, readline_hook is called
426
   with a prompt that is emitted prior to collecting the user input.
427
   It can be called multiple times.  Finally, readline_end_hook is called
428
   to notify the GUI that we are done with the interaction window and it
429
   can close it. */
430
 
431
void (*readline_begin_hook) PARAMS ((char *,...));
432
char *(*readline_hook) PARAMS ((char *));
433
void (*readline_end_hook) PARAMS ((void));
434
 
435
/* Called as appropriate to notify the interface of the specified breakpoint
436
   conditions.  */
437
 
438
void (*create_breakpoint_hook) PARAMS ((struct breakpoint * bpt));
439
void (*delete_breakpoint_hook) PARAMS ((struct breakpoint * bpt));
440
void (*modify_breakpoint_hook) PARAMS ((struct breakpoint * bpt));
441
 
442
/* Called as appropriate to notify the interface that we have attached
443
   to or detached from an already running process. */
444
 
445
void (*attach_hook) PARAMS ((void));
446
void (*detach_hook) PARAMS ((void));
447
 
448
/* Called during long calculations to allow GUI to repair window damage, and to
449
   check for stop buttons, etc... */
450
 
451
void (*interactive_hook) PARAMS ((void));
452
 
453
/* Called when the registers have changed, as a hint to a GUI
454
   to minimize window update. */
455
 
456
void (*registers_changed_hook) PARAMS ((void));
457
 
458
/* Tell the GUI someone changed the register REGNO. -1 means
459
   that the caller does not know which register changed or
460
   that several registers have changed (see value_assign). */
461
void (*register_changed_hook) PARAMS ((int regno));
462
 
463
/* Tell the GUI someone changed LEN bytes of memory at ADDR */
464
void (*memory_changed_hook) PARAMS ((CORE_ADDR addr, int len));
465
 
466
/* Called when going to wait for the target.  Usually allows the GUI to run
467
   while waiting for target events.  */
468
 
469
int (*target_wait_hook) PARAMS ((int pid, struct target_waitstatus * status));
470
 
471
/* Used by UI as a wrapper around command execution.  May do various things
472
   like enabling/disabling buttons, etc...  */
473
 
474
void (*call_command_hook) PARAMS ((struct cmd_list_element * c, char *cmd,
475
                                   int from_tty));
476
 
477
/* Called after a `set' command has finished.  Is only run if the
478
   `set' command succeeded.  */
479
 
480
void (*set_hook) (struct cmd_list_element * c);
481
 
482
/* Called when the current thread changes.  Argument is thread id.  */
483
 
484
void (*context_hook) PARAMS ((int id));
485
 
486
/* Takes control from error ().  Typically used to prevent longjmps out of the
487
   middle of the GUI.  Usually used in conjunction with a catch routine.  */
488
 
489
NORETURN void (*error_hook) (void) ATTR_NORETURN;
490
 
491
 
492
/* One should use catch_errors rather than manipulating these
493
   directly.  */
494
#if defined(HAVE_SIGSETJMP)
495
#define SIGJMP_BUF              sigjmp_buf
496
#define SIGSETJMP(buf)          sigsetjmp(buf, 1)
497
#define SIGLONGJMP(buf,val)     siglongjmp(buf,val)
498
#else
499
#define SIGJMP_BUF              jmp_buf
500
#define SIGSETJMP(buf)          setjmp(buf)
501
#define SIGLONGJMP(buf,val)     longjmp(buf,val)
502
#endif
503
 
504
/* Where to go for return_to_top_level.  */
505
static SIGJMP_BUF *catch_return;
506
 
507
/* Return for reason REASON to the nearest containing catch_errors().  */
508
 
509
NORETURN void
510
return_to_top_level (reason)
511
     enum return_reason reason;
512
{
513
  quit_flag = 0;
514
  immediate_quit = 0;
515
 
516
  /* Perhaps it would be cleaner to do this via the cleanup chain (not sure
517
     I can think of a reason why that is vital, though).  */
518
  bpstat_clear_actions (stop_bpstat);   /* Clear queued breakpoint commands */
519
 
520
  disable_current_display ();
521
  do_cleanups (ALL_CLEANUPS);
522
  if (event_loop_p && target_can_async_p () && !target_executing)
523
    do_exec_cleanups (ALL_CLEANUPS);
524
  if (event_loop_p && sync_execution)
525
    do_exec_error_cleanups (ALL_CLEANUPS);
526
 
527
  if (annotation_level > 1)
528
    switch (reason)
529
      {
530
      case RETURN_QUIT:
531
        annotate_quit ();
532
        break;
533
      case RETURN_ERROR:
534
        annotate_error ();
535
        break;
536
      }
537
 
538
  /* Jump to the containing catch_errors() call, communicating REASON
539
     to that call via setjmp's return value.  Note that REASON can't
540
     be zero, by definition in defs.h. */
541
 
542
  (NORETURN void) SIGLONGJMP (*catch_return, (int) reason);
543
}
544
 
545
/* Call FUNC with arg ARGS, catching any errors.  If there is no
546
   error, return the value returned by FUNC.  If there is an error,
547
   print ERRSTRING, print the specific error message, then return
548
   zero.
549
 
550
   Must not be called with immediate_quit in effect (bad things might
551
   happen, say we got a signal in the middle of a memcpy to quit_return).
552
   This is an OK restriction; with very few exceptions immediate_quit can
553
   be replaced by judicious use of QUIT.
554
 
555
   MASK specifies what to catch; it is normally set to
556
   RETURN_MASK_ALL, if for no other reason than that the code which
557
   calls catch_errors might not be set up to deal with a quit which
558
   isn't caught.  But if the code can deal with it, it generally
559
   should be RETURN_MASK_ERROR, unless for some reason it is more
560
   useful to abort only the portion of the operation inside the
561
   catch_errors.  Note that quit should return to the command line
562
   fairly quickly, even if some further processing is being done.  */
563
 
564
/* MAYBE: cagney/1999-11-05: catch_errors() in conjunction with
565
   error() et.al. could maintain a set of flags that indicate the the
566
   current state of each of the longjmp buffers.  This would give the
567
   longjmp code the chance to detect a longjmp botch (before it gets
568
   to longjmperror()).  Prior to 1999-11-05 this wasn't possible as
569
   code also randomly used a SET_TOP_LEVEL macro that directly
570
   initialize the longjmp buffers. */
571
 
572
/* MAYBE: cagney/1999-11-05: Should the catch_erros and cleanups code
573
   be consolidated into a single file instead of being distributed
574
   between utils.c and top.c? */
575
 
576
int
577
catch_errors (func, args, errstring, mask)
578
     catch_errors_ftype *func;
579
     PTR args;
580
     char *errstring;
581
     return_mask mask;
582
{
583
  SIGJMP_BUF *saved_catch;
584
  SIGJMP_BUF catch;
585
  int val;
586
  struct cleanup *saved_cleanup_chain;
587
  char *saved_error_pre_print;
588
  char *saved_quit_pre_print;
589
 
590
  /* Return value from SIGSETJMP(): enum return_reason if error or
591
     quit caught, 0 otherwise. */
592
  int caught;
593
 
594
  /* Override error/quit messages during FUNC. */
595
 
596
  saved_error_pre_print = error_pre_print;
597
  saved_quit_pre_print = quit_pre_print;
598
 
599
  if (mask & RETURN_MASK_ERROR)
600
    error_pre_print = errstring;
601
  if (mask & RETURN_MASK_QUIT)
602
    quit_pre_print = errstring;
603
 
604
  /* Prevent error/quit during FUNC from calling cleanups established
605
     prior to here. */
606
 
607
  saved_cleanup_chain = save_cleanups ();
608
 
609
  /* Call FUNC, catching error/quit events. */
610
 
611
  saved_catch = catch_return;
612
  catch_return = &catch;
613
  caught = SIGSETJMP (catch);
614
  if (!caught)
615
    val = (*func) (args);
616
  catch_return = saved_catch;
617
 
618
  /* FIXME: cagney/1999-11-05: A correct FUNC implementaton will
619
     clean things up (restoring the cleanup chain) to the state they
620
     were just prior to the call.  Unfortunatly, many FUNC's are not
621
     that well behaved.  This could be fixed by adding either a
622
     do_cleanups call (to cover the problem) or an assertion check to
623
     detect bad FUNCs code. */
624
 
625
  /* Restore the cleanup chain and error/quit messages to their
626
     original states. */
627
 
628
  restore_cleanups (saved_cleanup_chain);
629
 
630
  if (mask & RETURN_MASK_QUIT)
631
    quit_pre_print = saved_quit_pre_print;
632
  if (mask & RETURN_MASK_ERROR)
633
    error_pre_print = saved_error_pre_print;
634
 
635
  /* Return normally if no error/quit event occurred. */
636
 
637
  if (!caught)
638
    return val;
639
 
640
  /* If the caller didn't request that the event be caught, relay the
641
     event to the next containing catch_errors(). */
642
 
643
  if (!(mask & RETURN_MASK (caught)))
644
    return_to_top_level (caught);
645
 
646
  /* Tell the caller that an event was caught.
647
 
648
     FIXME: nsd/2000-02-22: When MASK is RETURN_MASK_ALL, the caller
649
     can't tell what type of event occurred.
650
 
651
     A possible fix is to add a new interface, catch_event(), that
652
     returns enum return_reason after catching an error or a quit.
653
 
654
     When returning normally, i.e. without catching an error or a
655
     quit, catch_event() could return RETURN_NORMAL, which would be
656
     added to enum return_reason.  FUNC would return information
657
     exclusively via ARGS.
658
 
659
     Alternatively, normal catch_event() could return FUNC's return
660
     value.  The caller would need to be aware of potential overlap
661
     with enum return_reason, which could be publicly restricted to
662
     negative values to simplify return value processing in FUNC and
663
     in the caller. */
664
 
665
  return 0;
666
}
667
 
668
struct captured_command_args
669
  {
670
    catch_command_errors_ftype *command;
671
    char *arg;
672
    int from_tty;
673
  };
674
 
675
static int
676
do_captured_command (void *data)
677
{
678
  struct captured_command_args *context = data;
679
  context->command (context->arg, context->from_tty);
680
  /* FIXME: cagney/1999-11-07: Technically this do_cleanups() call
681
     isn't needed.  Instead an assertion check could be made that
682
     simply confirmed that the called function correctly cleaned up
683
     after its self.  Unfortunatly, old code (prior to 1999-11-04) in
684
     main.c was calling SET_TOP_LEVEL(), calling the command function,
685
     and then *always* calling do_cleanups().  For the moment we
686
     remain ``bug compatible'' with that old code..  */
687
  do_cleanups (ALL_CLEANUPS);
688
  return 1;
689
}
690
 
691
int
692
catch_command_errors (catch_command_errors_ftype * command,
693
                      char *arg, int from_tty, return_mask mask)
694
{
695
  struct captured_command_args args;
696
  args.command = command;
697
  args.arg = arg;
698
  args.from_tty = from_tty;
699
  return catch_errors (do_captured_command, &args, "", mask);
700
}
701
 
702
 
703
/* Handler for SIGHUP.  */
704
 
705
#ifdef SIGHUP
706
static void
707
disconnect (signo)
708
     int signo;
709
{
710
  catch_errors (quit_cover, NULL,
711
              "Could not kill the program being debugged", RETURN_MASK_ALL);
712
  signal (SIGHUP, SIG_DFL);
713
  kill (getpid (), SIGHUP);
714
}
715
 
716
/* Just a little helper function for disconnect().  */
717
 
718
/* NOTE 1999-04-29: This function will be static again, once we modify
719
   gdb to use the event loop as the default command loop and we merge
720
   event-top.c into this file, top.c */
721
/* static */ int
722
quit_cover (s)
723
     PTR s;
724
{
725
  caution = 0;                   /* Throw caution to the wind -- we're exiting.
726
                                   This prevents asking the user dumb questions.  */
727
  quit_command ((char *) 0, 0);
728
  return 0;
729
}
730
#endif /* defined SIGHUP */
731
 
732
/* Line number we are currently in in a file which is being sourced.  */
733
/* NOTE 1999-04-29: This variable will be static again, once we modify
734
   gdb to use the event loop as the default command loop and we merge
735
   event-top.c into this file, top.c */
736
/* static */ int source_line_number;
737
 
738
/* Name of the file we are sourcing.  */
739
/* NOTE 1999-04-29: This variable will be static again, once we modify
740
   gdb to use the event loop as the default command loop and we merge
741
   event-top.c into this file, top.c */
742
/* static */ char *source_file_name;
743
 
744
/* Buffer containing the error_pre_print used by the source stuff.
745
   Malloc'd.  */
746
/* NOTE 1999-04-29: This variable will be static again, once we modify
747
   gdb to use the event loop as the default command loop and we merge
748
   event-top.c into this file, top.c */
749
/* static */ char *source_error;
750
static int source_error_allocated;
751
 
752
/* Something to glom on to the start of error_pre_print if source_file_name
753
   is set.  */
754
/* NOTE 1999-04-29: This variable will be static again, once we modify
755
   gdb to use the event loop as the default command loop and we merge
756
   event-top.c into this file, top.c */
757
/* static */ char *source_pre_error;
758
 
759
/* Clean up on error during a "source" command (or execution of a
760
   user-defined command).  */
761
 
762
static void
763
source_cleanup (stream)
764
     FILE *stream;
765
{
766
  /* Restore the previous input stream.  */
767
  instream = stream;
768
}
769
 
770
/* Read commands from STREAM.  */
771
void
772
read_command_file (stream)
773
     FILE *stream;
774
{
775
  struct cleanup *cleanups;
776
 
777
  cleanups = make_cleanup ((make_cleanup_func) source_cleanup, instream);
778
  instream = stream;
779
  command_loop ();
780
  do_cleanups (cleanups);
781
}
782
 
783
extern void init_proc PARAMS ((void));
784
 
785
void (*pre_init_ui_hook) PARAMS ((void));
786
 
787
void
788
gdb_init (argv0)
789
     char *argv0;
790
{
791
  if (pre_init_ui_hook)
792
    pre_init_ui_hook ();
793
 
794
  /* Run the init function of each source file */
795
 
796
  getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
797
  current_directory = gdb_dirbuf;
798
 
799
#ifdef __MSDOS__
800
  /* Make sure we return to the original directory upon exit, come
801
     what may, since the OS doesn't do that for us.  */
802
  make_final_cleanup ((make_cleanup_func) chdir, strsave (current_directory));
803
#endif
804
 
805
  init_cmd_lists ();            /* This needs to be done first */
806
  initialize_targets ();        /* Setup target_terminal macros for utils.c */
807
  initialize_utils ();          /* Make errors and warnings possible */
808
  initialize_all_files ();
809
  initialize_current_architecture ();
810
  init_main ();                 /* But that omits this file!  Do it now */
811
 
812
  /* The signal handling mechanism is different depending whether or
813
     not the async version is run. NOTE: in the future we plan to make
814
     the event loop be the default engine of gdb, and this difference
815
     will disappear. */
816
  if (event_loop_p)
817
    async_init_signals ();
818
  else
819
    init_signals ();
820
 
821
  /* We need a default language for parsing expressions, so simple things like
822
     "set width 0" won't fail if no language is explicitly set in a config file
823
     or implicitly set by reading an executable during startup. */
824
  set_language (language_c);
825
  expected_language = current_language;         /* don't warn about the change.  */
826
 
827
#ifdef UI_OUT
828
  /* Install the default UI */
829
  uiout = cli_out_new (gdb_stdout);
830
#endif
831
 
832
#ifdef UI_OUT
833
  /* All the interpreters should have had a look at things by now.
834
     Initialize the selected interpreter. */
835
  if (interpreter_p && !init_ui_hook)
836
    {
837
      fprintf_unfiltered (gdb_stderr, "Interpreter `%s' unrecognized.\n",
838
                          interpreter_p);
839
      exit (1);
840
    }
841
#endif
842
 
843
  if (init_ui_hook)
844
    init_ui_hook (argv0);
845
}
846
 
847
/* Allocate, initialize a new command line structure for one of the
848
   control commands (if/while).  */
849
 
850
static struct command_line *
851
build_command_line (type, args)
852
     enum command_control_type type;
853
     char *args;
854
{
855
  struct command_line *cmd;
856
 
857
  if (args == NULL)
858
    error ("if/while commands require arguments.\n");
859
 
860
  cmd = (struct command_line *) xmalloc (sizeof (struct command_line));
861
  cmd->next = NULL;
862
  cmd->control_type = type;
863
 
864
  cmd->body_count = 1;
865
  cmd->body_list
866
    = (struct command_line **) xmalloc (sizeof (struct command_line *)
867
                                        * cmd->body_count);
868
  memset (cmd->body_list, 0, sizeof (struct command_line *) * cmd->body_count);
869
  cmd->line = savestring (args, strlen (args));
870
  return cmd;
871
}
872
 
873
/* Build and return a new command structure for the control commands
874
   such as "if" and "while".  */
875
 
876
static struct command_line *
877
get_command_line (type, arg)
878
     enum command_control_type type;
879
     char *arg;
880
{
881
  struct command_line *cmd;
882
  struct cleanup *old_chain = NULL;
883
 
884
  /* Allocate and build a new command line structure.  */
885
  cmd = build_command_line (type, arg);
886
 
887
  old_chain = make_cleanup ((make_cleanup_func) free_command_lines, &cmd);
888
 
889
  /* Read in the body of this command.  */
890
  if (recurse_read_control_structure (cmd) == invalid_control)
891
    {
892
      warning ("error reading in control structure\n");
893
      do_cleanups (old_chain);
894
      return NULL;
895
    }
896
 
897
  discard_cleanups (old_chain);
898
  return cmd;
899
}
900
 
901
/* Recursively print a command (including full control structures).  */
902
#ifdef UI_OUT
903
void
904
print_command_lines (uiout, cmd, depth)
905
     struct ui_out *uiout;
906
     struct command_line *cmd;
907
     unsigned int depth;
908
{
909
  struct command_line *list;
910
 
911
  list = cmd;
912
  while (list)
913
    {
914
 
915
      if (depth)
916
        ui_out_spaces (uiout, 2 * depth);
917
 
918
      /* A simple command, print it and continue.  */
919
      if (list->control_type == simple_control)
920
        {
921
          ui_out_field_string (uiout, NULL, list->line);
922
          ui_out_text (uiout, "\n");
923
          list = list->next;
924
          continue;
925
        }
926
 
927
      /* loop_continue to jump to the start of a while loop, print it
928
         and continue. */
929
      if (list->control_type == continue_control)
930
        {
931
          ui_out_field_string (uiout, NULL, "loop_continue");
932
          ui_out_text (uiout, "\n");
933
          list = list->next;
934
          continue;
935
        }
936
 
937
      /* loop_break to break out of a while loop, print it and continue.  */
938
      if (list->control_type == break_control)
939
        {
940
          ui_out_field_string (uiout, NULL, "loop_break");
941
          ui_out_text (uiout, "\n");
942
          list = list->next;
943
          continue;
944
        }
945
 
946
      /* A while command.  Recursively print its subcommands and continue.  */
947
      if (list->control_type == while_control)
948
        {
949
          ui_out_text (uiout, "while ");
950
          ui_out_field_fmt (uiout, NULL, "while %s", list->line);
951
          ui_out_text (uiout, "\n");
952
          print_command_lines (uiout, *list->body_list, depth + 1);
953
          ui_out_field_string (uiout, NULL, "end");
954
          if (depth)
955
            ui_out_spaces (uiout, 2 * depth);
956
          ui_out_text (uiout, "end\n");
957
          list = list->next;
958
          continue;
959
        }
960
 
961
      /* An if command.  Recursively print both arms before continueing.  */
962
      if (list->control_type == if_control)
963
        {
964
          ui_out_text (uiout, "if ");
965
          ui_out_field_fmt (uiout, NULL, "if %s", list->line);
966
          ui_out_text (uiout, "\n");
967
          /* The true arm. */
968
          print_command_lines (uiout, list->body_list[0], depth + 1);
969
 
970
          /* Show the false arm if it exists.  */
971
          if (list->body_count == 2)
972
            {
973
              if (depth)
974
                ui_out_spaces (uiout, 2 * depth);
975
              ui_out_field_string (uiout, NULL, "else");
976
              ui_out_text (uiout, "else\n");
977
              print_command_lines (uiout, list->body_list[1], depth + 1);
978
            }
979
 
980
          ui_out_field_string (uiout, NULL, "end");
981
          if (depth)
982
            ui_out_spaces (uiout, 2 * depth);
983
          ui_out_text (uiout, "end\n");
984
          list = list->next;
985
          continue;
986
        }
987
 
988
      /* ignore illegal command type and try next */
989
      list = list->next;
990
    }                           /* while (list) */
991
}
992
#else
993
void
994
print_command_line (cmd, depth, stream)
995
     struct command_line *cmd;
996
     unsigned int depth;
997
     struct ui_file *stream;
998
{
999
  unsigned int i;
1000
 
1001
  if (depth)
1002
    {
1003
      for (i = 0; i < depth; i++)
1004
        fputs_filtered ("  ", stream);
1005
    }
1006
 
1007
  /* A simple command, print it and return.  */
1008
  if (cmd->control_type == simple_control)
1009
    {
1010
      fputs_filtered (cmd->line, stream);
1011
      fputs_filtered ("\n", stream);
1012
      return;
1013
    }
1014
 
1015
  /* loop_continue to jump to the start of a while loop, print it
1016
     and return. */
1017
  if (cmd->control_type == continue_control)
1018
    {
1019
      fputs_filtered ("loop_continue\n", stream);
1020
      return;
1021
    }
1022
 
1023
  /* loop_break to break out of a while loop, print it and return.  */
1024
  if (cmd->control_type == break_control)
1025
    {
1026
      fputs_filtered ("loop_break\n", stream);
1027
      return;
1028
    }
1029
 
1030
  /* A while command.  Recursively print its subcommands before returning.  */
1031
  if (cmd->control_type == while_control)
1032
    {
1033
      struct command_line *list;
1034
      fputs_filtered ("while ", stream);
1035
      fputs_filtered (cmd->line, stream);
1036
      fputs_filtered ("\n", stream);
1037
      list = *cmd->body_list;
1038
      while (list)
1039
        {
1040
          print_command_line (list, depth + 1, stream);
1041
          list = list->next;
1042
        }
1043
    }
1044
 
1045
  /* An if command.  Recursively print both arms before returning.  */
1046
  if (cmd->control_type == if_control)
1047
    {
1048
      fputs_filtered ("if ", stream);
1049
      fputs_filtered (cmd->line, stream);
1050
      fputs_filtered ("\n", stream);
1051
      /* The true arm. */
1052
      print_command_line (cmd->body_list[0], depth + 1, stream);
1053
 
1054
      /* Show the false arm if it exists.  */
1055
      if (cmd->body_count == 2)
1056
        {
1057
          if (depth)
1058
            {
1059
              for (i = 0; i < depth; i++)
1060
                fputs_filtered ("  ", stream);
1061
            }
1062
          fputs_filtered ("else\n", stream);
1063
          print_command_line (cmd->body_list[1], depth + 1, stream);
1064
        }
1065
      if (depth)
1066
        {
1067
          for (i = 0; i < depth; i++)
1068
            fputs_filtered ("  ", stream);
1069
        }
1070
      fputs_filtered ("end\n", stream);
1071
    }
1072
}
1073
#endif
1074
 
1075
/* Execute the command in CMD.  */
1076
 
1077
enum command_control_type
1078
execute_control_command (cmd)
1079
     struct command_line *cmd;
1080
{
1081
  struct expression *expr;
1082
  struct command_line *current;
1083
  struct cleanup *old_chain = 0;
1084
  value_ptr val;
1085
  value_ptr val_mark;
1086
  int loop;
1087
  enum command_control_type ret;
1088
  char *new_line;
1089
 
1090
  switch (cmd->control_type)
1091
    {
1092
    case simple_control:
1093
      /* A simple command, execute it and return.  */
1094
      new_line = insert_args (cmd->line);
1095
      if (!new_line)
1096
        return invalid_control;
1097
      old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
1098
                                &new_line);
1099
      execute_command (new_line, 0);
1100
      ret = cmd->control_type;
1101
      break;
1102
 
1103
    case continue_control:
1104
    case break_control:
1105
      /* Return for "continue", and "break" so we can either
1106
         continue the loop at the top, or break out.  */
1107
      ret = cmd->control_type;
1108
      break;
1109
 
1110
    case while_control:
1111
      {
1112
        /* Parse the loop control expression for the while statement.  */
1113
        new_line = insert_args (cmd->line);
1114
        if (!new_line)
1115
          return invalid_control;
1116
        old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
1117
                                  &new_line);
1118
        expr = parse_expression (new_line);
1119
        make_cleanup ((make_cleanup_func) free_current_contents, &expr);
1120
 
1121
        ret = simple_control;
1122
        loop = 1;
1123
 
1124
        /* Keep iterating so long as the expression is true.  */
1125
        while (loop == 1)
1126
          {
1127
            int cond_result;
1128
 
1129
            QUIT;
1130
 
1131
            /* Evaluate the expression.  */
1132
            val_mark = value_mark ();
1133
            val = evaluate_expression (expr);
1134
            cond_result = value_true (val);
1135
            value_free_to_mark (val_mark);
1136
 
1137
            /* If the value is false, then break out of the loop.  */
1138
            if (!cond_result)
1139
              break;
1140
 
1141
            /* Execute the body of the while statement.  */
1142
            current = *cmd->body_list;
1143
            while (current)
1144
              {
1145
                ret = execute_control_command (current);
1146
 
1147
                /* If we got an error, or a "break" command, then stop
1148
                   looping.  */
1149
                if (ret == invalid_control || ret == break_control)
1150
                  {
1151
                    loop = 0;
1152
                    break;
1153
                  }
1154
 
1155
                /* If we got a "continue" command, then restart the loop
1156
                   at this point.  */
1157
                if (ret == continue_control)
1158
                  break;
1159
 
1160
                /* Get the next statement.  */
1161
                current = current->next;
1162
              }
1163
          }
1164
 
1165
        /* Reset RET so that we don't recurse the break all the way down.  */
1166
        if (ret == break_control)
1167
          ret = simple_control;
1168
 
1169
        break;
1170
      }
1171
 
1172
    case if_control:
1173
      {
1174
        new_line = insert_args (cmd->line);
1175
        if (!new_line)
1176
          return invalid_control;
1177
        old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
1178
                                  &new_line);
1179
        /* Parse the conditional for the if statement.  */
1180
        expr = parse_expression (new_line);
1181
        make_cleanup ((make_cleanup_func) free_current_contents, &expr);
1182
 
1183
        current = NULL;
1184
        ret = simple_control;
1185
 
1186
        /* Evaluate the conditional.  */
1187
        val_mark = value_mark ();
1188
        val = evaluate_expression (expr);
1189
 
1190
        /* Choose which arm to take commands from based on the value of the
1191
           conditional expression.  */
1192
        if (value_true (val))
1193
          current = *cmd->body_list;
1194
        else if (cmd->body_count == 2)
1195
          current = *(cmd->body_list + 1);
1196
        value_free_to_mark (val_mark);
1197
 
1198
        /* Execute commands in the given arm.  */
1199
        while (current)
1200
          {
1201
            ret = execute_control_command (current);
1202
 
1203
            /* If we got an error, get out.  */
1204
            if (ret != simple_control)
1205
              break;
1206
 
1207
            /* Get the next statement in the body.  */
1208
            current = current->next;
1209
          }
1210
 
1211
        break;
1212
      }
1213
 
1214
    default:
1215
      warning ("Invalid control type in command structure.");
1216
      return invalid_control;
1217
    }
1218
 
1219
  if (old_chain)
1220
    do_cleanups (old_chain);
1221
 
1222
  return ret;
1223
}
1224
 
1225
/* "while" command support.  Executes a body of statements while the
1226
   loop condition is nonzero.  */
1227
 
1228
static void
1229
while_command (arg, from_tty)
1230
     char *arg;
1231
     int from_tty;
1232
{
1233
  struct command_line *command = NULL;
1234
 
1235
  control_level = 1;
1236
  command = get_command_line (while_control, arg);
1237
 
1238
  if (command == NULL)
1239
    return;
1240
 
1241
  execute_control_command (command);
1242
  free_command_lines (&command);
1243
}
1244
 
1245
/* "if" command support.  Execute either the true or false arm depending
1246
   on the value of the if conditional.  */
1247
 
1248
static void
1249
if_command (arg, from_tty)
1250
     char *arg;
1251
     int from_tty;
1252
{
1253
  struct command_line *command = NULL;
1254
 
1255
  control_level = 1;
1256
  command = get_command_line (if_control, arg);
1257
 
1258
  if (command == NULL)
1259
    return;
1260
 
1261
  execute_control_command (command);
1262
  free_command_lines (&command);
1263
}
1264
 
1265
/* Cleanup */
1266
static void
1267
arg_cleanup ()
1268
{
1269
  struct user_args *oargs = user_args;
1270
  if (!user_args)
1271
    internal_error ("Internal error, arg_cleanup called with no user args.\n");
1272
 
1273
  user_args = user_args->next;
1274
  free (oargs);
1275
}
1276
 
1277
/* Bind the incomming arguments for a user defined command to
1278
   $arg0, $arg1 ... $argMAXUSERARGS.  */
1279
 
1280
static struct cleanup *
1281
setup_user_args (p)
1282
     char *p;
1283
{
1284
  struct user_args *args;
1285
  struct cleanup *old_chain;
1286
  unsigned int arg_count = 0;
1287
 
1288
  args = (struct user_args *) xmalloc (sizeof (struct user_args));
1289
  memset (args, 0, sizeof (struct user_args));
1290
 
1291
  args->next = user_args;
1292
  user_args = args;
1293
 
1294
  old_chain = make_cleanup ((make_cleanup_func) arg_cleanup, 0);
1295
 
1296
  if (p == NULL)
1297
    return old_chain;
1298
 
1299
  while (*p)
1300
    {
1301
      char *start_arg;
1302
      int squote = 0;
1303
      int dquote = 0;
1304
      int bsquote = 0;
1305
 
1306
      if (arg_count >= MAXUSERARGS)
1307
        {
1308
          error ("user defined function may only have %d arguments.\n",
1309
                 MAXUSERARGS);
1310
          return old_chain;
1311
        }
1312
 
1313
      /* Strip whitespace.  */
1314
      while (*p == ' ' || *p == '\t')
1315
        p++;
1316
 
1317
      /* P now points to an argument.  */
1318
      start_arg = p;
1319
      user_args->a[arg_count].arg = p;
1320
 
1321
      /* Get to the end of this argument.  */
1322
      while (*p)
1323
        {
1324
          if (((*p == ' ' || *p == '\t')) && !squote && !dquote && !bsquote)
1325
            break;
1326
          else
1327
            {
1328
              if (bsquote)
1329
                bsquote = 0;
1330
              else if (*p == '\\')
1331
                bsquote = 1;
1332
              else if (squote)
1333
                {
1334
                  if (*p == '\'')
1335
                    squote = 0;
1336
                }
1337
              else if (dquote)
1338
                {
1339
                  if (*p == '"')
1340
                    dquote = 0;
1341
                }
1342
              else
1343
                {
1344
                  if (*p == '\'')
1345
                    squote = 1;
1346
                  else if (*p == '"')
1347
                    dquote = 1;
1348
                }
1349
              p++;
1350
            }
1351
        }
1352
 
1353
      user_args->a[arg_count].len = p - start_arg;
1354
      arg_count++;
1355
      user_args->count++;
1356
    }
1357
  return old_chain;
1358
}
1359
 
1360
/* Given character string P, return a point to the first argument ($arg),
1361
   or NULL if P contains no arguments.  */
1362
 
1363
static char *
1364
locate_arg (p)
1365
     char *p;
1366
{
1367
  while ((p = strchr (p, '$')))
1368
    {
1369
      if (strncmp (p, "$arg", 4) == 0 && isdigit (p[4]))
1370
        return p;
1371
      p++;
1372
    }
1373
  return NULL;
1374
}
1375
 
1376
/* Insert the user defined arguments stored in user_arg into the $arg
1377
   arguments found in line, with the updated copy being placed into nline.  */
1378
 
1379
static char *
1380
insert_args (line)
1381
     char *line;
1382
{
1383
  char *p, *save_line, *new_line;
1384
  unsigned len, i;
1385
 
1386
  /* First we need to know how much memory to allocate for the new line.  */
1387
  save_line = line;
1388
  len = 0;
1389
  while ((p = locate_arg (line)))
1390
    {
1391
      len += p - line;
1392
      i = p[4] - '0';
1393
 
1394
      if (i >= user_args->count)
1395
        {
1396
          error ("Missing argument %d in user function.\n", i);
1397
          return NULL;
1398
        }
1399
      len += user_args->a[i].len;
1400
      line = p + 5;
1401
    }
1402
 
1403
  /* Don't forget the tail.  */
1404
  len += strlen (line);
1405
 
1406
  /* Allocate space for the new line and fill it in.  */
1407
  new_line = (char *) xmalloc (len + 1);
1408
  if (new_line == NULL)
1409
    return NULL;
1410
 
1411
  /* Restore pointer to beginning of old line.  */
1412
  line = save_line;
1413
 
1414
  /* Save pointer to beginning of new line.  */
1415
  save_line = new_line;
1416
 
1417
  while ((p = locate_arg (line)))
1418
    {
1419
      int i, len;
1420
 
1421
      memcpy (new_line, line, p - line);
1422
      new_line += p - line;
1423
      i = p[4] - '0';
1424
 
1425
      len = user_args->a[i].len;
1426
      if (len)
1427
        {
1428
          memcpy (new_line, user_args->a[i].arg, len);
1429
          new_line += len;
1430
        }
1431
      line = p + 5;
1432
    }
1433
  /* Don't forget the tail.  */
1434
  strcpy (new_line, line);
1435
 
1436
  /* Return a pointer to the beginning of the new line.  */
1437
  return save_line;
1438
}
1439
 
1440
void
1441
execute_user_command (c, args)
1442
     struct cmd_list_element *c;
1443
     char *args;
1444
{
1445
  register struct command_line *cmdlines;
1446
  struct cleanup *old_chain;
1447
  enum command_control_type ret;
1448
 
1449
  old_chain = setup_user_args (args);
1450
 
1451
  cmdlines = c->user_commands;
1452
  if (cmdlines == 0)
1453
    /* Null command */
1454
    return;
1455
 
1456
  /* Set the instream to 0, indicating execution of a
1457
     user-defined function.  */
1458
  old_chain = make_cleanup ((make_cleanup_func) source_cleanup, instream);
1459
  instream = (FILE *) 0;
1460
  while (cmdlines)
1461
    {
1462
      ret = execute_control_command (cmdlines);
1463
      if (ret != simple_control && ret != break_control)
1464
        {
1465
          warning ("Error in control structure.\n");
1466
          break;
1467
        }
1468
      cmdlines = cmdlines->next;
1469
    }
1470
  do_cleanups (old_chain);
1471
}
1472
 
1473
/* Execute the line P as a command.
1474
   Pass FROM_TTY as second argument to the defining function.  */
1475
 
1476
void
1477
execute_command (p, from_tty)
1478
     char *p;
1479
     int from_tty;
1480
{
1481
  register struct cmd_list_element *c;
1482
  register enum language flang;
1483
  static int warned = 0;
1484
  char *line;
1485
  /* FIXME: These should really be in an appropriate header file */
1486
  extern void serial_log_command PARAMS ((const char *));
1487
 
1488
  free_all_values ();
1489
 
1490
  /* Force cleanup of any alloca areas if using C alloca instead of
1491
     a builtin alloca.  */
1492
  alloca (0);
1493
 
1494
  /* This can happen when command_line_input hits end of file.  */
1495
  if (p == NULL)
1496
    return;
1497
 
1498
  serial_log_command (p);
1499
 
1500
  while (*p == ' ' || *p == '\t')
1501
    p++;
1502
  if (*p)
1503
    {
1504
      char *arg;
1505
      line = p;
1506
 
1507
      c = lookup_cmd (&p, cmdlist, "", 0, 1);
1508
 
1509
      /* If the target is running, we allow only a limited set of
1510
         commands. */
1511
      if (event_loop_p && target_can_async_p () && target_executing)
1512
        if (!strcmp (c->name, "help")
1513
            && !strcmp (c->name, "pwd")
1514
            && !strcmp (c->name, "show")
1515
            && !strcmp (c->name, "stop"))
1516
          error ("Cannot execute this command while the target is running.");
1517
 
1518
      /* Pass null arg rather than an empty one.  */
1519
      arg = *p ? p : 0;
1520
 
1521
      /* Clear off trailing whitespace, except for set and complete command.  */
1522
      if (arg && c->type != set_cmd && c->function.cfunc != complete_command)
1523
        {
1524
          p = arg + strlen (arg) - 1;
1525
          while (p >= arg && (*p == ' ' || *p == '\t'))
1526
            p--;
1527
          *(p + 1) = '\0';
1528
        }
1529
 
1530
      /* If this command has been hooked, run the hook first. */
1531
      if (c->hook)
1532
        execute_user_command (c->hook, (char *) 0);
1533
 
1534
      if (c->flags & DEPRECATED_WARN_USER)
1535
        deprecated_cmd_warning (&line);
1536
 
1537
      if (c->class == class_user)
1538
        execute_user_command (c, arg);
1539
      else if (c->type == set_cmd || c->type == show_cmd)
1540
        do_setshow_command (arg, from_tty & caution, c);
1541
      else if (c->function.cfunc == NO_FUNCTION)
1542
        error ("That is not a command, just a help topic.");
1543
      else if (call_command_hook)
1544
        call_command_hook (c, arg, from_tty & caution);
1545
      else
1546
        (*c->function.cfunc) (arg, from_tty & caution);
1547
    }
1548
 
1549
  /* Tell the user if the language has changed (except first time).  */
1550
  if (current_language != expected_language)
1551
    {
1552
      if (language_mode == language_mode_auto)
1553
        {
1554
          language_info (1);    /* Print what changed.  */
1555
        }
1556
      warned = 0;
1557
    }
1558
 
1559
  /* Warn the user if the working language does not match the
1560
     language of the current frame.  Only warn the user if we are
1561
     actually running the program, i.e. there is a stack. */
1562
  /* FIXME:  This should be cacheing the frame and only running when
1563
     the frame changes.  */
1564
 
1565
  if (target_has_stack)
1566
    {
1567
      flang = get_frame_language ();
1568
      if (!warned
1569
          && flang != language_unknown
1570
          && flang != current_language->la_language)
1571
        {
1572
          printf_filtered ("%s\n", lang_frame_mismatch_warn);
1573
          warned = 1;
1574
        }
1575
    }
1576
}
1577
 
1578
/* ARGSUSED */
1579
/* NOTE 1999-04-29: This function will be static again, once we modify
1580
   gdb to use the event loop as the default command loop and we merge
1581
   event-top.c into this file, top.c */
1582
/* static */ void
1583
command_loop_marker (foo)
1584
     int foo;
1585
{
1586
}
1587
 
1588
/* Read commands from `instream' and execute them
1589
   until end of file or error reading instream.  */
1590
 
1591
void
1592
command_loop ()
1593
{
1594
  struct cleanup *old_chain;
1595
  char *command;
1596
  int stdin_is_tty = ISATTY (stdin);
1597
  long time_at_cmd_start;
1598
#ifdef HAVE_SBRK
1599
  long space_at_cmd_start = 0;
1600
#endif
1601
  extern int display_time;
1602
  extern int display_space;
1603
 
1604
  while (instream && !feof (instream))
1605
    {
1606
#if defined(TUI)
1607
      extern int insert_mode;
1608
#endif
1609
      if (window_hook && instream == stdin)
1610
        (*window_hook) (instream, get_prompt ());
1611
 
1612
      quit_flag = 0;
1613
      if (instream == stdin && stdin_is_tty)
1614
        reinitialize_more_filter ();
1615
      old_chain = make_cleanup ((make_cleanup_func) command_loop_marker, 0);
1616
 
1617
#if defined(TUI)
1618
      /* A bit of paranoia: I want to make sure the "insert_mode" global
1619
       * is clear except when it is being used for command-line editing
1620
       * (see tuiIO.c, utils.c); otherwise normal output will
1621
       * get messed up in the TUI. So clear it before/after
1622
       * the command-line-input call. - RT
1623
       */
1624
      insert_mode = 0;
1625
#endif
1626
      /* Get a command-line. This calls the readline package. */
1627
      command = command_line_input (instream == stdin ?
1628
                                    get_prompt () : (char *) NULL,
1629
                                    instream == stdin, "prompt");
1630
#if defined(TUI)
1631
      insert_mode = 0;
1632
#endif
1633
      if (command == 0)
1634
        return;
1635
 
1636
      time_at_cmd_start = get_run_time ();
1637
 
1638
      if (display_space)
1639
        {
1640
#ifdef HAVE_SBRK
1641
          extern char **environ;
1642
          char *lim = (char *) sbrk (0);
1643
 
1644
          space_at_cmd_start = (long) (lim - (char *) &environ);
1645
#endif
1646
        }
1647
 
1648
      execute_command (command, instream == stdin);
1649
      /* Do any commands attached to breakpoint we stopped at.  */
1650
      bpstat_do_actions (&stop_bpstat);
1651
      do_cleanups (old_chain);
1652
 
1653
      if (display_time)
1654
        {
1655
          long cmd_time = get_run_time () - time_at_cmd_start;
1656
 
1657
          printf_unfiltered ("Command execution time: %ld.%06ld\n",
1658
                             cmd_time / 1000000, cmd_time % 1000000);
1659
        }
1660
 
1661
      if (display_space)
1662
        {
1663
#ifdef HAVE_SBRK
1664
          extern char **environ;
1665
          char *lim = (char *) sbrk (0);
1666
          long space_now = lim - (char *) &environ;
1667
          long space_diff = space_now - space_at_cmd_start;
1668
 
1669
          printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
1670
                             space_now,
1671
                             (space_diff >= 0 ? '+' : '-'),
1672
                             space_diff);
1673
#endif
1674
        }
1675
    }
1676
}
1677
 
1678
/* Read commands from `instream' and execute them until end of file or
1679
   error reading instream. This command loop doesnt care about any
1680
   such things as displaying time and space usage. If the user asks
1681
   for those, they won't work. */
1682
void
1683
simplified_command_loop (read_input_func, execute_command_func)
1684
     char *(*read_input_func) (char *);
1685
     void (*execute_command_func) (char *, int);
1686
{
1687
  struct cleanup *old_chain;
1688
  char *command;
1689
  int stdin_is_tty = ISATTY (stdin);
1690
 
1691
  while (instream && !feof (instream))
1692
    {
1693
      quit_flag = 0;
1694
      if (instream == stdin && stdin_is_tty)
1695
        reinitialize_more_filter ();
1696
      old_chain = make_cleanup ((make_cleanup_func) command_loop_marker, 0);
1697
 
1698
      /* Get a command-line. */
1699
      command = (*read_input_func) (instream == stdin ?
1700
                                    get_prompt () : (char *) NULL);
1701
 
1702
      if (command == 0)
1703
        return;
1704
 
1705
      (*execute_command_func) (command, instream == stdin);
1706
 
1707
      /* Do any commands attached to breakpoint we stopped at.  */
1708
      bpstat_do_actions (&stop_bpstat);
1709
 
1710
      do_cleanups (old_chain);
1711
    }
1712
}
1713
 
1714
/* Commands call this if they do not want to be repeated by null lines.  */
1715
 
1716
void
1717
dont_repeat ()
1718
{
1719
  if (server_command)
1720
    return;
1721
 
1722
  /* If we aren't reading from standard input, we are saving the last
1723
     thing read from stdin in line and don't want to delete it.  Null lines
1724
     won't repeat here in any case.  */
1725
  if (instream == stdin)
1726
    *line = 0;
1727
}
1728
 
1729
/* Read a line from the stream "instream" without command line editing.
1730
 
1731
   It prints PROMPT_ARG once at the start.
1732
   Action is compatible with "readline", e.g. space for the result is
1733
   malloc'd and should be freed by the caller.
1734
 
1735
   A NULL return means end of file.  */
1736
char *
1737
gdb_readline (prompt_arg)
1738
     char *prompt_arg;
1739
{
1740
  int c;
1741
  char *result;
1742
  int input_index = 0;
1743
  int result_size = 80;
1744
 
1745
  if (prompt_arg)
1746
    {
1747
      /* Don't use a _filtered function here.  It causes the assumed
1748
         character position to be off, since the newline we read from
1749
         the user is not accounted for.  */
1750
      fputs_unfiltered (prompt_arg, gdb_stdout);
1751
#ifdef MPW
1752
      /* Move to a new line so the entered line doesn't have a prompt
1753
         on the front of it. */
1754
      fputs_unfiltered ("\n", gdb_stdout);
1755
#endif /* MPW */
1756
      gdb_flush (gdb_stdout);
1757
    }
1758
 
1759
  result = (char *) xmalloc (result_size);
1760
 
1761
  while (1)
1762
    {
1763
      /* Read from stdin if we are executing a user defined command.
1764
         This is the right thing for prompt_for_continue, at least.  */
1765
      c = fgetc (instream ? instream : stdin);
1766
 
1767
      if (c == EOF)
1768
        {
1769
          if (input_index > 0)
1770
            /* The last line does not end with a newline.  Return it, and
1771
               if we are called again fgetc will still return EOF and
1772
               we'll return NULL then.  */
1773
            break;
1774
          free (result);
1775
          return NULL;
1776
        }
1777
 
1778
      if (c == '\n')
1779
#ifndef CRLF_SOURCE_FILES
1780
        break;
1781
#else
1782
        {
1783
          if (input_index > 0 && result[input_index - 1] == '\r')
1784
            input_index--;
1785
          break;
1786
        }
1787
#endif
1788
 
1789
      result[input_index++] = c;
1790
      while (input_index >= result_size)
1791
        {
1792
          result_size *= 2;
1793
          result = (char *) xrealloc (result, result_size);
1794
        }
1795
    }
1796
 
1797
  result[input_index++] = '\0';
1798
  return result;
1799
}
1800
 
1801
/* Variables which control command line editing and history
1802
   substitution.  These variables are given default values at the end
1803
   of this file.  */
1804
static int command_editing_p;
1805
/* NOTE 1999-04-29: This variable will be static again, once we modify
1806
   gdb to use the event loop as the default command loop and we merge
1807
   event-top.c into this file, top.c */
1808
/* static */ int history_expansion_p;
1809
static int write_history_p;
1810
static int history_size;
1811
static char *history_filename;
1812
 
1813
/* readline uses the word breaks for two things:
1814
   (1) In figuring out where to point the TEXT parameter to the
1815
   rl_completion_entry_function.  Since we don't use TEXT for much,
1816
   it doesn't matter a lot what the word breaks are for this purpose, but
1817
   it does affect how much stuff M-? lists.
1818
   (2) If one of the matches contains a word break character, readline
1819
   will quote it.  That's why we switch between
1820
   gdb_completer_word_break_characters and
1821
   gdb_completer_command_word_break_characters.  I'm not sure when
1822
   we need this behavior (perhaps for funky characters in C++ symbols?).  */
1823
 
1824
/* Variables which are necessary for fancy command line editing.  */
1825
char *gdb_completer_word_break_characters =
1826
" \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
1827
 
1828
/* When completing on command names, we remove '-' from the list of
1829
   word break characters, since we use it in command names.  If the
1830
   readline library sees one in any of the current completion strings,
1831
   it thinks that the string needs to be quoted and automatically supplies
1832
   a leading quote. */
1833
char *gdb_completer_command_word_break_characters =
1834
" \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
1835
 
1836
/* When completing on file names, we remove from the list of word
1837
   break characters any characters that are commonly used in file
1838
   names, such as '-', '+', '~', etc.  Otherwise, readline displays
1839
   incorrect completion candidates.  */
1840
char *gdb_completer_file_name_break_characters = " \t\n*|\"';:?/><";
1841
 
1842
/* Characters that can be used to quote completion strings.  Note that we
1843
   can't include '"' because the gdb C parser treats such quoted sequences
1844
   as strings. */
1845
char *gdb_completer_quote_characters =
1846
"'";
1847
 
1848
/* Functions that are used as part of the fancy command line editing.  */
1849
 
1850
/* This can be used for functions which don't want to complete on symbols
1851
   but don't want to complete on anything else either.  */
1852
/* ARGSUSED */
1853
char **
1854
noop_completer (text, prefix)
1855
     char *text;
1856
     char *prefix;
1857
{
1858
  return NULL;
1859
}
1860
 
1861
/* Complete on filenames.  */
1862
char **
1863
filename_completer (text, word)
1864
     char *text;
1865
     char *word;
1866
{
1867
  /* From readline.  */
1868
  extern char *filename_completion_function PARAMS ((char *, int));
1869
  int subsequent_name;
1870
  char **return_val;
1871
  int return_val_used;
1872
  int return_val_alloced;
1873
 
1874
  return_val_used = 0;
1875
  /* Small for testing.  */
1876
  return_val_alloced = 1;
1877
  return_val = (char **) xmalloc (return_val_alloced * sizeof (char *));
1878
 
1879
  subsequent_name = 0;
1880
  while (1)
1881
    {
1882
      char *p;
1883
      p = filename_completion_function (text, subsequent_name);
1884
      if (return_val_used >= return_val_alloced)
1885
        {
1886
          return_val_alloced *= 2;
1887
          return_val =
1888
            (char **) xrealloc (return_val,
1889
                                return_val_alloced * sizeof (char *));
1890
        }
1891
      if (p == NULL)
1892
        {
1893
          return_val[return_val_used++] = p;
1894
          break;
1895
        }
1896
      /* We need to set subsequent_name to a non-zero value before the
1897
         continue line below, because otherwise, if the first file seen
1898
         by GDB is a backup file whose name ends in a `~', we will loop
1899
         indefinitely.  */
1900
      subsequent_name = 1;
1901
      /* Like emacs, don't complete on old versions.  Especially useful
1902
         in the "source" command.  */
1903
      if (p[strlen (p) - 1] == '~')
1904
        continue;
1905
 
1906
      {
1907
        char *q;
1908
        if (word == text)
1909
          /* Return exactly p.  */
1910
          return_val[return_val_used++] = p;
1911
        else if (word > text)
1912
          {
1913
            /* Return some portion of p.  */
1914
            q = xmalloc (strlen (p) + 5);
1915
            strcpy (q, p + (word - text));
1916
            return_val[return_val_used++] = q;
1917
            free (p);
1918
          }
1919
        else
1920
          {
1921
            /* Return some of TEXT plus p.  */
1922
            q = xmalloc (strlen (p) + (text - word) + 5);
1923
            strncpy (q, word, text - word);
1924
            q[text - word] = '\0';
1925
            strcat (q, p);
1926
            return_val[return_val_used++] = q;
1927
            free (p);
1928
          }
1929
      }
1930
    }
1931
#if 0
1932
  /* There is no way to do this just long enough to affect quote inserting
1933
     without also affecting the next completion.  This should be fixed in
1934
     readline.  FIXME.  */
1935
  /* Insure that readline does the right thing
1936
     with respect to inserting quotes.  */
1937
  rl_completer_word_break_characters = "";
1938
#endif
1939
  return return_val;
1940
}
1941
 
1942
/* Here are some useful test cases for completion.  FIXME: These should
1943
   be put in the test suite.  They should be tested with both M-? and TAB.
1944
 
1945
   "show output-" "radix"
1946
   "show output" "-radix"
1947
   "p" ambiguous (commands starting with p--path, print, printf, etc.)
1948
   "p "  ambiguous (all symbols)
1949
   "info t foo" no completions
1950
   "info t " no completions
1951
   "info t" ambiguous ("info target", "info terminal", etc.)
1952
   "info ajksdlfk" no completions
1953
   "info ajksdlfk " no completions
1954
   "info" " "
1955
   "info " ambiguous (all info commands)
1956
   "p \"a" no completions (string constant)
1957
   "p 'a" ambiguous (all symbols starting with a)
1958
   "p b-a" ambiguous (all symbols starting with a)
1959
   "p b-" ambiguous (all symbols)
1960
   "file Make" "file" (word break hard to screw up here)
1961
   "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
1962
 */
1963
 
1964
/* Generate completions one by one for the completer.  Each time we are
1965
   called return another potential completion to the caller.
1966
   line_completion just completes on commands or passes the buck to the
1967
   command's completer function, the stuff specific to symbol completion
1968
   is in make_symbol_completion_list.
1969
 
1970
   TEXT is the caller's idea of the "word" we are looking at.
1971
 
1972
   MATCHES is the number of matches that have currently been collected from
1973
   calling this completion function.  When zero, then we need to initialize,
1974
   otherwise the initialization has already taken place and we can just
1975
   return the next potential completion string.
1976
 
1977
   LINE_BUFFER is available to be looked at; it contains the entire text
1978
   of the line.  POINT is the offset in that line of the cursor.  You
1979
   should pretend that the line ends at POINT.
1980
 
1981
   Returns NULL if there are no more completions, else a pointer to a string
1982
   which is a possible completion, it is the caller's responsibility to
1983
   free the string.  */
1984
 
1985
static char *
1986
line_completion_function (text, matches, line_buffer, point)
1987
     char *text;
1988
     int matches;
1989
     char *line_buffer;
1990
     int point;
1991
{
1992
  static char **list = (char **) NULL;  /* Cache of completions */
1993
  static int index;             /* Next cached completion */
1994
  char *output = NULL;
1995
  char *tmp_command, *p;
1996
  /* Pointer within tmp_command which corresponds to text.  */
1997
  char *word;
1998
  struct cmd_list_element *c, *result_list;
1999
 
2000
  if (matches == 0)
2001
    {
2002
      /* The caller is beginning to accumulate a new set of completions, so
2003
         we need to find all of them now, and cache them for returning one at
2004
         a time on future calls. */
2005
 
2006
      if (list)
2007
        {
2008
          /* Free the storage used by LIST, but not by the strings inside.
2009
             This is because rl_complete_internal () frees the strings. */
2010
          free ((PTR) list);
2011
        }
2012
      list = 0;
2013
      index = 0;
2014
 
2015
      /* Choose the default set of word break characters to break completions.
2016
         If we later find out that we are doing completions on command strings
2017
         (as opposed to strings supplied by the individual command completer
2018
         functions, which can be any string) then we will switch to the
2019
         special word break set for command strings, which leaves out the
2020
         '-' character used in some commands.  */
2021
 
2022
      rl_completer_word_break_characters =
2023
        gdb_completer_word_break_characters;
2024
 
2025
      /* Decide whether to complete on a list of gdb commands or on symbols. */
2026
      tmp_command = (char *) alloca (point + 1);
2027
      p = tmp_command;
2028
 
2029
      strncpy (tmp_command, line_buffer, point);
2030
      tmp_command[point] = '\0';
2031
      /* Since text always contains some number of characters leading up
2032
         to point, we can find the equivalent position in tmp_command
2033
         by subtracting that many characters from the end of tmp_command.  */
2034
      word = tmp_command + point - strlen (text);
2035
 
2036
      if (point == 0)
2037
        {
2038
          /* An empty line we want to consider ambiguous; that is, it
2039
             could be any command.  */
2040
          c = (struct cmd_list_element *) -1;
2041
          result_list = 0;
2042
        }
2043
      else
2044
        {
2045
          c = lookup_cmd_1 (&p, cmdlist, &result_list, 1);
2046
        }
2047
 
2048
      /* Move p up to the next interesting thing.  */
2049
      while (*p == ' ' || *p == '\t')
2050
        {
2051
          p++;
2052
        }
2053
 
2054
      if (!c)
2055
        {
2056
          /* It is an unrecognized command.  So there are no
2057
             possible completions.  */
2058
          list = NULL;
2059
        }
2060
      else if (c == (struct cmd_list_element *) -1)
2061
        {
2062
          char *q;
2063
 
2064
          /* lookup_cmd_1 advances p up to the first ambiguous thing, but
2065
             doesn't advance over that thing itself.  Do so now.  */
2066
          q = p;
2067
          while (*q && (isalnum (*q) || *q == '-' || *q == '_'))
2068
            ++q;
2069
          if (q != tmp_command + point)
2070
            {
2071
              /* There is something beyond the ambiguous
2072
                 command, so there are no possible completions.  For
2073
                 example, "info t " or "info t foo" does not complete
2074
                 to anything, because "info t" can be "info target" or
2075
                 "info terminal".  */
2076
              list = NULL;
2077
            }
2078
          else
2079
            {
2080
              /* We're trying to complete on the command which was ambiguous.
2081
                 This we can deal with.  */
2082
              if (result_list)
2083
                {
2084
                  list = complete_on_cmdlist (*result_list->prefixlist, p,
2085
                                              word);
2086
                }
2087
              else
2088
                {
2089
                  list = complete_on_cmdlist (cmdlist, p, word);
2090
                }
2091
              /* Insure that readline does the right thing with respect to
2092
                 inserting quotes.  */
2093
              rl_completer_word_break_characters =
2094
                gdb_completer_command_word_break_characters;
2095
            }
2096
        }
2097
      else
2098
        {
2099
          /* We've recognized a full command.  */
2100
 
2101
          if (p == tmp_command + point)
2102
            {
2103
              /* There is no non-whitespace in the line beyond the command.  */
2104
 
2105
              if (p[-1] == ' ' || p[-1] == '\t')
2106
                {
2107
                  /* The command is followed by whitespace; we need to complete
2108
                     on whatever comes after command.  */
2109
                  if (c->prefixlist)
2110
                    {
2111
                      /* It is a prefix command; what comes after it is
2112
                         a subcommand (e.g. "info ").  */
2113
                      list = complete_on_cmdlist (*c->prefixlist, p, word);
2114
 
2115
                      /* Insure that readline does the right thing
2116
                         with respect to inserting quotes.  */
2117
                      rl_completer_word_break_characters =
2118
                        gdb_completer_command_word_break_characters;
2119
                    }
2120
                  else if (c->enums)
2121
                    {
2122
                      list = complete_on_enum (c->enums, p, word);
2123
                      rl_completer_word_break_characters =
2124
                        gdb_completer_command_word_break_characters;
2125
                    }
2126
                  else
2127
                    {
2128
                      /* It is a normal command; what comes after it is
2129
                         completed by the command's completer function.  */
2130
                      list = (*c->completer) (p, word);
2131
                      if (c->completer == filename_completer)
2132
                        rl_completer_word_break_characters =
2133
                          gdb_completer_file_name_break_characters;
2134
                    }
2135
                }
2136
              else
2137
                {
2138
                  /* The command is not followed by whitespace; we need to
2139
                     complete on the command itself.  e.g. "p" which is a
2140
                     command itself but also can complete to "print", "ptype"
2141
                     etc.  */
2142
                  char *q;
2143
 
2144
                  /* Find the command we are completing on.  */
2145
                  q = p;
2146
                  while (q > tmp_command)
2147
                    {
2148
                      if (isalnum (q[-1]) || q[-1] == '-' || q[-1] == '_')
2149
                        --q;
2150
                      else
2151
                        break;
2152
                    }
2153
 
2154
                  list = complete_on_cmdlist (result_list, q, word);
2155
 
2156
                  /* Insure that readline does the right thing
2157
                     with respect to inserting quotes.  */
2158
                  rl_completer_word_break_characters =
2159
                    gdb_completer_command_word_break_characters;
2160
                }
2161
            }
2162
          else
2163
            {
2164
              /* There is non-whitespace beyond the command.  */
2165
 
2166
              if (c->prefixlist && !c->allow_unknown)
2167
                {
2168
                  /* It is an unrecognized subcommand of a prefix command,
2169
                     e.g. "info adsfkdj".  */
2170
                  list = NULL;
2171
                }
2172
              else if (c->enums)
2173
                {
2174
                  list = complete_on_enum (c->enums, p, word);
2175
                }
2176
              else
2177
                {
2178
                  /* It is a normal command.  */
2179
                  list = (*c->completer) (p, word);
2180
                  if (c->completer == filename_completer)
2181
                    rl_completer_word_break_characters =
2182
                      gdb_completer_file_name_break_characters;
2183
                }
2184
            }
2185
        }
2186
    }
2187
 
2188
  /* If we found a list of potential completions during initialization then
2189
     dole them out one at a time.  The vector of completions is NULL
2190
     terminated, so after returning the last one, return NULL (and continue
2191
     to do so) each time we are called after that, until a new list is
2192
     available. */
2193
 
2194
  if (list)
2195
    {
2196
      output = list[index];
2197
      if (output)
2198
        {
2199
          index++;
2200
        }
2201
    }
2202
 
2203
#if 0
2204
  /* Can't do this because readline hasn't yet checked the word breaks
2205
     for figuring out whether to insert a quote.  */
2206
  if (output == NULL)
2207
    /* Make sure the word break characters are set back to normal for the
2208
       next time that readline tries to complete something.  */
2209
    rl_completer_word_break_characters =
2210
      gdb_completer_word_break_characters;
2211
#endif
2212
 
2213
  return (output);
2214
}
2215
 
2216
/* Line completion interface function for readline.  */
2217
 
2218
static char *
2219
readline_line_completion_function (text, matches)
2220
     char *text;
2221
     int matches;
2222
{
2223
  return line_completion_function (text, matches, rl_line_buffer, rl_point);
2224
}
2225
 
2226
/* Skip over a possibly quoted word (as defined by the quote characters
2227
   and word break characters the completer uses).  Returns pointer to the
2228
   location after the "word". */
2229
 
2230
char *
2231
skip_quoted (str)
2232
     char *str;
2233
{
2234
  char quote_char = '\0';
2235
  char *scan;
2236
 
2237
  for (scan = str; *scan != '\0'; scan++)
2238
    {
2239
      if (quote_char != '\0')
2240
        {
2241
          /* Ignore everything until the matching close quote char */
2242
          if (*scan == quote_char)
2243
            {
2244
              /* Found matching close quote. */
2245
              scan++;
2246
              break;
2247
            }
2248
        }
2249
      else if (strchr (gdb_completer_quote_characters, *scan))
2250
        {
2251
          /* Found start of a quoted string. */
2252
          quote_char = *scan;
2253
        }
2254
      else if (strchr (gdb_completer_word_break_characters, *scan))
2255
        {
2256
          break;
2257
        }
2258
    }
2259
  return (scan);
2260
}
2261
 
2262
 
2263
#ifdef STOP_SIGNAL
2264
static void
2265
stop_sig (signo)
2266
     int signo;
2267
{
2268
#if STOP_SIGNAL == SIGTSTP
2269
  signal (SIGTSTP, SIG_DFL);
2270
  sigsetmask (0);
2271
  kill (getpid (), SIGTSTP);
2272
  signal (SIGTSTP, stop_sig);
2273
#else
2274
  signal (STOP_SIGNAL, stop_sig);
2275
#endif
2276
  printf_unfiltered ("%s", get_prompt ());
2277
  gdb_flush (gdb_stdout);
2278
 
2279
  /* Forget about any previous command -- null line now will do nothing.  */
2280
  dont_repeat ();
2281
}
2282
#endif /* STOP_SIGNAL */
2283
 
2284
/* Initialize signal handlers. */
2285
static void
2286
do_nothing (signo)
2287
     int signo;
2288
{
2289
  /* Under System V the default disposition of a signal is reinstated after
2290
     the signal is caught and delivered to an application process.  On such
2291
     systems one must restore the replacement signal handler if one wishes
2292
     to continue handling the signal in one's program.  On BSD systems this
2293
     is not needed but it is harmless, and it simplifies the code to just do
2294
     it unconditionally. */
2295
  signal (signo, do_nothing);
2296
}
2297
 
2298
static void
2299
init_signals ()
2300
{
2301
  signal (SIGINT, request_quit);
2302
 
2303
  /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
2304
     to the inferior and breakpoints will be ignored.  */
2305
#ifdef SIGTRAP
2306
  signal (SIGTRAP, SIG_DFL);
2307
#endif
2308
 
2309
  /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
2310
     passed to the inferior, which we don't want.  It would be
2311
     possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
2312
     on BSD4.3 systems using vfork, that can affect the
2313
     GDB process as well as the inferior (the signal handling tables
2314
     might be in memory, shared between the two).  Since we establish
2315
     a handler for SIGQUIT, when we call exec it will set the signal
2316
     to SIG_DFL for us.  */
2317
  signal (SIGQUIT, do_nothing);
2318
#ifdef SIGHUP
2319
  if (signal (SIGHUP, do_nothing) != SIG_IGN)
2320
    signal (SIGHUP, disconnect);
2321
#endif
2322
  signal (SIGFPE, float_handler);
2323
 
2324
#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
2325
  signal (SIGWINCH, SIGWINCH_HANDLER);
2326
#endif
2327
}
2328
 
2329
/* Read one line from the command input stream `instream'
2330
   into the local static buffer `linebuffer' (whose current length
2331
   is `linelength').
2332
   The buffer is made bigger as necessary.
2333
   Returns the address of the start of the line.
2334
 
2335
   NULL is returned for end of file.
2336
 
2337
   *If* the instream == stdin & stdin is a terminal, the line read
2338
   is copied into the file line saver (global var char *line,
2339
   length linesize) so that it can be duplicated.
2340
 
2341
   This routine either uses fancy command line editing or
2342
   simple input as the user has requested.  */
2343
 
2344
char *
2345
command_line_input (prompt_arg, repeat, annotation_suffix)
2346
     char *prompt_arg;
2347
     int repeat;
2348
     char *annotation_suffix;
2349
{
2350
  static char *linebuffer = 0;
2351
  static unsigned linelength = 0;
2352
  register char *p;
2353
  char *p1;
2354
  char *rl;
2355
  char *local_prompt = prompt_arg;
2356
  char *nline;
2357
  char got_eof = 0;
2358
 
2359
  /* The annotation suffix must be non-NULL.  */
2360
  if (annotation_suffix == NULL)
2361
    annotation_suffix = "";
2362
 
2363
  if (annotation_level > 1 && instream == stdin)
2364
    {
2365
      local_prompt = alloca ((prompt_arg == NULL ? 0 : strlen (prompt_arg))
2366
                             + strlen (annotation_suffix) + 40);
2367
      if (prompt_arg == NULL)
2368
        local_prompt[0] = '\0';
2369
      else
2370
        strcpy (local_prompt, prompt_arg);
2371
      strcat (local_prompt, "\n\032\032");
2372
      strcat (local_prompt, annotation_suffix);
2373
      strcat (local_prompt, "\n");
2374
    }
2375
 
2376
  if (linebuffer == 0)
2377
    {
2378
      linelength = 80;
2379
      linebuffer = (char *) xmalloc (linelength);
2380
    }
2381
 
2382
  p = linebuffer;
2383
 
2384
  /* Control-C quits instantly if typed while in this loop
2385
     since it should not wait until the user types a newline.  */
2386
  immediate_quit++;
2387
#ifdef STOP_SIGNAL
2388
  if (job_control)
2389
    {
2390
      if (event_loop_p)
2391
        signal (STOP_SIGNAL, handle_stop_sig);
2392
      else
2393
        signal (STOP_SIGNAL, stop_sig);
2394
    }
2395
#endif
2396
 
2397
  while (1)
2398
    {
2399
      /* Make sure that all output has been output.  Some machines may let
2400
         you get away with leaving out some of the gdb_flush, but not all.  */
2401
      wrap_here ("");
2402
      gdb_flush (gdb_stdout);
2403
      gdb_flush (gdb_stderr);
2404
 
2405
      if (source_file_name != NULL)
2406
        {
2407
          ++source_line_number;
2408
          sprintf (source_error,
2409
                   "%s%s:%d: Error in sourced command file:\n",
2410
                   source_pre_error,
2411
                   source_file_name,
2412
                   source_line_number);
2413
          error_pre_print = source_error;
2414
        }
2415
 
2416
      if (annotation_level > 1 && instream == stdin)
2417
        {
2418
          printf_unfiltered ("\n\032\032pre-");
2419
          printf_unfiltered (annotation_suffix);
2420
          printf_unfiltered ("\n");
2421
        }
2422
 
2423
      /* Don't use fancy stuff if not talking to stdin.  */
2424
      if (readline_hook && instream == NULL)
2425
        {
2426
          rl = (*readline_hook) (local_prompt);
2427
        }
2428
      else if (command_editing_p && instream == stdin && ISATTY (instream))
2429
        {
2430
          rl = readline (local_prompt);
2431
        }
2432
      else
2433
        {
2434
          rl = gdb_readline (local_prompt);
2435
        }
2436
 
2437
      if (annotation_level > 1 && instream == stdin)
2438
        {
2439
          printf_unfiltered ("\n\032\032post-");
2440
          printf_unfiltered (annotation_suffix);
2441
          printf_unfiltered ("\n");
2442
        }
2443
 
2444
      if (!rl || rl == (char *) EOF)
2445
        {
2446
          got_eof = 1;
2447
          break;
2448
        }
2449
      if (strlen (rl) + 1 + (p - linebuffer) > linelength)
2450
        {
2451
          linelength = strlen (rl) + 1 + (p - linebuffer);
2452
          nline = (char *) xrealloc (linebuffer, linelength);
2453
          p += nline - linebuffer;
2454
          linebuffer = nline;
2455
        }
2456
      p1 = rl;
2457
      /* Copy line.  Don't copy null at end.  (Leaves line alone
2458
         if this was just a newline)  */
2459
      while (*p1)
2460
        *p++ = *p1++;
2461
 
2462
      free (rl);                /* Allocated in readline.  */
2463
 
2464
      if (p == linebuffer || *(p - 1) != '\\')
2465
        break;
2466
 
2467
      p--;                      /* Put on top of '\'.  */
2468
      local_prompt = (char *) 0;
2469
    }
2470
 
2471
#ifdef STOP_SIGNAL
2472
  if (job_control)
2473
    signal (STOP_SIGNAL, SIG_DFL);
2474
#endif
2475
  immediate_quit--;
2476
 
2477
  if (got_eof)
2478
    return NULL;
2479
 
2480
#define SERVER_COMMAND_LENGTH 7
2481
  server_command =
2482
    (p - linebuffer > SERVER_COMMAND_LENGTH)
2483
    && STREQN (linebuffer, "server ", SERVER_COMMAND_LENGTH);
2484
  if (server_command)
2485
    {
2486
      /* Note that we don't set `line'.  Between this and the check in
2487
         dont_repeat, this insures that repeating will still do the
2488
         right thing.  */
2489
      *p = '\0';
2490
      return linebuffer + SERVER_COMMAND_LENGTH;
2491
    }
2492
 
2493
  /* Do history expansion if that is wished.  */
2494
  if (history_expansion_p && instream == stdin
2495
      && ISATTY (instream))
2496
    {
2497
      char *history_value;
2498
      int expanded;
2499
 
2500
      *p = '\0';                /* Insert null now.  */
2501
      expanded = history_expand (linebuffer, &history_value);
2502
      if (expanded)
2503
        {
2504
          /* Print the changes.  */
2505
          printf_unfiltered ("%s\n", history_value);
2506
 
2507
          /* If there was an error, call this function again.  */
2508
          if (expanded < 0)
2509
            {
2510
              free (history_value);
2511
              return command_line_input (prompt_arg, repeat, annotation_suffix);
2512
            }
2513
          if (strlen (history_value) > linelength)
2514
            {
2515
              linelength = strlen (history_value) + 1;
2516
              linebuffer = (char *) xrealloc (linebuffer, linelength);
2517
            }
2518
          strcpy (linebuffer, history_value);
2519
          p = linebuffer + strlen (linebuffer);
2520
          free (history_value);
2521
        }
2522
    }
2523
 
2524
  /* If we just got an empty line, and that is supposed
2525
     to repeat the previous command, return the value in the
2526
     global buffer.  */
2527
  if (repeat && p == linebuffer)
2528
    return line;
2529
  for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++);
2530
  if (repeat && !*p1)
2531
    return line;
2532
 
2533
  *p = 0;
2534
 
2535
  /* Add line to history if appropriate.  */
2536
  if (instream == stdin
2537
      && ISATTY (stdin) && *linebuffer)
2538
    add_history (linebuffer);
2539
 
2540
  /* Note: lines consisting solely of comments are added to the command
2541
     history.  This is useful when you type a command, and then
2542
     realize you don't want to execute it quite yet.  You can comment
2543
     out the command and then later fetch it from the value history
2544
     and remove the '#'.  The kill ring is probably better, but some
2545
     people are in the habit of commenting things out.  */
2546
  if (*p1 == '#')
2547
    *p1 = '\0';                 /* Found a comment. */
2548
 
2549
  /* Save into global buffer if appropriate.  */
2550
  if (repeat)
2551
    {
2552
      if (linelength > linesize)
2553
        {
2554
          line = xrealloc (line, linelength);
2555
          linesize = linelength;
2556
        }
2557
      strcpy (line, linebuffer);
2558
      return line;
2559
    }
2560
 
2561
  return linebuffer;
2562
}
2563
 
2564
 
2565
/* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
2566
   code bodies.  This is typically used when we encounter an "else"
2567
   clause for an "if" command.  */
2568
 
2569
static void
2570
realloc_body_list (command, new_length)
2571
     struct command_line *command;
2572
     int new_length;
2573
{
2574
  int n;
2575
  struct command_line **body_list;
2576
 
2577
  n = command->body_count;
2578
 
2579
  /* Nothing to do?  */
2580
  if (new_length <= n)
2581
    return;
2582
 
2583
  body_list = (struct command_line **)
2584
    xmalloc (sizeof (struct command_line *) * new_length);
2585
 
2586
  memcpy (body_list, command->body_list, sizeof (struct command_line *) * n);
2587
 
2588
  free (command->body_list);
2589
  command->body_list = body_list;
2590
  command->body_count = new_length;
2591
}
2592
 
2593
/* Read one line from the input stream.  If the command is an "else" or
2594
   "end", return such an indication to the caller.  */
2595
 
2596
static enum misc_command_type
2597
read_next_line (command)
2598
     struct command_line **command;
2599
{
2600
  char *p, *p1, *prompt_ptr, control_prompt[256];
2601
  int i = 0;
2602
 
2603
  if (control_level >= 254)
2604
    error ("Control nesting too deep!\n");
2605
 
2606
  /* Set a prompt based on the nesting of the control commands.  */
2607
  if (instream == stdin || (instream == 0 && readline_hook != NULL))
2608
    {
2609
      for (i = 0; i < control_level; i++)
2610
        control_prompt[i] = ' ';
2611
      control_prompt[i] = '>';
2612
      control_prompt[i + 1] = '\0';
2613
      prompt_ptr = (char *) &control_prompt[0];
2614
    }
2615
  else
2616
    prompt_ptr = NULL;
2617
 
2618
  p = command_line_input (prompt_ptr, instream == stdin, "commands");
2619
 
2620
  /* Not sure what to do here.  */
2621
  if (p == NULL)
2622
    return end_command;
2623
 
2624
  /* Strip leading and trailing whitespace.  */
2625
  while (*p == ' ' || *p == '\t')
2626
    p++;
2627
 
2628
  p1 = p + strlen (p);
2629
  while (p1 != p && (p1[-1] == ' ' || p1[-1] == '\t'))
2630
    p1--;
2631
 
2632
  /* Blanks and comments don't really do anything, but we need to
2633
     distinguish them from else, end and other commands which can be
2634
     executed.  */
2635
  if (p1 == p || p[0] == '#')
2636
    return nop_command;
2637
 
2638
  /* Is this the end of a simple, while, or if control structure?  */
2639
  if (p1 - p == 3 && !strncmp (p, "end", 3))
2640
    return end_command;
2641
 
2642
  /* Is the else clause of an if control structure?  */
2643
  if (p1 - p == 4 && !strncmp (p, "else", 4))
2644
    return else_command;
2645
 
2646
  /* Check for while, if, break, continue, etc and build a new command
2647
     line structure for them.  */
2648
  if (p1 - p > 5 && !strncmp (p, "while", 5))
2649
    *command = build_command_line (while_control, p + 6);
2650
  else if (p1 - p > 2 && !strncmp (p, "if", 2))
2651
    *command = build_command_line (if_control, p + 3);
2652
  else if (p1 - p == 10 && !strncmp (p, "loop_break", 10))
2653
    {
2654
      *command = (struct command_line *)
2655
        xmalloc (sizeof (struct command_line));
2656
      (*command)->next = NULL;
2657
      (*command)->line = NULL;
2658
      (*command)->control_type = break_control;
2659
      (*command)->body_count = 0;
2660
      (*command)->body_list = NULL;
2661
    }
2662
  else if (p1 - p == 13 && !strncmp (p, "loop_continue", 13))
2663
    {
2664
      *command = (struct command_line *)
2665
        xmalloc (sizeof (struct command_line));
2666
      (*command)->next = NULL;
2667
      (*command)->line = NULL;
2668
      (*command)->control_type = continue_control;
2669
      (*command)->body_count = 0;
2670
      (*command)->body_list = NULL;
2671
    }
2672
  else
2673
    {
2674
      /* A normal command.  */
2675
      *command = (struct command_line *)
2676
        xmalloc (sizeof (struct command_line));
2677
      (*command)->next = NULL;
2678
      (*command)->line = savestring (p, p1 - p);
2679
      (*command)->control_type = simple_control;
2680
      (*command)->body_count = 0;
2681
      (*command)->body_list = NULL;
2682
    }
2683
 
2684
  /* Nothing special.  */
2685
  return ok_command;
2686
}
2687
 
2688
/* Recursively read in the control structures and create a command_line
2689
   structure from them.
2690
 
2691
   The parent_control parameter is the control structure in which the
2692
   following commands are nested.  */
2693
 
2694
static enum command_control_type
2695
recurse_read_control_structure (current_cmd)
2696
     struct command_line *current_cmd;
2697
{
2698
  int current_body, i;
2699
  enum misc_command_type val;
2700
  enum command_control_type ret;
2701
  struct command_line **body_ptr, *child_tail, *next;
2702
 
2703
  child_tail = NULL;
2704
  current_body = 1;
2705
 
2706
  /* Sanity checks.  */
2707
  if (current_cmd->control_type == simple_control)
2708
    {
2709
      error ("Recursed on a simple control type\n");
2710
      return invalid_control;
2711
    }
2712
 
2713
  if (current_body > current_cmd->body_count)
2714
    {
2715
      error ("Allocated body is smaller than this command type needs\n");
2716
      return invalid_control;
2717
    }
2718
 
2719
  /* Read lines from the input stream and build control structures.  */
2720
  while (1)
2721
    {
2722
      dont_repeat ();
2723
 
2724
      next = NULL;
2725
      val = read_next_line (&next);
2726
 
2727
      /* Just skip blanks and comments.  */
2728
      if (val == nop_command)
2729
        continue;
2730
 
2731
      if (val == end_command)
2732
        {
2733
          if (current_cmd->control_type == while_control
2734
              || current_cmd->control_type == if_control)
2735
            {
2736
              /* Success reading an entire control structure.  */
2737
              ret = simple_control;
2738
              break;
2739
            }
2740
          else
2741
            {
2742
              ret = invalid_control;
2743
              break;
2744
            }
2745
        }
2746
 
2747
      /* Not the end of a control structure.  */
2748
      if (val == else_command)
2749
        {
2750
          if (current_cmd->control_type == if_control
2751
              && current_body == 1)
2752
            {
2753
              realloc_body_list (current_cmd, 2);
2754
              current_body = 2;
2755
              child_tail = NULL;
2756
              continue;
2757
            }
2758
          else
2759
            {
2760
              ret = invalid_control;
2761
              break;
2762
            }
2763
        }
2764
 
2765
      if (child_tail)
2766
        {
2767
          child_tail->next = next;
2768
        }
2769
      else
2770
        {
2771
          body_ptr = current_cmd->body_list;
2772
          for (i = 1; i < current_body; i++)
2773
            body_ptr++;
2774
 
2775
          *body_ptr = next;
2776
 
2777
        }
2778
 
2779
      child_tail = next;
2780
 
2781
      /* If the latest line is another control structure, then recurse
2782
         on it.  */
2783
      if (next->control_type == while_control
2784
          || next->control_type == if_control)
2785
        {
2786
          control_level++;
2787
          ret = recurse_read_control_structure (next);
2788
          control_level--;
2789
 
2790
          if (ret != simple_control)
2791
            break;
2792
        }
2793
    }
2794
 
2795
  dont_repeat ();
2796
 
2797
  return ret;
2798
}
2799
 
2800
/* Read lines from the input stream and accumulate them in a chain of
2801
   struct command_line's, which is then returned.  For input from a
2802
   terminal, the special command "end" is used to mark the end of the
2803
   input, and is not included in the returned chain of commands. */
2804
 
2805
#define END_MESSAGE "End with a line saying just \"end\"."
2806
 
2807
struct command_line *
2808
read_command_lines (prompt_arg, from_tty)
2809
     char *prompt_arg;
2810
     int from_tty;
2811
{
2812
  struct command_line *head, *tail, *next;
2813
  struct cleanup *old_chain;
2814
  enum command_control_type ret;
2815
  enum misc_command_type val;
2816
 
2817
  control_level = 0;
2818
  if (readline_begin_hook)
2819
    {
2820
      /* Note - intentional to merge messages with no newline */
2821
      (*readline_begin_hook) ("%s  %s\n", prompt_arg, END_MESSAGE);
2822
    }
2823
  else if (from_tty && input_from_terminal_p ())
2824
    {
2825
      printf_unfiltered ("%s\n%s\n", prompt_arg, END_MESSAGE);
2826
      gdb_flush (gdb_stdout);
2827
    }
2828
 
2829
  head = tail = NULL;
2830
  old_chain = NULL;
2831
 
2832
  while (1)
2833
    {
2834
      val = read_next_line (&next);
2835
 
2836
      /* Ignore blank lines or comments.  */
2837
      if (val == nop_command)
2838
        continue;
2839
 
2840
      if (val == end_command)
2841
        {
2842
          ret = simple_control;
2843
          break;
2844
        }
2845
 
2846
      if (val != ok_command)
2847
        {
2848
          ret = invalid_control;
2849
          break;
2850
        }
2851
 
2852
      if (next->control_type == while_control
2853
          || next->control_type == if_control)
2854
        {
2855
          control_level++;
2856
          ret = recurse_read_control_structure (next);
2857
          control_level--;
2858
 
2859
          if (ret == invalid_control)
2860
            break;
2861
        }
2862
 
2863
      if (tail)
2864
        {
2865
          tail->next = next;
2866
        }
2867
      else
2868
        {
2869
          head = next;
2870
          old_chain = make_cleanup ((make_cleanup_func) free_command_lines,
2871
                                    &head);
2872
        }
2873
      tail = next;
2874
    }
2875
 
2876
  dont_repeat ();
2877
 
2878
  if (head)
2879
    {
2880
      if (ret != invalid_control)
2881
        {
2882
          discard_cleanups (old_chain);
2883
        }
2884
      else
2885
        do_cleanups (old_chain);
2886
    }
2887
 
2888
  if (readline_end_hook)
2889
    {
2890
      (*readline_end_hook) ();
2891
    }
2892
  return (head);
2893
}
2894
 
2895
/* Free a chain of struct command_line's.  */
2896
 
2897
void
2898
free_command_lines (lptr)
2899
     struct command_line **lptr;
2900
{
2901
  register struct command_line *l = *lptr;
2902
  register struct command_line *next;
2903
  struct command_line **blist;
2904
  int i;
2905
 
2906
  while (l)
2907
    {
2908
      if (l->body_count > 0)
2909
        {
2910
          blist = l->body_list;
2911
          for (i = 0; i < l->body_count; i++, blist++)
2912
            free_command_lines (blist);
2913
        }
2914
      next = l->next;
2915
      free (l->line);
2916
      free ((PTR) l);
2917
      l = next;
2918
    }
2919
}
2920
 
2921
/* Add an element to the list of info subcommands.  */
2922
 
2923
struct cmd_list_element *
2924
add_info (name, fun, doc)
2925
     char *name;
2926
     void (*fun) PARAMS ((char *, int));
2927
     char *doc;
2928
{
2929
  return add_cmd (name, no_class, fun, doc, &infolist);
2930
}
2931
 
2932
/* Add an alias to the list of info subcommands.  */
2933
 
2934
struct cmd_list_element *
2935
add_info_alias (name, oldname, abbrev_flag)
2936
     char *name;
2937
     char *oldname;
2938
     int abbrev_flag;
2939
{
2940
  return add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist);
2941
}
2942
 
2943
/* The "info" command is defined as a prefix, with allow_unknown = 0.
2944
   Therefore, its own definition is called only for "info" with no args.  */
2945
 
2946
/* ARGSUSED */
2947
static void
2948
info_command (arg, from_tty)
2949
     char *arg;
2950
     int from_tty;
2951
{
2952
  printf_unfiltered ("\"info\" must be followed by the name of an info command.\n");
2953
  help_list (infolist, "info ", -1, gdb_stdout);
2954
}
2955
 
2956
/* The "complete" command is used by Emacs to implement completion.  */
2957
 
2958
/* ARGSUSED */
2959
static void
2960
complete_command (arg, from_tty)
2961
     char *arg;
2962
     int from_tty;
2963
{
2964
  int i;
2965
  int argpoint;
2966
  char *completion;
2967
 
2968
  dont_repeat ();
2969
 
2970
  if (arg == NULL)
2971
    arg = "";
2972
  argpoint = strlen (arg);
2973
 
2974
  for (completion = line_completion_function (arg, i = 0, arg, argpoint);
2975
       completion;
2976
       completion = line_completion_function (arg, ++i, arg, argpoint))
2977
    {
2978
      printf_unfiltered ("%s\n", completion);
2979
      free (completion);
2980
    }
2981
}
2982
 
2983
/* The "show" command with no arguments shows all the settings.  */
2984
 
2985
/* ARGSUSED */
2986
static void
2987
show_command (arg, from_tty)
2988
     char *arg;
2989
     int from_tty;
2990
{
2991
  cmd_show_list (showlist, from_tty, "");
2992
}
2993
 
2994
/* Add an element to the list of commands.  */
2995
 
2996
struct cmd_list_element *
2997
add_com (name, class, fun, doc)
2998
     char *name;
2999
     enum command_class class;
3000
     void (*fun) PARAMS ((char *, int));
3001
     char *doc;
3002
{
3003
  return add_cmd (name, class, fun, doc, &cmdlist);
3004
}
3005
 
3006
/* Add an alias or abbreviation command to the list of commands.  */
3007
 
3008
struct cmd_list_element *
3009
add_com_alias (name, oldname, class, abbrev_flag)
3010
     char *name;
3011
     char *oldname;
3012
     enum command_class class;
3013
     int abbrev_flag;
3014
{
3015
  return add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist);
3016
}
3017
 
3018
void
3019
error_no_arg (why)
3020
     char *why;
3021
{
3022
  error ("Argument required (%s).", why);
3023
}
3024
 
3025
/* ARGSUSED */
3026
static void
3027
help_command (command, from_tty)
3028
     char *command;
3029
     int from_tty;              /* Ignored */
3030
{
3031
  help_cmd (command, gdb_stdout);
3032
}
3033
 
3034
static void
3035
validate_comname (comname)
3036
     char *comname;
3037
{
3038
  register char *p;
3039
 
3040
  if (comname == 0)
3041
    error_no_arg ("name of command to define");
3042
 
3043
  p = comname;
3044
  while (*p)
3045
    {
3046
      if (!isalnum (*p) && *p != '-' && *p != '_')
3047
        error ("Junk in argument list: \"%s\"", p);
3048
      p++;
3049
    }
3050
}
3051
 
3052
/* This is just a placeholder in the command data structures.  */
3053
static void
3054
user_defined_command (ignore, from_tty)
3055
     char *ignore;
3056
     int from_tty;
3057
{
3058
}
3059
 
3060
static void
3061
define_command (comname, from_tty)
3062
     char *comname;
3063
     int from_tty;
3064
{
3065
  register struct command_line *cmds;
3066
  register struct cmd_list_element *c, *newc, *hookc = 0;
3067
  char *tem = comname;
3068
  char tmpbuf[128];
3069
#define HOOK_STRING     "hook-"
3070
#define HOOK_LEN 5
3071
 
3072
  validate_comname (comname);
3073
 
3074
  /* Look it up, and verify that we got an exact match.  */
3075
  c = lookup_cmd (&tem, cmdlist, "", -1, 1);
3076
  if (c && !STREQ (comname, c->name))
3077
    c = 0;
3078
 
3079
  if (c)
3080
    {
3081
      if (c->class == class_user || c->class == class_alias)
3082
        tem = "Redefine command \"%s\"? ";
3083
      else
3084
        tem = "Really redefine built-in command \"%s\"? ";
3085
      if (!query (tem, c->name))
3086
        error ("Command \"%s\" not redefined.", c->name);
3087
    }
3088
 
3089
  /* If this new command is a hook, then mark the command which it
3090
     is hooking.  Note that we allow hooking `help' commands, so that
3091
     we can hook the `stop' pseudo-command.  */
3092
 
3093
  if (!strncmp (comname, HOOK_STRING, HOOK_LEN))
3094
    {
3095
      /* Look up cmd it hooks, and verify that we got an exact match.  */
3096
      tem = comname + HOOK_LEN;
3097
      hookc = lookup_cmd (&tem, cmdlist, "", -1, 0);
3098
      if (hookc && !STREQ (comname + HOOK_LEN, hookc->name))
3099
        hookc = 0;
3100
      if (!hookc)
3101
        {
3102
          warning ("Your new `%s' command does not hook any existing command.",
3103
                   comname);
3104
          if (!query ("Proceed? "))
3105
            error ("Not confirmed.");
3106
        }
3107
    }
3108
 
3109
  comname = savestring (comname, strlen (comname));
3110
 
3111
  /* If the rest of the commands will be case insensitive, this one
3112
     should behave in the same manner. */
3113
  for (tem = comname; *tem; tem++)
3114
    if (isupper (*tem))
3115
      *tem = tolower (*tem);
3116
 
3117
  sprintf (tmpbuf, "Type commands for definition of \"%s\".", comname);
3118
  cmds = read_command_lines (tmpbuf, from_tty);
3119
 
3120
  if (c && c->class == class_user)
3121
    free_command_lines (&c->user_commands);
3122
 
3123
  newc = add_cmd (comname, class_user, user_defined_command,
3124
                  (c && c->class == class_user)
3125
                  ? c->doc : savestring ("User-defined.", 13), &cmdlist);
3126
  newc->user_commands = cmds;
3127
 
3128
  /* If this new command is a hook, then mark both commands as being
3129
     tied.  */
3130
  if (hookc)
3131
    {
3132
      hookc->hook = newc;       /* Target gets hooked.  */
3133
      newc->hookee = hookc;     /* We are marked as hooking target cmd.  */
3134
    }
3135
}
3136
 
3137
static void
3138
document_command (comname, from_tty)
3139
     char *comname;
3140
     int from_tty;
3141
{
3142
  struct command_line *doclines;
3143
  register struct cmd_list_element *c;
3144
  char *tem = comname;
3145
  char tmpbuf[128];
3146
 
3147
  validate_comname (comname);
3148
 
3149
  c = lookup_cmd (&tem, cmdlist, "", 0, 1);
3150
 
3151
  if (c->class != class_user)
3152
    error ("Command \"%s\" is built-in.", comname);
3153
 
3154
  sprintf (tmpbuf, "Type documentation for \"%s\".", comname);
3155
  doclines = read_command_lines (tmpbuf, from_tty);
3156
 
3157
  if (c->doc)
3158
    free (c->doc);
3159
 
3160
  {
3161
    register struct command_line *cl1;
3162
    register int len = 0;
3163
 
3164
    for (cl1 = doclines; cl1; cl1 = cl1->next)
3165
      len += strlen (cl1->line) + 1;
3166
 
3167
    c->doc = (char *) xmalloc (len + 1);
3168
    *c->doc = 0;
3169
 
3170
    for (cl1 = doclines; cl1; cl1 = cl1->next)
3171
      {
3172
        strcat (c->doc, cl1->line);
3173
        if (cl1->next)
3174
          strcat (c->doc, "\n");
3175
      }
3176
  }
3177
 
3178
  free_command_lines (&doclines);
3179
}
3180
 
3181
/* Print the GDB banner. */
3182
void
3183
print_gdb_version (stream)
3184
     struct ui_file *stream;
3185
{
3186
  /* From GNU coding standards, first line is meant to be easy for a
3187
     program to parse, and is just canonical program name and version
3188
     number, which starts after last space. */
3189
 
3190
#ifdef UI_OUT
3191
  /* Print it console style until a format is defined */
3192
  fprintf_filtered (stream, "GNU gdb %s (UI_OUT)\n", version);
3193
#else
3194
  fprintf_filtered (stream, "GNU gdb %s\n", version);
3195
#endif
3196
 
3197
  /* Second line is a copyright notice. */
3198
 
3199
  fprintf_filtered (stream, "Copyright 2000 Free Software Foundation, Inc.\n");
3200
 
3201
  /* Following the copyright is a brief statement that the program is
3202
     free software, that users are free to copy and change it on
3203
     certain conditions, that it is covered by the GNU GPL, and that
3204
     there is no warranty. */
3205
 
3206
  fprintf_filtered (stream, "\
3207
GDB is free software, covered by the GNU General Public License, and you are\n\
3208
welcome to change it and/or distribute copies of it under certain conditions.\n\
3209
Type \"show copying\" to see the conditions.\n\
3210
There is absolutely no warranty for GDB.  Type \"show warranty\" for details.\n");
3211
 
3212
  /* After the required info we print the configuration information. */
3213
 
3214
  fprintf_filtered (stream, "This GDB was configured as \"");
3215
  if (!STREQ (host_name, target_name))
3216
    {
3217
      fprintf_filtered (stream, "--host=%s --target=%s", host_name, target_name);
3218
    }
3219
  else
3220
    {
3221
      fprintf_filtered (stream, "%s", host_name);
3222
    }
3223
  fprintf_filtered (stream, "\".");
3224
}
3225
 
3226
/* ARGSUSED */
3227
static void
3228
show_version (args, from_tty)
3229
     char *args;
3230
     int from_tty;
3231
{
3232
  immediate_quit++;
3233
  print_gdb_version (gdb_stdout);
3234
  printf_filtered ("\n");
3235
  immediate_quit--;
3236
}
3237
 
3238
/* get_prompt: access method for the GDB prompt string.  */
3239
 
3240
#define MAX_PROMPT_SIZE 256
3241
 
3242
/*
3243
 * int get_prompt_1 (char * buf);
3244
 *
3245
 * Work-horse for get_prompt (called via catch_errors).
3246
 * Argument is buffer to hold the formatted prompt.
3247
 *
3248
 * Returns: 1 for success (use formatted prompt)
3249
 *          0 for failure (use gdb_prompt_string).
3250
 */
3251
 
3252
static int gdb_prompt_escape;
3253
 
3254
static int
3255
get_prompt_1 (formatted_prompt)
3256
     char *formatted_prompt;
3257
{
3258
  char *local_prompt;
3259
 
3260
  if (event_loop_p)
3261
    local_prompt = PROMPT (0);
3262
  else
3263
    local_prompt = gdb_prompt_string;
3264
 
3265
 
3266
  if (gdb_prompt_escape == 0)
3267
    {
3268
      return 0;                  /* do no formatting */
3269
    }
3270
  else
3271
    /* formatted prompt */
3272
    {
3273
      char fmt[40], *promptp, *outp, *tmp;
3274
      value_ptr arg_val;
3275
      DOUBLEST doubleval;
3276
      LONGEST longval;
3277
      CORE_ADDR addrval;
3278
 
3279
      int i, len;
3280
      struct type *arg_type, *elt_type;
3281
 
3282
      promptp = local_prompt;
3283
      outp = formatted_prompt;
3284
 
3285
      while (*promptp != '\0')
3286
        {
3287
          int available = MAX_PROMPT_SIZE - (outp - formatted_prompt) - 1;
3288
 
3289
          if (*promptp != gdb_prompt_escape)
3290
            {
3291
              if (available >= 1)       /* overflow protect */
3292
                *outp++ = *promptp++;
3293
            }
3294
          else
3295
            {
3296
              /* GDB prompt string contains escape char.  Parse for arg.
3297
                 Two consecutive escape chars followed by arg followed by
3298
                 a comma means to insert the arg using a default format.
3299
                 Otherwise a printf format string may be included between
3300
                 the two escape chars.  eg:
3301
                 %%foo, insert foo using default format
3302
                 %2.2f%foo,     insert foo using "%2.2f" format
3303
                 A mismatch between the format string and the data type
3304
                 of "foo" is an error (which we don't know how to protect
3305
                 against).  */
3306
 
3307
              fmt[0] = '\0';     /* assume null format string */
3308
              if (promptp[1] == gdb_prompt_escape)      /* double esc char */
3309
                {
3310
                  promptp += 2; /* skip past two escape chars. */
3311
                }
3312
              else
3313
                {
3314
                  /* extract format string from between two esc chars */
3315
                  i = 0;
3316
                  do
3317
                    {
3318
                      fmt[i++] = *promptp++;    /* copy format string */
3319
                    }
3320
                  while (i < sizeof (fmt) - 1 &&
3321
                         *promptp != gdb_prompt_escape &&
3322
                         *promptp != '\0');
3323
 
3324
                  if (*promptp != gdb_prompt_escape)
3325
                    error ("Syntax error at prompt position %d",
3326
                           promptp - local_prompt);
3327
                  else
3328
                    {
3329
                      promptp++;        /* skip second escape char */
3330
                      fmt[i++] = '\0';  /* terminate the format string */
3331
                    }
3332
                }
3333
 
3334
              arg_val = parse_to_comma_and_eval (&promptp);
3335
              if (*promptp == ',')
3336
                promptp++;      /* skip past the comma */
3337
              arg_type = check_typedef (VALUE_TYPE (arg_val));
3338
              switch (TYPE_CODE (arg_type))
3339
                {
3340
                case TYPE_CODE_ARRAY:
3341
                  elt_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
3342
                  if (TYPE_LENGTH (arg_type) > 0 &&
3343
                      TYPE_LENGTH (elt_type) == 1 &&
3344
                      TYPE_CODE (elt_type) == TYPE_CODE_INT)
3345
                    {
3346
                      int len = TYPE_LENGTH (arg_type);
3347
 
3348
                      if (VALUE_LAZY (arg_val))
3349
                        value_fetch_lazy (arg_val);
3350
                      tmp = VALUE_CONTENTS (arg_val);
3351
 
3352
                      if (len > available)
3353
                        len = available;        /* overflow protect */
3354
 
3355
                      /* FIXME: how to protect GDB from crashing
3356
                         from bad user-supplied format string? */
3357
                      if (fmt[0] != 0)
3358
                        sprintf (outp, fmt, tmp);
3359
                      else
3360
                        strncpy (outp, tmp, len);
3361
                      outp[len] = '\0';
3362
                    }
3363
                  break;
3364
                case TYPE_CODE_PTR:
3365
                  elt_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
3366
                  addrval = value_as_pointer (arg_val);
3367
 
3368
                  if (TYPE_LENGTH (elt_type) == 1 &&
3369
                      TYPE_CODE (elt_type) == TYPE_CODE_INT &&
3370
                      addrval != 0)
3371
                    {
3372
                      /* display it as a string */
3373
                      char *default_fmt = "%s";
3374
                      char *tmp;
3375
                      int err = 0;
3376
 
3377
                      /* Limiting the number of bytes that the following call
3378
                         will read protects us from sprintf overflow later. */
3379
                      i = target_read_string (addrval,  /* src */
3380
                                              &tmp,     /* dest */
3381
                                              available,        /* len */
3382
                                              &err);
3383
                      if (err)  /* read failed */
3384
                        error ("%s on target_read", safe_strerror (err));
3385
 
3386
                      tmp[i] = '\0';    /* force-terminate string */
3387
                      /* FIXME: how to protect GDB from crashing
3388
                         from bad user-supplied format string? */
3389
                      sprintf (outp, fmt[0] == 0 ? default_fmt : fmt,
3390
                               tmp);
3391
                      free (tmp);
3392
                    }
3393
                  else
3394
                    {
3395
                      /* display it as a pointer */
3396
                      char *default_fmt = "0x%x";
3397
 
3398
                      /* FIXME: how to protect GDB from crashing
3399
                         from bad user-supplied format string? */
3400
                      if (available >= 16 /*? */ )      /* overflow protect */
3401
                        sprintf (outp, fmt[0] == 0 ? default_fmt : fmt,
3402
                                 (long) addrval);
3403
                    }
3404
                  break;
3405
                case TYPE_CODE_FLT:
3406
                  {
3407
                    char *default_fmt = "%g";
3408
 
3409
                    doubleval = value_as_double (arg_val);
3410
                    /* FIXME: how to protect GDB from crashing
3411
                       from bad user-supplied format string? */
3412
                    if (available >= 16 /*? */ )        /* overflow protect */
3413
                      sprintf (outp, fmt[0] == 0 ? default_fmt : fmt,
3414
                               (double) doubleval);
3415
                    break;
3416
                  }
3417
                case TYPE_CODE_INT:
3418
                  {
3419
                    char *default_fmt = "%d";
3420
 
3421
                    longval = value_as_long (arg_val);
3422
                    /* FIXME: how to protect GDB from crashing
3423
                       from bad user-supplied format string? */
3424
                    if (available >= 16 /*? */ )        /* overflow protect */
3425
                      sprintf (outp, fmt[0] == 0 ? default_fmt : fmt,
3426
                               (long) longval);
3427
                    break;
3428
                  }
3429
                case TYPE_CODE_BOOL:
3430
                  {
3431
                    /* no default format for bool */
3432
                    longval = value_as_long (arg_val);
3433
                    if (available >= 8 /*? */ )         /* overflow protect */
3434
                      {
3435
                        if (longval)
3436
                          strcpy (outp, "<true>");
3437
                        else
3438
                          strcpy (outp, "<false>");
3439
                      }
3440
                    break;
3441
                  }
3442
                case TYPE_CODE_ENUM:
3443
                  {
3444
                    /* no default format for enum */
3445
                    longval = value_as_long (arg_val);
3446
                    len = TYPE_NFIELDS (arg_type);
3447
                    /* find enum name if possible */
3448
                    for (i = 0; i < len; i++)
3449
                      if (TYPE_FIELD_BITPOS (arg_type, i) == longval)
3450
                        break;  /* match -- end loop */
3451
 
3452
                    if (i < len)        /* enum name found */
3453
                      {
3454
                        char *name = TYPE_FIELD_NAME (arg_type, i);
3455
 
3456
                        strncpy (outp, name, available);
3457
                        /* in casel available < strlen (name), */
3458
                        outp[available] = '\0';
3459
                      }
3460
                    else
3461
                      {
3462
                        if (available >= 16 /*? */ )    /* overflow protect */
3463
                          sprintf (outp, "%ld", (long) longval);
3464
                      }
3465
                    break;
3466
                  }
3467
                case TYPE_CODE_VOID:
3468
                  *outp = '\0';
3469
                  break;        /* void type -- no output */
3470
                default:
3471
                  error ("bad data type at prompt position %d",
3472
                         promptp - local_prompt);
3473
                  break;
3474
                }
3475
              outp += strlen (outp);
3476
            }
3477
        }
3478
      *outp++ = '\0';           /* terminate prompt string */
3479
      return 1;
3480
    }
3481
}
3482
 
3483
char *
3484
get_prompt ()
3485
{
3486
  static char buf[MAX_PROMPT_SIZE];
3487
 
3488
  if (catch_errors (get_prompt_1, buf, "bad formatted prompt: ",
3489
                    RETURN_MASK_ALL))
3490
    {
3491
      return &buf[0];            /* successful formatted prompt */
3492
    }
3493
  else
3494
    {
3495
      /* Prompt could not be formatted.  */
3496
      if (event_loop_p)
3497
        return PROMPT (0);
3498
      else
3499
        return gdb_prompt_string;
3500
    }
3501
}
3502
 
3503
void
3504
set_prompt (s)
3505
     char *s;
3506
{
3507
/* ??rehrauer: I don't know why this fails, since it looks as though
3508
   assignments to prompt are wrapped in calls to savestring...
3509
   if (prompt != NULL)
3510
   free (prompt);
3511
 */
3512
  if (event_loop_p)
3513
    PROMPT (0) = savestring (s, strlen (s));
3514
  else
3515
    gdb_prompt_string = savestring (s, strlen (s));
3516
}
3517
 
3518
 
3519
/* If necessary, make the user confirm that we should quit.  Return
3520
   non-zero if we should quit, zero if we shouldn't.  */
3521
 
3522
int
3523
quit_confirm ()
3524
{
3525
  if (inferior_pid != 0 && target_has_execution)
3526
    {
3527
      char *s;
3528
 
3529
      /* This is something of a hack.  But there's no reliable way to
3530
         see if a GUI is running.  The `use_windows' variable doesn't
3531
         cut it.  */
3532
      if (init_ui_hook)
3533
        s = "A debugging session is active.\nDo you still want to close the debugger?";
3534
      else if (attach_flag)
3535
        s = "The program is running.  Quit anyway (and detach it)? ";
3536
      else
3537
        s = "The program is running.  Exit anyway? ";
3538
 
3539
      if (!query (s))
3540
        return 0;
3541
    }
3542
 
3543
  return 1;
3544
}
3545
 
3546
/* Quit without asking for confirmation.  */
3547
 
3548
void
3549
quit_force (args, from_tty)
3550
     char *args;
3551
     int from_tty;
3552
{
3553
  int exit_code = 0;
3554
 
3555
  /* An optional expression may be used to cause gdb to terminate with the
3556
     value of that expression. */
3557
  if (args)
3558
    {
3559
      value_ptr val = parse_and_eval (args);
3560
 
3561
      exit_code = (int) value_as_long (val);
3562
    }
3563
 
3564
  if (inferior_pid != 0 && target_has_execution)
3565
    {
3566
      if (attach_flag)
3567
        target_detach (args, from_tty);
3568
      else
3569
        target_kill ();
3570
    }
3571
 
3572
  /* UDI wants this, to kill the TIP.  */
3573
  target_close (1);
3574
 
3575
  /* Save the history information if it is appropriate to do so.  */
3576
  if (write_history_p && history_filename)
3577
    write_history (history_filename);
3578
 
3579
  do_final_cleanups (ALL_CLEANUPS);     /* Do any final cleanups before exiting */
3580
 
3581
#if defined(TUI)
3582
  /* tuiDo((TuiOpaqueFuncPtr)tuiCleanUp); */
3583
  /* The above does not need to be inside a tuiDo(), since
3584
   * it is not manipulating the curses screen, but rather,
3585
   * it is tearing it down.
3586
   */
3587
  if (tui_version)
3588
    tuiCleanUp ();
3589
#endif
3590
 
3591
  exit (exit_code);
3592
}
3593
 
3594
/* Handle the quit command.  */
3595
 
3596
void
3597
quit_command (args, from_tty)
3598
     char *args;
3599
     int from_tty;
3600
{
3601
  if (!quit_confirm ())
3602
    error ("Not confirmed.");
3603
  quit_force (args, from_tty);
3604
}
3605
 
3606
/* Returns whether GDB is running on a terminal and whether the user
3607
   desires that questions be asked of them on that terminal.  */
3608
 
3609
int
3610
input_from_terminal_p ()
3611
{
3612
  return gdb_has_a_terminal () && (instream == stdin) & caution;
3613
}
3614
 
3615
/* ARGSUSED */
3616
static void
3617
pwd_command (args, from_tty)
3618
     char *args;
3619
     int from_tty;
3620
{
3621
  if (args)
3622
    error ("The \"pwd\" command does not take an argument: %s", args);
3623
  getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
3624
 
3625
  if (!STREQ (gdb_dirbuf, current_directory))
3626
    printf_unfiltered ("Working directory %s\n (canonically %s).\n",
3627
                       current_directory, gdb_dirbuf);
3628
  else
3629
    printf_unfiltered ("Working directory %s.\n", current_directory);
3630
}
3631
 
3632
void
3633
cd_command (dir, from_tty)
3634
     char *dir;
3635
     int from_tty;
3636
{
3637
  int len;
3638
  /* Found something other than leading repetitions of "/..".  */
3639
  int found_real_path;
3640
  char *p;
3641
 
3642
  /* If the new directory is absolute, repeat is a no-op; if relative,
3643
     repeat might be useful but is more likely to be a mistake.  */
3644
  dont_repeat ();
3645
 
3646
  if (dir == 0)
3647
    error_no_arg ("new working directory");
3648
 
3649
  dir = tilde_expand (dir);
3650
  make_cleanup (free, dir);
3651
 
3652
  if (chdir (dir) < 0)
3653
    perror_with_name (dir);
3654
 
3655
#if defined(_WIN32) || defined(__MSDOS__)
3656
  /* There's too much mess with DOSish names like "d:", "d:.",
3657
     "d:./foo" etc.  Instead of having lots of special #ifdef'ed code,
3658
     simply get the canonicalized name of the current directory.  */
3659
  dir = getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
3660
#endif
3661
 
3662
  len = strlen (dir);
3663
  if (SLASH_P (dir[len - 1]))
3664
    {
3665
      /* Remove the trailing slash unless this is a root directory
3666
         (including a drive letter on non-Unix systems).  */
3667
      if (!(len == 1)           /* "/" */
3668
#if defined(_WIN32) || defined(__MSDOS__)
3669
          && !(!SLASH_P (*dir) && ROOTED_P (dir) && len <= 3)   /* "d:/" */
3670
#endif
3671
          )
3672
        len--;
3673
    }
3674
 
3675
  dir = savestring (dir, len);
3676
  if (ROOTED_P (dir))
3677
    current_directory = dir;
3678
  else
3679
    {
3680
      if (SLASH_P (current_directory[strlen (current_directory) - 1]))
3681
        current_directory = concat (current_directory, dir, NULL);
3682
      else
3683
        current_directory = concat (current_directory, SLASH_STRING, dir, NULL);
3684
      free (dir);
3685
    }
3686
 
3687
  /* Now simplify any occurrences of `.' and `..' in the pathname.  */
3688
 
3689
  found_real_path = 0;
3690
  for (p = current_directory; *p;)
3691
    {
3692
      if (SLASH_P (p[0]) && p[1] == '.' && (p[2] == 0 || SLASH_P (p[2])))
3693
        strcpy (p, p + 2);
3694
      else if (SLASH_P (p[0]) && p[1] == '.' && p[2] == '.'
3695
               && (p[3] == 0 || SLASH_P (p[3])))
3696
        {
3697
          if (found_real_path)
3698
            {
3699
              /* Search backwards for the directory just before the "/.."
3700
                 and obliterate it and the "/..".  */
3701
              char *q = p;
3702
              while (q != current_directory && !SLASH_P (q[-1]))
3703
                --q;
3704
 
3705
              if (q == current_directory)
3706
                /* current_directory is
3707
                   a relative pathname ("can't happen"--leave it alone).  */
3708
                ++p;
3709
              else
3710
                {
3711
                  strcpy (q - 1, p + 3);
3712
                  p = q - 1;
3713
                }
3714
            }
3715
          else
3716
            /* We are dealing with leading repetitions of "/..", for example
3717
               "/../..", which is the Mach super-root.  */
3718
            p += 3;
3719
        }
3720
      else
3721
        {
3722
          found_real_path = 1;
3723
          ++p;
3724
        }
3725
    }
3726
 
3727
  forget_cached_source_info ();
3728
 
3729
  if (from_tty)
3730
    pwd_command ((char *) 0, 1);
3731
}
3732
 
3733
struct source_cleanup_lines_args
3734
{
3735
  int old_line;
3736
  char *old_file;
3737
  char *old_pre_error;
3738
  char *old_error_pre_print;
3739
};
3740
 
3741
static void
3742
source_cleanup_lines (args)
3743
     PTR args;
3744
{
3745
  struct source_cleanup_lines_args *p =
3746
  (struct source_cleanup_lines_args *) args;
3747
  source_line_number = p->old_line;
3748
  source_file_name = p->old_file;
3749
  source_pre_error = p->old_pre_error;
3750
  error_pre_print = p->old_error_pre_print;
3751
}
3752
 
3753
/* ARGSUSED */
3754
void
3755
source_command (args, from_tty)
3756
     char *args;
3757
     int from_tty;
3758
{
3759
  FILE *stream;
3760
  struct cleanup *old_cleanups;
3761
  char *file = args;
3762
  struct source_cleanup_lines_args old_lines;
3763
  int needed_length;
3764
 
3765
  if (file == NULL)
3766
    {
3767
      error ("source command requires pathname of file to source.");
3768
    }
3769
 
3770
  file = tilde_expand (file);
3771
  old_cleanups = make_cleanup (free, file);
3772
 
3773
  stream = fopen (file, FOPEN_RT);
3774
  if (!stream)
3775
    {
3776
      if (from_tty)
3777
        perror_with_name (file);
3778
      else
3779
        return;
3780
    }
3781
 
3782
  make_cleanup ((make_cleanup_func) fclose, stream);
3783
 
3784
  old_lines.old_line = source_line_number;
3785
  old_lines.old_file = source_file_name;
3786
  old_lines.old_pre_error = source_pre_error;
3787
  old_lines.old_error_pre_print = error_pre_print;
3788
  make_cleanup (source_cleanup_lines, &old_lines);
3789
  source_line_number = 0;
3790
  source_file_name = file;
3791
  source_pre_error = error_pre_print == NULL ? "" : error_pre_print;
3792
  source_pre_error = savestring (source_pre_error, strlen (source_pre_error));
3793
  make_cleanup (free, source_pre_error);
3794
  /* This will get set every time we read a line.  So it won't stay "" for
3795
     long.  */
3796
  error_pre_print = "";
3797
 
3798
  needed_length = strlen (source_file_name) + strlen (source_pre_error) + 80;
3799
  if (source_error_allocated < needed_length)
3800
    {
3801
      source_error_allocated *= 2;
3802
      if (source_error_allocated < needed_length)
3803
        source_error_allocated = needed_length;
3804
      if (source_error == NULL)
3805
        source_error = xmalloc (source_error_allocated);
3806
      else
3807
        source_error = xrealloc (source_error, source_error_allocated);
3808
    }
3809
 
3810
  read_command_file (stream);
3811
 
3812
  do_cleanups (old_cleanups);
3813
}
3814
 
3815
/* ARGSUSED */
3816
static void
3817
echo_command (text, from_tty)
3818
     char *text;
3819
     int from_tty;
3820
{
3821
  char *p = text;
3822
  register int c;
3823
 
3824
  if (text)
3825
    while ((c = *p++) != '\0')
3826
      {
3827
        if (c == '\\')
3828
          {
3829
            /* \ at end of argument is used after spaces
3830
               so they won't be lost.  */
3831
            if (*p == 0)
3832
              return;
3833
 
3834
            c = parse_escape (&p);
3835
            if (c >= 0)
3836
              printf_filtered ("%c", c);
3837
          }
3838
        else
3839
          printf_filtered ("%c", c);
3840
      }
3841
 
3842
  /* Force this output to appear now.  */
3843
  wrap_here ("");
3844
  gdb_flush (gdb_stdout);
3845
}
3846
 
3847
/* ARGSUSED */
3848
static void
3849
dont_repeat_command (ignored, from_tty)
3850
     char *ignored;
3851
     int from_tty;
3852
{
3853
  *line = 0;                     /* Can't call dont_repeat here because we're not
3854
                                   necessarily reading from stdin.  */
3855
}
3856
 
3857
/* Functions to manipulate command line editing control variables.  */
3858
 
3859
/* Number of commands to print in each call to show_commands.  */
3860
#define Hist_print 10
3861
static void
3862
show_commands (args, from_tty)
3863
     char *args;
3864
     int from_tty;
3865
{
3866
  /* Index for history commands.  Relative to history_base.  */
3867
  int offset;
3868
 
3869
  /* Number of the history entry which we are planning to display next.
3870
     Relative to history_base.  */
3871
  static int num = 0;
3872
 
3873
  /* The first command in the history which doesn't exist (i.e. one more
3874
     than the number of the last command).  Relative to history_base.  */
3875
  int hist_len;
3876
 
3877
  extern HIST_ENTRY *history_get PARAMS ((int));
3878
 
3879
  /* Print out some of the commands from the command history.  */
3880
  /* First determine the length of the history list.  */
3881
  hist_len = history_size;
3882
  for (offset = 0; offset < history_size; offset++)
3883
    {
3884
      if (!history_get (history_base + offset))
3885
        {
3886
          hist_len = offset;
3887
          break;
3888
        }
3889
    }
3890
 
3891
  if (args)
3892
    {
3893
      if (args[0] == '+' && args[1] == '\0')
3894
        /* "info editing +" should print from the stored position.  */
3895
        ;
3896
      else
3897
        /* "info editing <exp>" should print around command number <exp>.  */
3898
        num = (parse_and_eval_address (args) - history_base) - Hist_print / 2;
3899
    }
3900
  /* "show commands" means print the last Hist_print commands.  */
3901
  else
3902
    {
3903
      num = hist_len - Hist_print;
3904
    }
3905
 
3906
  if (num < 0)
3907
    num = 0;
3908
 
3909
  /* If there are at least Hist_print commands, we want to display the last
3910
     Hist_print rather than, say, the last 6.  */
3911
  if (hist_len - num < Hist_print)
3912
    {
3913
      num = hist_len - Hist_print;
3914
      if (num < 0)
3915
        num = 0;
3916
    }
3917
 
3918
  for (offset = num; offset < num + Hist_print && offset < hist_len; offset++)
3919
    {
3920
      printf_filtered ("%5d  %s\n", history_base + offset,
3921
                       (history_get (history_base + offset))->line);
3922
    }
3923
 
3924
  /* The next command we want to display is the next one that we haven't
3925
     displayed yet.  */
3926
  num += Hist_print;
3927
 
3928
  /* If the user repeats this command with return, it should do what
3929
     "show commands +" does.  This is unnecessary if arg is null,
3930
     because "show commands +" is not useful after "show commands".  */
3931
  if (from_tty && args)
3932
    {
3933
      args[0] = '+';
3934
      args[1] = '\0';
3935
    }
3936
}
3937
 
3938
/* Called by do_setshow_command.  */
3939
/* ARGSUSED */
3940
static void
3941
set_history_size_command (args, from_tty, c)
3942
     char *args;
3943
     int from_tty;
3944
     struct cmd_list_element *c;
3945
{
3946
  if (history_size == INT_MAX)
3947
    unstifle_history ();
3948
  else if (history_size >= 0)
3949
    stifle_history (history_size);
3950
  else
3951
    {
3952
      history_size = INT_MAX;
3953
      error ("History size must be non-negative");
3954
    }
3955
}
3956
 
3957
/* ARGSUSED */
3958
static void
3959
set_history (args, from_tty)
3960
     char *args;
3961
     int from_tty;
3962
{
3963
  printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n");
3964
  help_list (sethistlist, "set history ", -1, gdb_stdout);
3965
}
3966
 
3967
/* ARGSUSED */
3968
static void
3969
show_history (args, from_tty)
3970
     char *args;
3971
     int from_tty;
3972
{
3973
  cmd_show_list (showhistlist, from_tty, "");
3974
}
3975
 
3976
int info_verbose = 0;            /* Default verbose msgs off */
3977
 
3978
/* Called by do_setshow_command.  An elaborate joke.  */
3979
/* ARGSUSED */
3980
static void
3981
set_verbose (args, from_tty, c)
3982
     char *args;
3983
     int from_tty;
3984
     struct cmd_list_element *c;
3985
{
3986
  char *cmdname = "verbose";
3987
  struct cmd_list_element *showcmd;
3988
 
3989
  showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1);
3990
 
3991
  if (info_verbose)
3992
    {
3993
      c->doc = "Set verbose printing of informational messages.";
3994
      showcmd->doc = "Show verbose printing of informational messages.";
3995
    }
3996
  else
3997
    {
3998
      c->doc = "Set verbosity.";
3999
      showcmd->doc = "Show verbosity.";
4000
    }
4001
}
4002
 
4003
static void
4004
float_handler (signo)
4005
     int signo;
4006
{
4007
  /* This message is based on ANSI C, section 4.7.  Note that integer
4008
     divide by zero causes this, so "float" is a misnomer.  */
4009
  signal (SIGFPE, float_handler);
4010
  error ("Erroneous arithmetic operation.");
4011
}
4012
 
4013
static void
4014
set_debug (arg, from_tty)
4015
     char *arg;
4016
     int from_tty;
4017
{
4018
  printf_unfiltered ("\"set debug\" must be followed by the name of a print subcommand.\n");
4019
  help_list (setdebuglist, "set debug ", -1, gdb_stdout);
4020
}
4021
 
4022
static void
4023
show_debug (args, from_tty)
4024
     char *args;
4025
     int from_tty;
4026
{
4027
  cmd_show_list (showdebuglist, from_tty, "");
4028
}
4029
 
4030
static void
4031
init_cmd_lists ()
4032
{
4033
  cmdlist = NULL;
4034
  infolist = NULL;
4035
  enablelist = NULL;
4036
  disablelist = NULL;
4037
  togglelist = NULL;
4038
  stoplist = NULL;
4039
  deletelist = NULL;
4040
  enablebreaklist = NULL;
4041
  setlist = NULL;
4042
  unsetlist = NULL;
4043
  showlist = NULL;
4044
  sethistlist = NULL;
4045
  showhistlist = NULL;
4046
  unsethistlist = NULL;
4047
  maintenancelist = NULL;
4048
  maintenanceinfolist = NULL;
4049
  maintenanceprintlist = NULL;
4050
  setprintlist = NULL;
4051
  showprintlist = NULL;
4052
  setchecklist = NULL;
4053
  showchecklist = NULL;
4054
}
4055
 
4056
/* Init the history buffer.  Note that we are called after the init file(s)
4057
 * have been read so that the user can change the history file via his
4058
 * .gdbinit file (for instance).  The GDBHISTFILE environment variable
4059
 * overrides all of this.
4060
 */
4061
 
4062
void
4063
init_history ()
4064
{
4065
  char *tmpenv;
4066
 
4067
  tmpenv = getenv ("HISTSIZE");
4068
  if (tmpenv)
4069
    history_size = atoi (tmpenv);
4070
  else if (!history_size)
4071
    history_size = 256;
4072
 
4073
  stifle_history (history_size);
4074
 
4075
  tmpenv = getenv ("GDBHISTFILE");
4076
  if (tmpenv)
4077
    history_filename = savestring (tmpenv, strlen (tmpenv));
4078
  else if (!history_filename)
4079
    {
4080
      /* We include the current directory so that if the user changes
4081
         directories the file written will be the same as the one
4082
         that was read.  */
4083
#ifdef __MSDOS__
4084
      /* No leading dots in file names are allowed on MSDOS.  */
4085
      history_filename = concat (current_directory, "/_gdb_history", NULL);
4086
#else
4087
      history_filename = concat (current_directory, "/.gdb_history", NULL);
4088
#endif
4089
    }
4090
  read_history (history_filename);
4091
}
4092
 
4093
static void
4094
init_main ()
4095
{
4096
  struct cmd_list_element *c;
4097
 
4098
  /* If we are running the asynchronous version,
4099
     we initialize the prompts differently. */
4100
  if (!event_loop_p)
4101
    {
4102
      gdb_prompt_string = savestring (DEFAULT_PROMPT, strlen (DEFAULT_PROMPT));
4103
    }
4104
  else
4105
    {
4106
      /* initialize the prompt stack to a simple "(gdb) " prompt or to
4107
         whatever the DEFAULT_PROMPT is. */
4108
      the_prompts.top = 0;
4109
      PREFIX (0) = "";
4110
      PROMPT (0) = savestring (DEFAULT_PROMPT, strlen (DEFAULT_PROMPT));
4111
      SUFFIX (0) = "";
4112
      /* Set things up for annotation_level > 1, if the user ever decides
4113
         to use it. */
4114
      async_annotation_suffix = "prompt";
4115
      /* Set the variable associated with the setshow prompt command. */
4116
      new_async_prompt = savestring (PROMPT (0), strlen (PROMPT (0)));
4117
    }
4118
  gdb_prompt_escape = 0; /* default to none.  */
4119
 
4120
  /* Set the important stuff up for command editing.  */
4121
  command_editing_p = 1;
4122
  history_expansion_p = 0;
4123
  write_history_p = 0;
4124
 
4125
  /* Setup important stuff for command line editing.  */
4126
  rl_completion_entry_function = (int (*)()) readline_line_completion_function;
4127
  rl_completer_word_break_characters = gdb_completer_word_break_characters;
4128
  rl_completer_quote_characters = gdb_completer_quote_characters;
4129
  rl_readline_name = "gdb";
4130
 
4131
  /* Define the classes of commands.
4132
     They will appear in the help list in the reverse of this order.  */
4133
 
4134
  add_cmd ("internals", class_maintenance, NO_FUNCTION,
4135
           "Maintenance commands.\n\
4136
Some gdb commands are provided just for use by gdb maintainers.\n\
4137
These commands are subject to frequent change, and may not be as\n\
4138
well documented as user commands.",
4139
           &cmdlist);
4140
  add_cmd ("obscure", class_obscure, NO_FUNCTION, "Obscure features.", &cmdlist);
4141
  add_cmd ("aliases", class_alias, NO_FUNCTION, "Aliases of other commands.", &cmdlist);
4142
  add_cmd ("user-defined", class_user, NO_FUNCTION, "User-defined commands.\n\
4143
The commands in this class are those defined by the user.\n\
4144
Use the \"define\" command to define a command.", &cmdlist);
4145
  add_cmd ("support", class_support, NO_FUNCTION, "Support facilities.", &cmdlist);
4146
  if (!dbx_commands)
4147
    add_cmd ("status", class_info, NO_FUNCTION, "Status inquiries.", &cmdlist);
4148
  add_cmd ("files", class_files, NO_FUNCTION, "Specifying and examining files.", &cmdlist);
4149
  add_cmd ("breakpoints", class_breakpoint, NO_FUNCTION, "Making program stop at certain points.", &cmdlist);
4150
  add_cmd ("data", class_vars, NO_FUNCTION, "Examining data.", &cmdlist);
4151
  add_cmd ("stack", class_stack, NO_FUNCTION, "Examining the stack.\n\
4152
The stack is made up of stack frames.  Gdb assigns numbers to stack frames\n\
4153
counting from zero for the innermost (currently executing) frame.\n\n\
4154
At any time gdb identifies one frame as the \"selected\" frame.\n\
4155
Variable lookups are done with respect to the selected frame.\n\
4156
When the program being debugged stops, gdb selects the innermost frame.\n\
4157
The commands below can be used to select other frames by number or address.",
4158
           &cmdlist);
4159
  add_cmd ("running", class_run, NO_FUNCTION, "Running the program.", &cmdlist);
4160
 
4161
  add_com ("pwd", class_files, pwd_command,
4162
        "Print working directory.  This is used for your program as well.");
4163
  c = add_cmd ("cd", class_files, cd_command,
4164
               "Set working directory to DIR for debugger and program being debugged.\n\
4165
The change does not take effect for the program being debugged\n\
4166
until the next time it is started.", &cmdlist);
4167
  c->completer = filename_completer;
4168
 
4169
  /* The set prompt command is different depending whether or not the
4170
     async version is run. NOTE: this difference is going to
4171
     disappear as we make the event loop be the default engine of
4172
     gdb. */
4173
  if (!event_loop_p)
4174
    {
4175
      add_show_from_set
4176
        (add_set_cmd ("prompt", class_support, var_string,
4177
                      (char *) &gdb_prompt_string, "Set gdb's prompt",
4178
                      &setlist),
4179
         &showlist);
4180
    }
4181
  else
4182
    {
4183
      c = add_set_cmd ("prompt", class_support, var_string,
4184
                       (char *) &new_async_prompt, "Set gdb's prompt",
4185
                       &setlist);
4186
      add_show_from_set (c, &showlist);
4187
      c->function.sfunc = set_async_prompt;
4188
    }
4189
 
4190
  add_show_from_set
4191
    (add_set_cmd ("prompt-escape-char", class_support, var_zinteger,
4192
                  (char *) &gdb_prompt_escape,
4193
                  "Set escape character for formatting of gdb's prompt",
4194
                  &setlist),
4195
     &showlist);
4196
 
4197
  add_com ("echo", class_support, echo_command,
4198
           "Print a constant string.  Give string as argument.\n\
4199
C escape sequences may be used in the argument.\n\
4200
No newline is added at the end of the argument;\n\
4201
use \"\\n\" if you want a newline to be printed.\n\
4202
Since leading and trailing whitespace are ignored in command arguments,\n\
4203
if you want to print some you must use \"\\\" before leading whitespace\n\
4204
to be printed or after trailing whitespace.");
4205
  add_com ("document", class_support, document_command,
4206
           "Document a user-defined command.\n\
4207
Give command name as argument.  Give documentation on following lines.\n\
4208
End with a line of just \"end\".");
4209
  add_com ("define", class_support, define_command,
4210
           "Define a new command name.  Command name is argument.\n\
4211
Definition appears on following lines, one command per line.\n\
4212
End with a line of just \"end\".\n\
4213
Use the \"document\" command to give documentation for the new command.\n\
4214
Commands defined in this way may have up to ten arguments.");
4215
 
4216
#ifdef __STDC__
4217
  c = add_cmd ("source", class_support, source_command,
4218
               "Read commands from a file named FILE.\n\
4219
Note that the file \"" GDBINIT_FILENAME "\" is read automatically in this way\n\
4220
when gdb is started.", &cmdlist);
4221
#else
4222
  /* Punt file name, we can't help it easily.  */
4223
  c = add_cmd ("source", class_support, source_command,
4224
               "Read commands from a file named FILE.\n\
4225
Note that the file \".gdbinit\" is read automatically in this way\n\
4226
when gdb is started.", &cmdlist);
4227
#endif
4228
  c->completer = filename_completer;
4229
 
4230
  add_com ("quit", class_support, quit_command, "Exit gdb.");
4231
  add_com ("help", class_support, help_command, "Print list of commands.");
4232
  add_com_alias ("q", "quit", class_support, 1);
4233
  add_com_alias ("h", "help", class_support, 1);
4234
 
4235
  add_com ("dont-repeat", class_support, dont_repeat_command, "Don't repeat this command.\n\
4236
Primarily used inside of user-defined commands that should not be repeated when\n\
4237
hitting return.");
4238
 
4239
  c = add_set_cmd ("verbose", class_support, var_boolean, (char *) &info_verbose,
4240
                   "Set ",
4241
                   &setlist),
4242
    add_show_from_set (c, &showlist);
4243
  c->function.sfunc = set_verbose;
4244
  set_verbose (NULL, 0, c);
4245
 
4246
  /* The set editing command is different depending whether or not the
4247
     async version is run. NOTE: this difference is going to disappear
4248
     as we make the event loop be the default engine of gdb. */
4249
  if (!event_loop_p)
4250
    {
4251
      add_show_from_set
4252
        (add_set_cmd ("editing", class_support, var_boolean, (char *) &command_editing_p,
4253
                      "Set editing of command lines as they are typed.\n\
4254
Use \"on\" to enable the editing, and \"off\" to disable it.\n\
4255
Without an argument, command line editing is enabled.  To edit, use\n\
4256
EMACS-like or VI-like commands like control-P or ESC.", &setlist),
4257
         &showlist);
4258
    }
4259
  else
4260
    {
4261
      c = add_set_cmd ("editing", class_support, var_boolean, (char *) &async_command_editing_p,
4262
                       "Set editing of command lines as they are typed.\n\
4263
Use \"on\" to enable the editing, and \"off\" to disable it.\n\
4264
Without an argument, command line editing is enabled.  To edit, use\n\
4265
EMACS-like or VI-like commands like control-P or ESC.", &setlist);
4266
 
4267
      add_show_from_set (c, &showlist);
4268
      c->function.sfunc = set_async_editing_command;
4269
    }
4270
 
4271
  add_prefix_cmd ("history", class_support, set_history,
4272
                  "Generic command for setting command history parameters.",
4273
                  &sethistlist, "set history ", 0, &setlist);
4274
  add_prefix_cmd ("history", class_support, show_history,
4275
                  "Generic command for showing command history parameters.",
4276
                  &showhistlist, "show history ", 0, &showlist);
4277
 
4278
  add_show_from_set
4279
    (add_set_cmd ("expansion", no_class, var_boolean, (char *) &history_expansion_p,
4280
                  "Set history expansion on command input.\n\
4281
Without an argument, history expansion is enabled.", &sethistlist),
4282
     &showhistlist);
4283
 
4284
  add_show_from_set
4285
    (add_set_cmd ("save", no_class, var_boolean, (char *) &write_history_p,
4286
                  "Set saving of the history record on exit.\n\
4287
Use \"on\" to enable the saving, and \"off\" to disable it.\n\
4288
Without an argument, saving is enabled.", &sethistlist),
4289
     &showhistlist);
4290
 
4291
  c = add_set_cmd ("size", no_class, var_integer, (char *) &history_size,
4292
                   "Set the size of the command history, \n\
4293
ie. the number of previous commands to keep a record of.", &sethistlist);
4294
  add_show_from_set (c, &showhistlist);
4295
  c->function.sfunc = set_history_size_command;
4296
 
4297
  add_show_from_set
4298
    (add_set_cmd ("filename", no_class, var_filename, (char *) &history_filename,
4299
                  "Set the filename in which to record the command history\n\
4300
 (the list of previous commands of which a record is kept).", &sethistlist),
4301
     &showhistlist);
4302
 
4303
  add_show_from_set
4304
    (add_set_cmd ("confirm", class_support, var_boolean,
4305
                  (char *) &caution,
4306
                  "Set whether to confirm potentially dangerous operations.",
4307
                  &setlist),
4308
     &showlist);
4309
 
4310
  add_prefix_cmd ("info", class_info, info_command,
4311
     "Generic command for showing things about the program being debugged.",
4312
                  &infolist, "info ", 0, &cmdlist);
4313
  add_com_alias ("i", "info", class_info, 1);
4314
 
4315
  add_com ("complete", class_obscure, complete_command,
4316
           "List the completions for the rest of the line as a command.");
4317
 
4318
  add_prefix_cmd ("show", class_info, show_command,
4319
                  "Generic command for showing things about the debugger.",
4320
                  &showlist, "show ", 0, &cmdlist);
4321
  /* Another way to get at the same thing.  */
4322
  add_info ("set", show_command, "Show all GDB settings.");
4323
 
4324
  add_cmd ("commands", no_class, show_commands,
4325
           "Show the history of commands you typed.\n\
4326
You can supply a command number to start with, or a `+' to start after\n\
4327
the previous command number shown.",
4328
           &showlist);
4329
 
4330
  add_cmd ("version", no_class, show_version,
4331
           "Show what version of GDB this is.", &showlist);
4332
 
4333
  add_com ("while", class_support, while_command,
4334
           "Execute nested commands WHILE the conditional expression is non zero.\n\
4335
The conditional expression must follow the word `while' and must in turn be\n\
4336
followed by a new line.  The nested commands must be entered one per line,\n\
4337
and should be terminated by the word `end'.");
4338
 
4339
  add_com ("if", class_support, if_command,
4340
           "Execute nested commands once IF the conditional expression is non zero.\n\
4341
The conditional expression must follow the word `if' and must in turn be\n\
4342
followed by a new line.  The nested commands must be entered one per line,\n\
4343
and should be terminated by the word 'else' or `end'.  If an else clause\n\
4344
is used, the same rules apply to its nested commands as to the first ones.");
4345
 
4346
  /* If target is open when baud changes, it doesn't take effect until the
4347
     next open (I think, not sure).  */
4348
  add_show_from_set (add_set_cmd ("remotebaud", no_class,
4349
                                  var_zinteger, (char *) &baud_rate,
4350
                                  "Set baud rate for remote serial I/O.\n\
4351
This value is used to set the speed of the serial port when debugging\n\
4352
using remote targets.", &setlist),
4353
                     &showlist);
4354
 
4355
  c = add_set_cmd ("remotedebug", no_class, var_zinteger,
4356
                   (char *) &remote_debug,
4357
                   "Set debugging of remote protocol.\n\
4358
When enabled, each packet sent or received with the remote target\n\
4359
is displayed.", &setlist);
4360
  deprecate_cmd (c, "set debug remote");
4361
  deprecate_cmd (add_show_from_set (c, &showlist), "show debug remote");
4362
 
4363
  add_show_from_set (add_set_cmd ("remote", no_class, var_zinteger,
4364
                                  (char *) &remote_debug,
4365
                                  "Set debugging of remote protocol.\n\
4366
When enabled, each packet sent or received with the remote target\n\
4367
is displayed.", &setdebuglist),
4368
                     &showdebuglist);
4369
 
4370
  add_show_from_set (
4371
                      add_set_cmd ("remotetimeout", no_class, var_integer, (char *) &remote_timeout,
4372
                                   "Set timeout limit to wait for target to respond.\n\
4373
This value is used to set the time limit for gdb to wait for a response\n\
4374
from the target.", &setlist),
4375
                      &showlist);
4376
 
4377
  /* The set annotate command is different depending whether or not
4378
     the async version is run. NOTE: this difference is going to
4379
     disappear as we make the event loop be the default engine of
4380
     gdb. */
4381
  if (!event_loop_p)
4382
    {
4383
      c = add_set_cmd ("annotate", class_obscure, var_zinteger,
4384
                       (char *) &annotation_level, "Set annotation_level.\n\
4385
 
4386
2 == output annotated suitably for use by programs that control GDB.",
4387
                       &setlist);
4388
      c = add_show_from_set (c, &showlist);
4389
    }
4390
  else
4391
    {
4392
      c = add_set_cmd ("annotate", class_obscure, var_zinteger,
4393
                       (char *) &annotation_level, "Set annotation_level.\n\
4394
 
4395
2 == output annotated suitably for use by programs that control GDB.",
4396
                       &setlist);
4397
      add_show_from_set (c, &showlist);
4398
      c->function.sfunc = set_async_annotation_level;
4399
    }
4400
  if (event_loop_p)
4401
    {
4402
      add_show_from_set
4403
        (add_set_cmd ("exec-done-display", class_support, var_boolean, (char *) &exec_done_display_p,
4404
                      "Set notification of completion for asynchronous execution commands.\n\
4405
Use \"on\" to enable the notification, and \"off\" to disable it.", &setlist),
4406
         &showlist);
4407
    }
4408
  add_prefix_cmd ("debug", no_class, set_debug,
4409
                  "Generic command for setting gdb debugging flags",
4410
                  &setdebuglist, "set debug ", 0, &setlist);
4411
 
4412
  add_prefix_cmd ("debug", no_class, show_debug,
4413
                  "Generic command for showing gdb debugging flags",
4414
                  &showdebuglist, "show debug ", 0, &showlist);
4415
}

powered by: WebSVN 2.1.0

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