![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb|
Return to main.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 ! root 1: /* Top level for GDB, the GNU debugger. ! 2: Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc. ! 3: ! 4: GDB is distributed in the hope that it will be useful, but WITHOUT ANY ! 5: WARRANTY. No author or distributor accepts responsibility to anyone ! 6: for the consequences of using it or for whether it serves any ! 7: particular purpose or works at all, unless he says so in writing. ! 8: Refer to the GDB General Public License for full details. ! 9: ! 10: Everyone is granted permission to copy, modify and redistribute GDB, ! 11: but only under the conditions described in the GDB General Public ! 12: License. A copy of this license is supposed to have been given to you ! 13: along with GDB so you can know your rights and responsibilities. It ! 14: should be in a file named COPYING. Among other things, the copyright ! 15: notice and this notice must be preserved on all copies. ! 16: ! 17: In other words, go ahead and share GDB, but don't try to stop ! 18: anyone else from sharing it farther. Help stamp out software hoarding! ! 19: */ ! 20: ! 21: #include <sys/file.h> ! 22: #include <stdio.h> ! 23: #include <setjmp.h> ! 24: #include <signal.h> ! 25: #include <sys/param.h> ! 26: #include "defs.h" ! 27: #include "command.h" ! 28: #include "param.h" ! 29: ! 30: #ifdef SET_STACK_LIMIT_HUGE ! 31: #include <sys/time.h> ! 32: #include <sys/resource.h> ! 33: #endif ! 34: ! 35: /* Version number of GDB, as a string. */ ! 36: ! 37: extern char *version; ! 38: ! 39: /* Chain containing all defined commands. */ ! 40: ! 41: struct cmd_list_element *cmdlist; ! 42: ! 43: /* Chain containing all defined info subcommands. */ ! 44: ! 45: struct cmd_list_element *infolist; ! 46: ! 47: /* stdio stream that command input is being read from. */ ! 48: ! 49: FILE *instream; ! 50: ! 51: /* Current working directory. */ ! 52: ! 53: char *current_directory; ! 54: ! 55: /* The directory name is actually stored here (usually). */ ! 56: static char dirbuf[MAXPATHLEN]; ! 57: ! 58: /* Nonzero if we should refrain from using an X window. */ ! 59: ! 60: int inhibit_windows = 0; ! 61: ! 62: /* Hook for window manager argument parsing. */ ! 63: ! 64: int *win_argc; ! 65: char **win_argv; ! 66: char *win_prgm; ! 67: ! 68: /* Function to call before reading a command, if nonzero. ! 69: The function receives two args: an input stream, ! 70: and a prompt string. */ ! 71: ! 72: void (*window_hook) (); ! 73: ! 74: extern int frame_file_full_name; ! 75: ! 76: void free_command_lines (); ! 77: char *read_line (); ! 78: static void initialize_main (); ! 79: void command_loop (); ! 80: static void source_command (); ! 81: void print_gdb_version (); ! 82: ! 83: /* gdb prints this when reading a command interactively */ ! 84: static char *prompt; ! 85: ! 86: /* Buffer used for reading command lines, and the size ! 87: allocated for it so far. */ ! 88: ! 89: char *line; ! 90: int linesize; ! 91: ! 92: /* This is how `error' returns to command level. */ ! 93: ! 94: jmp_buf to_top_level; ! 95: ! 96: return_to_top_level () ! 97: { ! 98: quit_flag = 0; ! 99: immediate_quit = 0; ! 100: clear_breakpoint_commands (); ! 101: clear_momentary_breakpoints (); ! 102: delete_current_display (); ! 103: do_cleanups (0); ! 104: longjmp (to_top_level, 1); ! 105: } ! 106: ! 107: /* Call FUNC with arg ARG, catching any errors. ! 108: If there is no error, return the value returned by FUNC. ! 109: If there is an error, return zero after printing ERRSTRING ! 110: (which is in addition to the specific error message already printed). */ ! 111: ! 112: int ! 113: catch_errors (func, arg, errstring) ! 114: int (*func) (); ! 115: int arg; ! 116: char *errstring; ! 117: { ! 118: jmp_buf saved; ! 119: int val; ! 120: ! 121: bcopy (to_top_level, saved, sizeof (jmp_buf)); ! 122: ! 123: if (setjmp (to_top_level) == 0) ! 124: val = (*func) (arg); ! 125: else ! 126: { ! 127: fprintf (stderr, "%s\n", errstring); ! 128: val = 0; ! 129: } ! 130: ! 131: bcopy (saved, to_top_level, sizeof (jmp_buf)); ! 132: return val; ! 133: } ! 134: ! 135: /* Handler for SIGHUP. */ ! 136: ! 137: static void ! 138: disconnect () ! 139: { ! 140: kill_inferior_fast (); ! 141: signal (SIGHUP, SIG_DFL); ! 142: kill (getpid (), SIGHUP); ! 143: } ! 144: ! 145: main (argc, argv, envp) ! 146: int argc; ! 147: char **argv; ! 148: char **envp; ! 149: { ! 150: extern void request_quit (); ! 151: int count; ! 152: int inhibit_gdbinit = 0; ! 153: int quiet = 0; ! 154: int batch = 0; ! 155: register int i; ! 156: ! 157: quit_flag = 0; ! 158: linesize = 100; ! 159: line = (char *) xmalloc (linesize); ! 160: instream = stdin; ! 161: ! 162: getwd (dirbuf); ! 163: current_directory = dirbuf; ! 164: ! 165: win_argc = &argc; ! 166: win_argv = argv; ! 167: win_prgm = argv[0]; ! 168: ! 169: #ifdef SET_STACK_LIMIT_HUGE ! 170: { ! 171: struct rlimit rlim; ! 172: ! 173: /* Set the stack limit huge so that alloca (particularly stringtab ! 174: * in dbxread.c) does not fail. */ ! 175: getrlimit (RLIMIT_STACK, &rlim); ! 176: rlim.rlim_cur = rlim.rlim_max; ! 177: setrlimit (RLIMIT_STACK, &rlim); ! 178: } ! 179: #endif /* SET_STACK_LIMIT_HUGE */ ! 180: ! 181: /* Look for flag arguments. */ ! 182: ! 183: for (i = 1; i < argc; i++) ! 184: { ! 185: if (!strcmp (argv[i], "-q") || !strcmp (argv[i], "-quiet")) ! 186: quiet = 1; ! 187: else if (!strcmp (argv[i], "-nx")) ! 188: inhibit_gdbinit = 1; ! 189: else if (!strcmp (argv[i], "-nw")) ! 190: inhibit_windows = 1; ! 191: else if (!strcmp (argv[i], "-batch")) ! 192: batch = 1, quiet = 1; ! 193: else if (!strcmp (argv[i], "-fullname")) ! 194: frame_file_full_name = 1; ! 195: else if (argv[i][0] == '-') ! 196: i++; ! 197: } ! 198: ! 199: /* Run the init function of each source file */ ! 200: ! 201: initialize_all_files (); ! 202: initialize_main (); /* But that omits this file! Do it now */ ! 203: ! 204: signal (SIGINT, request_quit); ! 205: signal (SIGQUIT, SIG_IGN); ! 206: if (signal (SIGHUP, SIG_IGN) != SIG_IGN) ! 207: signal (SIGHUP, disconnect); ! 208: ! 209: if (!quiet) ! 210: print_gdb_version (); ! 211: ! 212: /* Process the command line arguments. */ ! 213: ! 214: count = 0; ! 215: for (i = 1; i < argc; i++) ! 216: { ! 217: register char *arg = argv[i]; ! 218: /* Args starting with - say what to do with the following arg ! 219: as a filename. */ ! 220: if (arg[0] == '-') ! 221: { ! 222: extern void exec_file_command (), symbol_file_command (); ! 223: extern void core_file_command (), directory_command (); ! 224: extern void tty_command (); ! 225: ! 226: if (!strcmp (arg, "-q") || !strcmp (arg, "-nx") ! 227: || !strcmp (arg, "-quiet") || !strcmp (arg, "-batch") ! 228: || !strcmp (arg, "-fullname")) ! 229: /* Already processed above */ ! 230: continue; ! 231: ! 232: if (++i == argc) ! 233: fprintf (stderr, "No argument follows \"%s\".\n", arg); ! 234: if (!setjmp (to_top_level)) ! 235: { ! 236: /* -s foo: get syms from foo. -e foo: execute foo. ! 237: -se foo: do both with foo. -c foo: use foo as core dump. */ ! 238: if (!strcmp (arg, "-se")) ! 239: { ! 240: exec_file_command (argv[i], !batch); ! 241: symbol_file_command (argv[i], !batch); ! 242: } ! 243: else if (!strcmp (arg, "-s") || !strcmp (arg, "-symbols")) ! 244: symbol_file_command (argv[i], !batch); ! 245: else if (!strcmp (arg, "-e") || !strcmp (arg, "-exec")) ! 246: exec_file_command (argv[i], !batch); ! 247: else if (!strcmp (arg, "-c") || !strcmp (arg, "-core")) ! 248: core_file_command (argv[i], !batch); ! 249: /* -x foo: execute commands from foo. */ ! 250: else if (!strcmp (arg, "-x") || !strcmp (arg, "-command") ! 251: || !strcmp (arg, "-commands")) ! 252: source_command (argv[i]); ! 253: /* -d foo: add directory `foo' to source-file directory ! 254: search-list */ ! 255: else if (!strcmp (arg, "-d") || !strcmp (arg, "-dir") ! 256: || !strcmp (arg, "-directory")) ! 257: directory_command (argv[i], 0); ! 258: /* -cd FOO: specify current directory as FOO. ! 259: GDB remembers the precise string FOO as the dirname. */ ! 260: else if (!strcmp (arg, "-cd")) ! 261: { ! 262: int len = strlen (argv[i]); ! 263: current_directory = argv[i]; ! 264: if (len > 1 && current_directory[len - 1] == '/') ! 265: current_directory = savestring (current_directory, len-1); ! 266: chdir (current_directory); ! 267: init_source_path (); ! 268: } ! 269: /* -t /def/ttyp1: use /dev/ttyp1 for inferior I/O. */ ! 270: else if (!strcmp (arg, "-t") || !strcmp (arg, "-tty")) ! 271: tty_command (argv[i], 0); ! 272: else ! 273: error ("Unknown command-line switch: \"%s\"\n", arg); ! 274: } ! 275: } ! 276: else ! 277: { ! 278: /* Args not thus accounted for ! 279: are treated as, first, the symbol/executable file ! 280: and, second, the core dump file. */ ! 281: count++; ! 282: if (!setjmp (to_top_level)) ! 283: switch (count) ! 284: { ! 285: case 1: ! 286: exec_file_command (arg, !batch); ! 287: symbol_file_command (arg, !batch); ! 288: break; ! 289: ! 290: case 2: ! 291: core_file_command (arg, !batch); ! 292: break; ! 293: ! 294: case 3: ! 295: fprintf (stderr, "Excess command line args ignored. (%s%s)\n", ! 296: arg, (i == argc - 1) ? "" : " ..."); ! 297: } ! 298: } ! 299: } ! 300: ! 301: /* Read init file, if it exists in home directory */ ! 302: if (getenv ("HOME")) ! 303: { ! 304: char *s; ! 305: s = (char *) xmalloc (strlen (getenv ("HOME")) + 10); ! 306: strcpy (s, getenv ("HOME")); ! 307: strcat (s, "/.gdbinit"); ! 308: if (!inhibit_gdbinit && access (s, R_OK) == 0) ! 309: if (!setjmp (to_top_level)) ! 310: source_command (s); ! 311: } ! 312: ! 313: /* Read init file, if it exists in current directory. */ ! 314: if (!inhibit_gdbinit && access (".gdbinit", R_OK) == 0) ! 315: if (!setjmp (to_top_level)) ! 316: source_command (".gdbinit"); ! 317: ! 318: if (batch) ! 319: fatal ("Attempt to read commands from stdin in batch mode."); ! 320: ! 321: if (!quiet) ! 322: printf ("Type \"help\" for a list of commands.\n"); ! 323: ! 324: /* The command loop. */ ! 325: ! 326: while (1) ! 327: { ! 328: if (!setjmp (to_top_level)) ! 329: command_loop (); ! 330: clearerr (stdin); /* Don't get hung if C-d is typed. */ ! 331: } ! 332: } ! 333: ! 334: /* Execute the line P as a command. ! 335: Pass FROM_TTY as second argument to the defining function. */ ! 336: ! 337: void ! 338: execute_command (p, from_tty) ! 339: char *p; ! 340: int from_tty; ! 341: { ! 342: register struct cmd_list_element *c; ! 343: register struct command_line *cmdlines; ! 344: ! 345: free_all_values (); ! 346: while (*p == ' ' || *p == '\t') p++; ! 347: if (*p) ! 348: { ! 349: c = lookup_cmd (&p, cmdlist, "", 0); ! 350: if (c->function == 0) ! 351: error ("That is not a command, just a help topic."); ! 352: else if (c->class == (int) class_user) ! 353: { ! 354: if (*p) ! 355: error ("User-defined commands cannot take arguments."); ! 356: cmdlines = (struct command_line *) c->function; ! 357: if (cmdlines == (struct command_line *) 0) ! 358: /* Null command */ ! 359: return; ! 360: while (cmdlines) ! 361: { ! 362: execute_command (cmdlines->line, 0); ! 363: cmdlines = cmdlines->next; ! 364: } ! 365: } ! 366: else ! 367: /* Pass null arg rather than an empty one. */ ! 368: (*c->function) (*p ? p : 0, from_tty); ! 369: } ! 370: } ! 371: ! 372: static void ! 373: do_nothing () ! 374: { ! 375: } ! 376: ! 377: /* Read commands from `instream' and execute them ! 378: until end of file. */ ! 379: void ! 380: command_loop () ! 381: { ! 382: struct cleanup *old_chain; ! 383: while (!feof (instream)) ! 384: { ! 385: if (instream == stdin) ! 386: printf ("%s", prompt); ! 387: fflush (stdout); ! 388: ! 389: if (window_hook && instream == stdin) ! 390: (*window_hook) (instream, prompt); ! 391: ! 392: quit_flag = 0; ! 393: old_chain = make_cleanup (do_nothing, 0); ! 394: execute_command (read_line (instream == stdin), instream == stdin); ! 395: /* Do any commands attached to breakpoint we stopped at. */ ! 396: do_breakpoint_commands (); ! 397: do_cleanups (old_chain); ! 398: } ! 399: } ! 400: ! 401: #ifdef SIGTSTP ! 402: static void ! 403: stop_sig () ! 404: { ! 405: signal (SIGTSTP, SIG_DFL); ! 406: sigsetmask (0); ! 407: kill (getpid (), SIGTSTP); ! 408: signal (SIGTSTP, stop_sig); ! 409: printf ("%s", prompt); ! 410: fflush (stdout); ! 411: ! 412: /* Forget about any previous command -- null line now will do nothing. */ ! 413: *line = 0; ! 414: } ! 415: #endif /* SIGTSTP */ ! 416: ! 417: /* Commands call this if they do not want to be repeated by null lines. */ ! 418: ! 419: void ! 420: dont_repeat () ! 421: { ! 422: *line = 0; ! 423: } ! 424: ! 425: /* Read one line from the command input stream `instream' ! 426: into the buffer `line' (whose current length is `linesize'). ! 427: The buffer is made bigger as necessary. ! 428: Returns the address of the start of the line. */ ! 429: ! 430: char * ! 431: read_line (repeat) ! 432: int repeat; ! 433: { ! 434: register char *p = line; ! 435: register char *p1; ! 436: register int c; ! 437: char *nline; ! 438: ! 439: /* Control-C quits instantly if typed while in this loop ! 440: since it should not wait until the user types a newline. */ ! 441: immediate_quit++; ! 442: #ifdef SIGTSTP ! 443: signal (SIGTSTP, stop_sig); ! 444: #endif ! 445: ! 446: while (1) ! 447: { ! 448: c = fgetc (instream); ! 449: if (c == -1 || c == '\n') ! 450: break; ! 451: /* Ignore backslash-newline; keep adding to the same line. */ ! 452: else if (c == '\\') ! 453: { ! 454: int c1 = fgetc (instream); ! 455: if (c1 == '\n') ! 456: continue; ! 457: else ! 458: ungetc (c1, instream); ! 459: } ! 460: ! 461: if (p - line == linesize - 1) ! 462: { ! 463: linesize *= 2; ! 464: nline = (char *) xrealloc (line, linesize); ! 465: p += nline - line; ! 466: line = nline; ! 467: } ! 468: *p++ = c; ! 469: } ! 470: ! 471: #ifdef SIGTSTP ! 472: signal (SIGTSTP, SIG_DFL); ! 473: #endif ! 474: immediate_quit--; ! 475: ! 476: /* If we just got an empty line, and that is supposed ! 477: to repeat the previous command, leave the last input unchanged. */ ! 478: if (p == line && repeat) ! 479: return line; ! 480: ! 481: /* If line is a comment, clear it out. */ ! 482: p1 = line; ! 483: while ((c = *p1) == ' ' || c == '\t') p1++; ! 484: if (c == '#') ! 485: p = line; ! 486: ! 487: *p = 0; ! 488: ! 489: return line; ! 490: } ! 491: ! 492: /* Read lines from the input stream ! 493: and accumulate them in a chain of struct command_line's ! 494: which is then returned. */ ! 495: ! 496: struct command_line * ! 497: read_command_lines () ! 498: { ! 499: struct command_line *first = 0; ! 500: register struct command_line *next, *tail = 0; ! 501: register char *p, *p1; ! 502: struct cleanup *old_chain = 0; ! 503: ! 504: while (1) ! 505: { ! 506: dont_repeat (); ! 507: p = read_line (1); ! 508: /* Remove leading and trailing blanks. */ ! 509: while (*p == ' ' || *p == '\t') p++; ! 510: p1 = p + strlen (p); ! 511: while (p1 != p && (p1[-1] == ' ' || p1[-1] == '\t')) p1--; ! 512: ! 513: /* Is this "end"? */ ! 514: if (p1 - p == 3 && !strncmp (p, "end", 3)) ! 515: break; ! 516: ! 517: /* No => add this line to the chain of command lines. */ ! 518: next = (struct command_line *) xmalloc (sizeof (struct command_line)); ! 519: next->line = savestring (p, p1 - p); ! 520: next->next = 0; ! 521: if (tail) ! 522: { ! 523: tail->next = next; ! 524: } ! 525: else ! 526: { ! 527: /* We just read the first line. ! 528: From now on, arrange to throw away the lines we have ! 529: if we quit or get an error while inside this function. */ ! 530: first = next; ! 531: old_chain = make_cleanup (free_command_lines, &first); ! 532: } ! 533: tail = next; ! 534: } ! 535: ! 536: dont_repeat (); ! 537: ! 538: /* Now we are about to return the chain to our caller, ! 539: so freeing it becomes his responsibility. */ ! 540: if (first) ! 541: discard_cleanups (old_chain); ! 542: return first; ! 543: } ! 544: ! 545: /* Free a chain of struct command_line's. */ ! 546: ! 547: void ! 548: free_command_lines (lptr) ! 549: struct command_line **lptr; ! 550: { ! 551: register struct command_line *l = *lptr; ! 552: register struct command_line *next; ! 553: ! 554: while (l) ! 555: { ! 556: next = l->next; ! 557: free (l->line); ! 558: free (l); ! 559: l = next; ! 560: } ! 561: } ! 562: ! 563: /* Add an element to the list of info subcommands. */ ! 564: ! 565: void ! 566: add_info (name, fun, doc) ! 567: char *name; ! 568: void (*fun) (); ! 569: char *doc; ! 570: { ! 571: add_cmd (name, 0, fun, doc, &infolist); ! 572: } ! 573: ! 574: /* Add an alias to the list of info subcommands. */ ! 575: ! 576: void ! 577: add_info_alias (name, oldname, abbrev_flag) ! 578: char *name; ! 579: char *oldname; ! 580: int abbrev_flag; ! 581: { ! 582: add_alias_cmd (name, oldname, 0, abbrev_flag, &infolist); ! 583: } ! 584: ! 585: /* The "info" command is defined as a prefix, with allow_unknown = 0. ! 586: Therefore, its own definition is called only for "info" with no args. */ ! 587: ! 588: static void ! 589: info_command () ! 590: { ! 591: printf ("\"info\" must be followed by the name of an info command.\n"); ! 592: help_cmd (0, infolist, "info ", -1, stdout); ! 593: } ! 594: ! 595: /* Add an element to the list of commands. */ ! 596: ! 597: void ! 598: add_com (name, class, fun, doc) ! 599: char *name; ! 600: int class; ! 601: void (*fun) (); ! 602: char *doc; ! 603: { ! 604: add_cmd (name, class, fun, doc, &cmdlist); ! 605: } ! 606: ! 607: /* Add an alias or abbreviation command to the list of commands. */ ! 608: ! 609: void ! 610: add_com_alias (name, oldname, class, abbrev_flag) ! 611: char *name; ! 612: char *oldname; ! 613: int class; ! 614: int abbrev_flag; ! 615: { ! 616: add_alias_cmd (name, oldname, class, abbrev_flag, &cmdlist); ! 617: } ! 618: ! 619: void ! 620: error_no_arg (why) ! 621: char *why; ! 622: { ! 623: error ("Argument required (%s).", why); ! 624: } ! 625: ! 626: static void ! 627: help_command (command, from_tty) ! 628: char *command; ! 629: int from_tty; /* Ignored */ ! 630: { ! 631: help_cmd (command, cmdlist, "", -2, stdout); ! 632: } ! 633: ! 634: static void ! 635: validate_comname (comname) ! 636: char *comname; ! 637: { ! 638: register char *p; ! 639: ! 640: if (comname == 0) ! 641: error_no_arg ("name of command to define"); ! 642: ! 643: p = comname; ! 644: while (*p) ! 645: { ! 646: if (!(*p >= 'A' && *p <= 'Z') ! 647: && !(*p >= 'a' && *p <= 'z') ! 648: && !(*p >= '0' && *p <= '9') ! 649: && *p != '-') ! 650: error ("Junk in argument list: \"%s\"", p); ! 651: p++; ! 652: } ! 653: } ! 654: ! 655: static void ! 656: define_command (comname, from_tty) ! 657: char *comname; ! 658: int from_tty; ! 659: { ! 660: register struct command_line *cmds; ! 661: register struct cmd_list_element *c; ! 662: char *tem = comname; ! 663: ! 664: validate_comname (comname); ! 665: ! 666: c = lookup_cmd (&tem, cmdlist, "", -1); ! 667: if (c) ! 668: { ! 669: if (c->class == (int) class_user || c->class == (int) class_alias) ! 670: tem = "Redefine command \"%s\"? "; ! 671: else ! 672: tem = "Really redefine built-in command \"%s\"? "; ! 673: if (!query (tem, comname)) ! 674: error ("Command \"%s\" not redefined.", comname); ! 675: } ! 676: ! 677: if (from_tty) ! 678: printf ("Type commands for definition of \"%s\".\n\ ! 679: End with a line saying just \"end\".\n", comname); ! 680: ! 681: comname = savestring (comname, strlen (comname)); ! 682: ! 683: cmds = read_command_lines (); ! 684: ! 685: if (c && c->class == (int) class_user) ! 686: free_command_lines (&c->function); ! 687: ! 688: add_com (comname, class_user, cmds, ! 689: (c && c->class == (int) class_user) ! 690: ? c->doc : savestring ("User-defined.", 13)); ! 691: } ! 692: ! 693: static void ! 694: document_command (comname, from_tty) ! 695: char *comname; ! 696: int from_tty; ! 697: { ! 698: struct command_line *doclines; ! 699: register struct cmd_list_element *c; ! 700: char *tem = comname; ! 701: ! 702: validate_comname (comname); ! 703: ! 704: c = lookup_cmd (&tem, cmdlist, "", 0); ! 705: ! 706: if (c->class != (int) class_user) ! 707: error ("Command \"%s\" is built-in.", comname); ! 708: ! 709: if (from_tty) ! 710: printf ("Type documentation for \"%s\".\n\ ! 711: End with a line saying just \"end\".\n", comname); ! 712: ! 713: doclines = read_command_lines (); ! 714: ! 715: if (c->doc) free (c->doc); ! 716: ! 717: { ! 718: register struct command_line *cl1; ! 719: register int len = 0; ! 720: ! 721: for (cl1 = doclines; cl1; cl1 = cl1->next) ! 722: len += strlen (cl1->line) + 1; ! 723: ! 724: c->doc = (char *) xmalloc (len + 1); ! 725: *c->doc = 0; ! 726: ! 727: for (cl1 = doclines; cl1; cl1 = cl1->next) ! 728: { ! 729: strcat (c->doc, cl1->line); ! 730: if (cl1->next) ! 731: strcat (c->doc, "\n"); ! 732: } ! 733: } ! 734: ! 735: free_command_lines (&doclines); ! 736: } ! 737: ! 738: static void ! 739: copying_info () ! 740: { ! 741: immediate_quit++; ! 742: printf (" GDB GENERAL PUBLIC LICENSE\n\ ! 743: (Clarified 11 Feb 1988)\n\ ! 744: \n\ ! 745: Copyright (C) 1988 Richard M. Stallman\n\ ! 746: Everyone is permitted to copy and distribute verbatim copies\n\ ! 747: of this license, but changing it is not allowed.\n\ ! 748: You can also use this wording to make the terms for other programs.\n\ ! 749: \n\ ! 750: The license agreements of most software companies keep you at the\n\ ! 751: mercy of those companies. By contrast, our general public license is\n\ ! 752: intended to give everyone the right to share GDB. To make sure that\n\ ! 753: you get the rights we want you to have, we need to make restrictions\n\ ! 754: that forbid anyone to deny you these rights or to ask you to surrender\n\ ! 755: the rights. Hence this license agreement.\n\ ! 756: \n\ ! 757: Specifically, we want to make sure that you have the right to give\n\ ! 758: away copies of GDB, that you receive source code or else can get it\n\ ! 759: if you want it, that you can change GDB or use pieces of it in new\n\ ! 760: free programs, and that you know you can do these things.\n\ ! 761: --Type Return to print more--"); ! 762: fflush (stdout); ! 763: read_line (); ! 764: ! 765: printf ("\ ! 766: To make sure that everyone has such rights, we have to forbid you to\n\ ! 767: deprive anyone else of these rights. For example, if you distribute\n\ ! 768: copies of GDB, you must give the recipients all the rights that you\n\ ! 769: have. You must make sure that they, too, receive or can get the\n\ ! 770: source code. And you must tell them their rights.\n\ ! 771: \n\ ! 772: Also, for our own protection, we must make certain that everyone\n\ ! 773: finds out that there is no warranty for GDB. If GDB is modified by\n\ ! 774: someone else and passed on, we want its recipients to know that what\n\ ! 775: they have is not what we distributed, so that any problems introduced\n\ ! 776: by others will not reflect on our reputation.\n\ ! 777: \n\ ! 778: Therefore we (Richard Stallman and the Free Software Foundation,\n\ ! 779: Inc.) make the following terms which say what you must do to be\n\ ! 780: allowed to distribute or change GDB.\n\ ! 781: --Type Return to print more--"); ! 782: fflush (stdout); ! 783: read_line (); ! 784: ! 785: printf ("\ ! 786: COPYING POLICIES\n\ ! 787: \n\ ! 788: 1. You may copy and distribute verbatim copies of GDB source code as\n\ ! 789: you receive it, in any medium, provided that you conspicuously and\n\ ! 790: appropriately publish on each copy a valid copyright notice \"Copyright\n\ ! 791: \(C) 1988 Free Software Foundation, Inc.\" (or with whatever year is\n\ ! 792: appropriate); keep intact the notices on all files that refer\n\ ! 793: to this License Agreement and to the absence of any warranty; and give\n\ ! 794: any other recipients of the GDB program a copy of this License\n\ ! 795: Agreement along with the program. You may charge a distribution fee\n\ ! 796: for the physical act of transferring a copy.\n\ ! 797: \n\ ! 798: 2. You may modify your copy or copies of GDB or any portion of it,\n\ ! 799: and copy and distribute such modifications under the terms of\n\ ! 800: Paragraph 1 above, provided that you also do the following:\n\ ! 801: \n\ ! 802: a) cause the modified files to carry prominent notices stating\n\ ! 803: that you changed the files and the date of any change; and\n\ ! 804: --Type Return to print more--"); ! 805: fflush (stdout); ! 806: read_line (); ! 807: ! 808: printf ("\ ! 809: b) cause the whole of any work that you distribute or publish,\n\ ! 810: that in whole or in part contains or is a derivative of GDB\n\ ! 811: or any part thereof, to be licensed to all third parties on terms\n\ ! 812: identical to those contained in this License Agreement (except that\n\ ! 813: you may choose to grant more extensive warranty protection to some\n\ ! 814: or all third parties, at your option).\n\ ! 815: \n"); ! 816: printf ("\ ! 817: c) if the modified program serves as a debugger, cause it\n\ ! 818: when started running in the simplest and usual way, to print\n\ ! 819: an announcement including a valid copyright notice\n\ ! 820: \"Copyright (C) 1988 Free Software Foundation, Inc.\" (or with\n\ ! 821: the year that is appropriate), saying that there is no warranty\n\ ! 822: (or else, saying that you provide a warranty) and that users may\n\ ! 823: redistribute the program under these conditions, and telling the user\n\ ! 824: how to view a copy of this License Agreement.\n\ ! 825: \n\ ! 826: d) You may charge a distribution fee for the physical act of\n\ ! 827: transferring a copy, and you may at your option offer warranty\n\ ! 828: protection in exchange for a fee.\n\ ! 829: \n\ ! 830: Mere aggregation of another unrelated program with this program (or its\n\ ! 831: derivative) on a volume of a storage or distribution medium does not bring\n\ ! 832: the other program under the scope of these terms.\n\ ! 833: --Type Return to print more--"); ! 834: fflush (stdout); ! 835: read_line (); ! 836: ! 837: printf ("\ ! 838: 3. You may copy and distribute GDB (or a portion or derivative of it,\n\ ! 839: under Paragraph 2) in object code or executable form under the terms of\n\ ! 840: Paragraphs 1 and 2 above provided that you also do one of the following:\n\ ! 841: \n\ ! 842: a) accompany it with the complete corresponding machine-readable\n\ ! 843: source code, which must be distributed under the terms of\n\ ! 844: Paragraphs 1 and 2 above; or,\n\ ! 845: \n\ ! 846: b) accompany it with a written offer, valid for at least three\n\ ! 847: years, to give any third party free (except for a nominal\n\ ! 848: shipping charge) a complete machine-readable copy of the\n\ ! 849: corresponding source code, to be distributed under the terms of\n\ ! 850: Paragraphs 1 and 2 above; or,\n\n"); ! 851: ! 852: printf ("\ ! 853: c) accompany it with the information you received as to where the\n\ ! 854: corresponding source code may be obtained. (This alternative is\n\ ! 855: allowed only for noncommercial distribution and only if you\n\ ! 856: received the program in object code or executable form alone.)\n\ ! 857: \n\ ! 858: For an executable file, complete source code means all the source code for\n\ ! 859: all modules it contains; but, as a special exception, it need not include\n\ ! 860: source code for modules which are standard libraries that accompany the\n\ ! 861: operating system on which the executable file runs.\n\ ! 862: --Type Return to print more--"); ! 863: fflush (stdout); ! 864: read_line (); ! 865: ! 866: printf ("\ ! 867: 4. You may not copy, sublicense, distribute or transfer GDB\n\ ! 868: except as expressly provided under this License Agreement. Any attempt\n\ ! 869: otherwise to copy, sublicense, distribute or transfer GDB is void and\n\ ! 870: your rights to use the program under this License agreement shall be\n\ ! 871: automatically terminated. However, parties who have received computer\n\ ! 872: software programs from you with this License Agreement will not have\n\ ! 873: their licenses terminated so long as such parties remain in full compliance.\n\ ! 874: \n\ ! 875: 5. If you wish to incorporate parts of GDB into other free\n\ ! 876: programs whose distribution conditions are different, write to the Free\n\ ! 877: Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet\n\ ! 878: worked out a simple rule that can be stated here, but we will often permit\n\ ! 879: this. We will be guided by the two goals of preserving the free status of\n\ ! 880: all derivatives of our free software and of promoting the sharing and reuse\n\ ! 881: of software.\n\ ! 882: \n\ ! 883: In other words, go ahead and share GDB, but don't try to stop\n\ ! 884: anyone else from sharing it farther. Help stamp out software hoarding!\n\ ! 885: "); ! 886: immediate_quit--; ! 887: } ! 888: ! 889: static void ! 890: warranty_info () ! 891: { ! 892: immediate_quit++; ! 893: printf (" NO WARRANTY\n\ ! 894: \n\ ! 895: BECAUSE GDB IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO\n\ ! 896: WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT\n\ ! 897: WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,\n\ ! 898: RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE GDB \"AS IS\" WITHOUT\n\ ! 899: WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT\n\ ! 900: LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n\ ! 901: A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND\n\ ! 902: PERFORMANCE OF GDB IS WITH YOU. SHOULD GDB PROVE DEFECTIVE, YOU\n\ ! 903: ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n"); ! 904: ! 905: printf ("\ ! 906: IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.\n\ ! 907: STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY\n\ ! 908: WHO MAY MODIFY AND REDISTRIBUTE GDB, BE LIABLE TO\n\ ! 909: YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER\n\ ! 910: SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR\n\ ! 911: INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA\n\ ! 912: BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A\n\ ! 913: FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GDB, EVEN\n\ ! 914: IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR\n\ ! 915: ANY CLAIM BY ANY OTHER PARTY.\n"); ! 916: immediate_quit--; ! 917: } ! 918: ! 919: static void ! 920: print_gdb_version () ! 921: { ! 922: printf ("GDB %s, Copyright (C) 1988 Free Software Foundation, Inc.\n\ ! 923: There is ABSOLUTELY NO WARRANTY for GDB; type \"info warranty\" for details.\n\ ! 924: GDB is free software and you are welcome to distribute copies of it\n\ ! 925: under certain conditions; type \"info copying\" to see the conditions.\n", ! 926: version); ! 927: } ! 928: ! 929: static void ! 930: version_info () ! 931: { ! 932: immediate_quit++; ! 933: print_gdb_version (); ! 934: immediate_quit--; ! 935: } ! 936: ! 937: /* xgdb calls this to reprint the usual GDB prompt. */ ! 938: ! 939: void ! 940: print_prompt () ! 941: { ! 942: printf ("%s", prompt); ! 943: fflush (stdout); ! 944: } ! 945: ! 946: /* Command to specify a prompt string instead of "(gdb) ". */ ! 947: ! 948: static void ! 949: set_prompt_command (text) ! 950: char *text; ! 951: { ! 952: char *p, *q; ! 953: register int c; ! 954: char *new; ! 955: ! 956: if (text == 0) ! 957: error_no_arg ("string to which to set prompt"); ! 958: ! 959: new = (char *) xmalloc (strlen (text) + 2); ! 960: p = text; q = new; ! 961: while (c = *p++) ! 962: { ! 963: if (c == '\\') ! 964: { ! 965: /* \ at end of argument is used after spaces ! 966: so they won't be lost. */ ! 967: if (*p == 0) ! 968: break; ! 969: c = parse_escape (&p); ! 970: if (c == 0) ! 971: break; /* C loses */ ! 972: else if (c > 0) ! 973: *q++ = c; ! 974: } ! 975: else ! 976: *q++ = c; ! 977: } ! 978: if (*(p - 1) != '\\') ! 979: *q++ = ' '; ! 980: *q++ = '\0'; ! 981: new = (char *) xrealloc (new, q - new); ! 982: free (prompt); ! 983: prompt = new; ! 984: } ! 985: ! 986: static void ! 987: quit_command () ! 988: { ! 989: if (have_inferior_p ()) ! 990: { ! 991: if (query ("The program is running. Quit anyway? ")) ! 992: { ! 993: /* Prevent any warning message from reopen_exec_file, in case ! 994: we have a core file that's inconsistent with the exec file. */ ! 995: exec_file_command (0, 0); ! 996: kill_inferior (); ! 997: } ! 998: else ! 999: error ("Not confirmed."); ! 1000: } ! 1001: exit (0); ! 1002: } ! 1003: ! 1004: int ! 1005: input_from_terminal_p () ! 1006: { ! 1007: return instream == stdin; ! 1008: } ! 1009: ! 1010: static void ! 1011: pwd_command (arg, from_tty) ! 1012: char *arg; ! 1013: int from_tty; ! 1014: { ! 1015: if (arg) error ("The \"pwd\" command does not take an argument: %s", arg); ! 1016: getwd (dirbuf); ! 1017: ! 1018: if (strcmp (dirbuf, current_directory)) ! 1019: printf ("Working directory %s\n (canonically %s).\n", ! 1020: current_directory, dirbuf); ! 1021: else ! 1022: printf ("Working directory %s.\n", current_directory); ! 1023: } ! 1024: ! 1025: static void ! 1026: cd_command (dir, from_tty) ! 1027: char *dir; ! 1028: int from_tty; ! 1029: { ! 1030: int len; ! 1031: int change; ! 1032: ! 1033: if (dir == 0) ! 1034: error_no_arg ("new working directory"); ! 1035: ! 1036: len = strlen (dir); ! 1037: dir = savestring (dir, len - (len > 1 && dir[len-1] == '/')); ! 1038: if (dir[0] == '/') ! 1039: current_directory = dir; ! 1040: else ! 1041: { ! 1042: current_directory = concat (current_directory, "/", dir); ! 1043: free (dir); ! 1044: } ! 1045: ! 1046: /* Now simplify any occurrences of `.' and `..' in the pathname. */ ! 1047: ! 1048: change = 1; ! 1049: while (change) ! 1050: { ! 1051: char *p; ! 1052: change = 0; ! 1053: ! 1054: for (p = current_directory; *p;) ! 1055: { ! 1056: if (!strncmp (p, "/./", 2) ! 1057: && (p[2] == 0 || p[2] == '/')) ! 1058: strcpy (p, p + 2); ! 1059: else if (!strncmp (p, "/..", 3) ! 1060: && (p[3] == 0 || p[3] == '/') ! 1061: && p != current_directory) ! 1062: { ! 1063: char *q = p; ! 1064: while (q != current_directory && q[-1] != '/') q--; ! 1065: if (q != current_directory) ! 1066: { ! 1067: strcpy (q-1, p+3); ! 1068: p = q-1; ! 1069: } ! 1070: } ! 1071: else p++; ! 1072: } ! 1073: } ! 1074: ! 1075: if (chdir (dir) < 0) ! 1076: perror_with_name (dir); ! 1077: ! 1078: if (from_tty) ! 1079: pwd_command ((char *) 0, 1); ! 1080: } ! 1081: ! 1082: /* Clean up on error during a "source" command. ! 1083: Close the file opened by the command ! 1084: and restore the previous input stream. */ ! 1085: ! 1086: static void ! 1087: source_cleanup (stream) ! 1088: FILE *stream; ! 1089: { ! 1090: fclose (instream); ! 1091: instream = stream; ! 1092: } ! 1093: ! 1094: static void ! 1095: source_command (file) ! 1096: char *file; ! 1097: { ! 1098: FILE *stream; ! 1099: struct cleanup *cleanups; ! 1100: ! 1101: if (file == 0) ! 1102: error_no_arg ("file to read commands from"); ! 1103: ! 1104: stream = fopen (file, "r"); ! 1105: if (stream == 0) ! 1106: perror_with_name (file); ! 1107: ! 1108: cleanups = make_cleanup (source_cleanup, instream); ! 1109: ! 1110: instream = stream; ! 1111: ! 1112: command_loop (); ! 1113: ! 1114: do_cleanups (cleanups); ! 1115: } ! 1116: ! 1117: static void ! 1118: echo_command (text) ! 1119: char *text; ! 1120: { ! 1121: char *p = text; ! 1122: register int c; ! 1123: ! 1124: if (text) ! 1125: while (c = *p++) ! 1126: { ! 1127: if (c == '\\') ! 1128: { ! 1129: /* \ at end of argument is used after spaces ! 1130: so they won't be lost. */ ! 1131: if (*p == 0) ! 1132: return; ! 1133: ! 1134: c = parse_escape (&p); ! 1135: if (c >= 0) ! 1136: fputc (c, stdout); ! 1137: } ! 1138: else ! 1139: fputc (c, stdout); ! 1140: } ! 1141: } ! 1142: ! 1143: static void ! 1144: dump_me_command () ! 1145: { ! 1146: if (query ("Should GDB dump core? ")) ! 1147: { ! 1148: signal (SIGQUIT, SIG_DFL); ! 1149: kill (getpid (), SIGQUIT); ! 1150: } ! 1151: } ! 1152: ! 1153: static void ! 1154: initialize_main () ! 1155: { ! 1156: prompt = savestring ("(gdb) ", 6); ! 1157: ! 1158: /* Define the classes of commands. ! 1159: They will appear in the help list in the reverse of this order. */ ! 1160: ! 1161: add_cmd ("obscure", class_obscure, 0, "Obscure features.", &cmdlist); ! 1162: add_cmd ("alias", class_alias, 0, "Aliases of other commands.", &cmdlist); ! 1163: add_cmd ("user", class_user, 0, "User-defined commands.\n\ ! 1164: The commands in this class are those defined by the user.\n\ ! 1165: Use the \"define\" command to define a command.", &cmdlist); ! 1166: add_cmd ("support", class_support, 0, "Support facilities.", &cmdlist); ! 1167: add_cmd ("status", class_info, 0, "Status inquiries.", &cmdlist); ! 1168: add_cmd ("files", class_files, 0, "Specifying and examining files.", &cmdlist); ! 1169: add_cmd ("breakpoints", class_breakpoint, 0, "Making program stop at certain points.", &cmdlist); ! 1170: add_cmd ("data", class_vars, 0, "Examining data.", &cmdlist); ! 1171: add_cmd ("stack", class_stack, 0, "Examining the stack.\n\ ! 1172: The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\ ! 1173: counting from zero for the innermost (currently executing) frame.\n\n\ ! 1174: At any time gdb identifies one frame as the \"selected\" frame.\n\ ! 1175: Variable lookups are done with respect to the selected frame.\n\ ! 1176: When the program being debugged stops, gdb selects the innermost frame.\n\ ! 1177: The commands below can be used to select other frames by number or address.", ! 1178: &cmdlist); ! 1179: add_cmd ("running", class_run, 0, "Running the program.", &cmdlist); ! 1180: ! 1181: add_com ("pwd", class_files, pwd_command, ! 1182: "Print working directory. This is used for your program as well."); ! 1183: add_com ("cd", class_files, cd_command, ! 1184: "Set working directory to DIR for debugger and program being debugged.\n\ ! 1185: The change does not take effect for the program being debugged\n\ ! 1186: until the next time it is started."); ! 1187: ! 1188: add_com ("set-prompt", class_support, set_prompt_command, ! 1189: "Change gdb's prompt from the default of \"(gdb)\""); ! 1190: add_com ("echo", class_support, echo_command, ! 1191: "Print a constant string. Give string as argument.\n\ ! 1192: C escape sequences may be used in the argument.\n\ ! 1193: No newline is added at the end of the argument;\n\ ! 1194: use \"\\n\" if you want a newline to be printed.\n\ ! 1195: Since leading and trailing whitespace are ignored in command arguments,\n\ ! 1196: if you want to print some you must use \"\\\" before leading whitespace\n\ ! 1197: to be printed or after trailing whitespace."); ! 1198: add_com ("document", class_support, document_command, ! 1199: "Document a user-defined command.\n\ ! 1200: Give command name as argument. Give documentation on following lines.\n\ ! 1201: End with a line of just \"end\"."); ! 1202: add_com ("define", class_support, define_command, ! 1203: "Define a new command name. Command name is argument.\n\ ! 1204: Definition appears on following lines, one command per line.\n\ ! 1205: End with a line of just \"end\".\n\ ! 1206: Use the \"document\" command to give documentation for the new command.\n\ ! 1207: Commands defined in this way do not take arguments."); ! 1208: ! 1209: add_com ("source", class_support, source_command, ! 1210: "Read commands from a file named FILE.\n\ ! 1211: Note that the file \".gdbinit\" is read automatically in this way\n\ ! 1212: when gdb is started."); ! 1213: add_com ("quit", class_support, quit_command, "Exit gdb."); ! 1214: add_com ("help", class_support, help_command, "Print list of commands."); ! 1215: add_com_alias ("q", "quit", class_support, 1); ! 1216: add_com_alias ("h", "help", class_support, 1); ! 1217: ! 1218: add_com ("dump-me", class_obscure, dump_me_command, ! 1219: "Get fatal error; make debugger dump its core."); ! 1220: ! 1221: add_prefix_cmd ("info", class_info, info_command, ! 1222: "Generic command for printing status.", ! 1223: &infolist, "info ", 0, &cmdlist); ! 1224: add_com_alias ("i", "info", class_info, 1); ! 1225: ! 1226: add_info ("copying", copying_info, "Conditions for redistributing copies of GDB."); ! 1227: add_info ("warranty", warranty_info, "Various kinds of warranty you do not have."); ! 1228: add_info ("version", version_info, "Report what version of GDB this is."); ! 1229: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.