![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to source.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 source.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 ! root 1: /* List lines of source files 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 <stdio.h> ! 22: #include <sys/param.h> ! 23: #include <sys/stat.h> ! 24: #include <sys/file.h> ! 25: #include "defs.h" ! 26: #include "initialize.h" ! 27: #include "symtab.h" ! 28: ! 29: /* Path of directories to search for source files. ! 30: Same format as the PATH environment variable's value. */ ! 31: ! 32: static char *source_path; ! 33: ! 34: /* Symtab of default file for listing lines of. */ ! 35: ! 36: struct symtab *current_source_symtab; ! 37: ! 38: /* Default next line to list. */ ! 39: ! 40: int current_source_line; ! 41: ! 42: /* Line number of last line printed. Default for various commands. ! 43: current_source_line is usually, but not always, the same as this. */ ! 44: ! 45: static int last_line_listed; ! 46: ! 47: /* First line number listed by last listing command. */ ! 48: ! 49: static int first_line_listed; ! 50: ! 51: START_FILE ! 52: ! 53: /* Set the source file default for the "list" command, ! 54: specifying a symtab. */ ! 55: ! 56: void ! 57: select_source_symtab (s) ! 58: register struct symtab *s; ! 59: { ! 60: if (s) ! 61: { ! 62: struct symtab_and_line sal; ! 63: ! 64: /* Make the default place to list be the function `main' ! 65: if one exists. */ ! 66: if (lookup_symbol ("main", 0, VAR_NAMESPACE)) ! 67: { ! 68: sal = decode_line_spec ("main", 1); ! 69: current_source_symtab = sal.symtab; ! 70: current_source_line = sal.line - 9; ! 71: return; ! 72: } ! 73: ! 74: /* If there is no `main', use the last symtab in the list, ! 75: which is actually the first found in the file's symbol table. ! 76: But ignore .h files. */ ! 77: do ! 78: { ! 79: char *name = s->filename; ! 80: int len = strlen (name); ! 81: if (! (len > 2 && !strcmp (&name[len - 2], ".h"))) ! 82: current_source_symtab = s; ! 83: s = s->next; ! 84: } ! 85: while (s); ! 86: current_source_line = 1; ! 87: } ! 88: } ! 89: ! 90: static void ! 91: directories_info () ! 92: { ! 93: printf ("Source directories searched: %s\n", source_path); ! 94: } ! 95: ! 96: void ! 97: init_source_path () ! 98: { ! 99: register struct symtab *s; ! 100: ! 101: source_path = savestring (current_directory, strlen (current_directory)); ! 102: ! 103: /* Forget what we learned about line positions in source files; ! 104: must check again now since files may be found in ! 105: a different directory now. */ ! 106: for (s = symtab_list; s; s = s->next) ! 107: if (s->line_charpos != 0) ! 108: { ! 109: free (s->line_charpos); ! 110: s->line_charpos = 0; ! 111: } ! 112: } ! 113: ! 114: void ! 115: directory_command (dirname, from_tty) ! 116: char *dirname; ! 117: int from_tty; ! 118: { ! 119: char *old = source_path; ! 120: ! 121: if (dirname == 0) ! 122: { ! 123: if (query ("Reinitialize source path to %s? ", current_directory)) ! 124: { ! 125: init_source_path (); ! 126: free (old); ! 127: } ! 128: } ! 129: else ! 130: { ! 131: struct stat st; ! 132: register int len = strlen (dirname); ! 133: register char *tem; ! 134: extern char *index (); ! 135: ! 136: if (index (dirname, ':')) ! 137: error ("Please add one directory at a time to the source path."); ! 138: if (dirname[len - 1] == '/') ! 139: /* Sigh. "foo/" => "foo" */ ! 140: dirname[--len] == '\0'; ! 141: ! 142: while (dirname[len - 1] == '.') ! 143: { ! 144: if (len == 1) ! 145: { ! 146: /* "." => getwd () */ ! 147: dirname = current_directory; ! 148: goto append; ! 149: } ! 150: else if (dirname[len - 2] == '/') ! 151: { ! 152: if (len == 2) ! 153: { ! 154: /* "/." => "/" */ ! 155: dirname[--len] = '\0'; ! 156: goto append; ! 157: } ! 158: else ! 159: { ! 160: /* "...foo/." => "...foo" */ ! 161: dirname[len -= 2] = '\0'; ! 162: continue; ! 163: } ! 164: } ! 165: break; ! 166: } ! 167: ! 168: if (dirname[0] != '/') ! 169: dirname = concat (current_directory, "/", dirname); ! 170: else ! 171: dirname = savestring (dirname, len); ! 172: make_cleanup (free, dirname); ! 173: ! 174: if (stat (dirname, &st) < 0) ! 175: perror_with_name (dirname); ! 176: if ((st.st_mode & S_IFMT) != S_IFDIR) ! 177: error ("%s is not a directory.", dirname); ! 178: ! 179: append: ! 180: len = strlen (dirname); ! 181: tem = source_path; ! 182: while (1) ! 183: { ! 184: if (!strncmp (tem, dirname, len) ! 185: && (tem[len] == '\0' || tem[len] == ':')) ! 186: { ! 187: printf ("\"%s\" is already in the source path.\n", ! 188: dirname); ! 189: break; ! 190: } ! 191: tem = index (tem, ':'); ! 192: if (tem) ! 193: tem++; ! 194: else ! 195: { ! 196: source_path = concat (old, ":", dirname); ! 197: free (old); ! 198: break; ! 199: } ! 200: } ! 201: if (from_tty) ! 202: directories_info (); ! 203: } ! 204: } ! 205: ! 206: /* Open a file named STRING, searching path PATH (dir names sep by colons) ! 207: using mode MODE and protection bits PROT in the calls to open. ! 208: If TRY_CWD_FIRST, try to open ./STRING before searching PATH. ! 209: (ie pretend the first element of PATH is ".") ! 210: If FILENAMED_OPENED is non-null, set it to a newly allocated string naming ! 211: the actual file opened (this string will always start with a "/" ! 212: ! 213: If a file is found, return the descriptor. ! 214: Otherwise, return -1, with errno set for the last name we tried to open. */ ! 215: ! 216: /* >>>> This should only allow files of certain types, ! 217: >>>> eg executable, non-directory */ ! 218: int ! 219: openp (path, try_cwd_first, string, mode, prot, filename_opened) ! 220: char *path; ! 221: int try_cwd_first; ! 222: char *string; ! 223: int mode; ! 224: int prot; ! 225: char **filename_opened; ! 226: { ! 227: register int fd; ! 228: register char *filename; ! 229: register char *p, *p1; ! 230: register int len; ! 231: ! 232: /* ./foo => foo */ ! 233: while (string[0] == '.' && string[1] == '/') ! 234: string += 2; ! 235: ! 236: if (try_cwd_first || string[0] == '/') ! 237: { ! 238: filename = string; ! 239: fd = open (filename, mode, prot); ! 240: if (fd >= 0 || string[0] == '/') ! 241: goto done; ! 242: } ! 243: ! 244: filename = (char *) alloca (strlen (path) + strlen (string) + 2); ! 245: fd = -1; ! 246: for (p = path; p; p = p1 ? p1 + 1 : 0) ! 247: { ! 248: p1 = (char *) index (p, ':'); ! 249: if (p1) ! 250: len = p1 - p; ! 251: else ! 252: len = strlen (p); ! 253: ! 254: strncpy (filename, p, len); ! 255: filename[len] = 0; ! 256: strcat (filename, "/"); ! 257: strcat (filename, string); ! 258: ! 259: fd = open (filename, mode, prot); ! 260: if (fd >= 0) break; ! 261: } ! 262: ! 263: done: ! 264: if (filename_opened) ! 265: if (fd < 0) ! 266: *filename_opened = (char *) 0; ! 267: else if (filename[0] == '/') ! 268: *filename_opened = savestring (filename, strlen (filename)); ! 269: else ! 270: { ! 271: *filename_opened = concat (current_directory, "/", filename); ! 272: } ! 273: ! 274: return fd; ! 275: } ! 276: ! 277: /* Create and initialize the table S->line_charpos that records ! 278: the positions of the lines in the source file, which is assumed ! 279: to be open on descriptor DESC. ! 280: All set S->nlines to the number of such lines. */ ! 281: ! 282: static void ! 283: find_source_lines (s, desc) ! 284: struct symtab *s; ! 285: int desc; ! 286: { ! 287: struct stat st; ! 288: register char *data, *p, *end; ! 289: int nlines = 0; ! 290: int lines_allocated = 1000; ! 291: int *line_charpos = (int *) xmalloc (lines_allocated * sizeof (int)); ! 292: extern int exec_mtime; ! 293: ! 294: fstat (desc, &st); ! 295: if (get_exec_file (0) != 0 && exec_mtime < st.st_mtime) ! 296: printf ("Source file is more recent than executable.\n"); ! 297: ! 298: data = (char *) alloca (st.st_size); ! 299: myread (desc, data, st.st_size); ! 300: end = data + st.st_size; ! 301: p = data; ! 302: line_charpos[0] = 0; ! 303: nlines = 1; ! 304: while (p != end) ! 305: { ! 306: if (*p++ == '\n' ! 307: /* A newline at the end does not start a new line. */ ! 308: && p != end) ! 309: { ! 310: if (nlines == lines_allocated) ! 311: { ! 312: lines_allocated *= 2; ! 313: line_charpos = (int *) xrealloc (line_charpos, ! 314: sizeof (int) * lines_allocated); ! 315: } ! 316: line_charpos[nlines++] = p - data; ! 317: } ! 318: } ! 319: s->nlines = nlines; ! 320: s->line_charpos = (int *) xrealloc (line_charpos, nlines * sizeof (int)); ! 321: } ! 322: ! 323: /* Return the character position of a line LINE in symtab S. ! 324: Return 0 if anything is invalid. */ ! 325: ! 326: int ! 327: source_line_charpos (s, line) ! 328: struct symtab *s; ! 329: int line; ! 330: { ! 331: if (!s) return 0; ! 332: if (!s->line_charpos || line <= 0) return 0; ! 333: if (line > s->nlines) ! 334: line = s->nlines; ! 335: return s->line_charpos[line - 1]; ! 336: } ! 337: ! 338: /* Return the line number of character position POS in symtab S. */ ! 339: ! 340: int ! 341: source_charpos_line (s, chr) ! 342: register struct symtab *s; ! 343: register int chr; ! 344: { ! 345: register int line = 0; ! 346: register int *lnp; ! 347: ! 348: if (s == 0 || s->line_charpos == 0) return 0; ! 349: lnp = s->line_charpos; ! 350: /* Files are usually short, so sequential search is Ok */ ! 351: while (line < s->nlines && *lnp <= chr) ! 352: { ! 353: line++; ! 354: lnp++; ! 355: } ! 356: if (line >= s->nlines) ! 357: line = s->nlines; ! 358: return line; ! 359: } ! 360: ! 361: /* Get full pathname and line number positions for a symtab. ! 362: Return nonzero if line numbers may have changed. ! 363: Set *FULLNAME to actual name of the file as found by `openp', ! 364: or to 0 if the file is not found. */ ! 365: ! 366: int ! 367: get_filename_and_charpos (s, line, fullname) ! 368: struct symtab *s; ! 369: int line; ! 370: char **fullname; ! 371: { ! 372: register int desc, linenums_changed = 0; ! 373: ! 374: desc = openp (source_path, 0, s->filename, O_RDONLY, 0, &s->fullname); ! 375: if (desc < 0) ! 376: { ! 377: if (fullname) ! 378: *fullname = NULL; ! 379: return 0; ! 380: } ! 381: if (fullname) ! 382: *fullname = s->fullname; ! 383: if (s->line_charpos == 0) linenums_changed = 1; ! 384: if (linenums_changed) find_source_lines (s, desc); ! 385: close (desc); ! 386: return linenums_changed; ! 387: } ! 388: ! 389: /* Print text describing the full name of the source file S ! 390: and the line number LINE and its corresponding character position. ! 391: The text starts with two Ctrl-z so that the Emacs-GDB interface ! 392: can easily find it. ! 393: ! 394: MID_STATEMENT is nonzero if the PC is not at the beginning of that line. ! 395: ! 396: Return 1 if successful, 0 if could not find the file. */ ! 397: ! 398: int ! 399: identify_source_line (s, line, mid_statement) ! 400: struct symtab *s; ! 401: int line; ! 402: int mid_statement; ! 403: { ! 404: if (s->line_charpos == 0) ! 405: get_filename_and_charpos (s, line, 0); ! 406: if (s->fullname == 0) ! 407: return 0; ! 408: printf ("\032\032%s:%d:%d:%s\n", s->fullname, ! 409: line, s->line_charpos[line - 1], ! 410: mid_statement ? "middle" : "beg"); ! 411: current_source_line = line; ! 412: first_line_listed = line; ! 413: last_line_listed = line; ! 414: current_source_symtab = s; ! 415: return 1; ! 416: } ! 417: ! 418: /* Print source lines from the file of symtab S, ! 419: starting with line number LINE and stopping before line number STOPLINE. */ ! 420: ! 421: void ! 422: print_source_lines (s, line, stopline, noerror) ! 423: struct symtab *s; ! 424: int line, stopline; ! 425: int noerror; ! 426: { ! 427: register int c; ! 428: register int desc; ! 429: register FILE *stream; ! 430: int nlines = stopline - line; ! 431: ! 432: desc = openp (source_path, 0, s->filename, O_RDONLY, 0, &s->fullname); ! 433: if (desc < 0) ! 434: { ! 435: extern int errno; ! 436: if (! noerror) ! 437: perror_with_name (s->filename); ! 438: print_sys_errmsg (s->filename, errno); ! 439: return; ! 440: } ! 441: ! 442: if (s->line_charpos == 0) ! 443: find_source_lines (s, desc); ! 444: ! 445: if (line < 1 || line > s->nlines) ! 446: { ! 447: close (desc); ! 448: error ("Line number out of range; %s has %d lines.", ! 449: s->filename, s->nlines); ! 450: } ! 451: ! 452: if (lseek (desc, s->line_charpos[line - 1], 0) < 0) ! 453: { ! 454: close (desc); ! 455: perror_with_name (s->filename); ! 456: } ! 457: ! 458: current_source_symtab = s; ! 459: current_source_line = line; ! 460: first_line_listed = line; ! 461: ! 462: stream = fdopen (desc, "r"); ! 463: clearerr (stream); ! 464: ! 465: while (nlines-- > 0) ! 466: { ! 467: c = fgetc (stream); ! 468: if (c == EOF) break; ! 469: last_line_listed = current_source_line; ! 470: printf ("%d\t", current_source_line++); ! 471: do ! 472: { ! 473: if (c < 040 && c != '\t' && c != '\n') ! 474: { ! 475: fputc ('^', stdout); ! 476: fputc (c + 0100, stdout); ! 477: } ! 478: else if (c == 0177) ! 479: printf ("^?"); ! 480: else ! 481: fputc (c, stdout); ! 482: } while (c != '\n' && (c = fgetc (stream)) >= 0); ! 483: } ! 484: ! 485: fclose (stream); ! 486: } ! 487: ! 488: static void ! 489: list_command (arg, from_tty) ! 490: char *arg; ! 491: int from_tty; ! 492: { ! 493: struct symtab_and_line sal, sal_end; ! 494: struct symbol *sym; ! 495: char *arg1; ! 496: int no_end = 1; ! 497: int dummy_end = 0; ! 498: int dummy_beg = 0; ! 499: int linenum_beg = 0; ! 500: char *p; ! 501: ! 502: if (symtab_list == 0) ! 503: error ("Listing source lines requires symbols."); ! 504: ! 505: /* "l" or "l +" lists next ten lines. */ ! 506: ! 507: if (arg == 0 || !strcmp (arg, "+")) ! 508: { ! 509: if (current_source_symtab == 0) ! 510: error ("No default source file yet. Do \"help list\"."); ! 511: print_source_lines (current_source_symtab, current_source_line, ! 512: current_source_line + 10, 0); ! 513: return; ! 514: } ! 515: ! 516: /* "l -" lists previous ten lines, the ones before the ten just listed. */ ! 517: if (!strcmp (arg, "-")) ! 518: { ! 519: if (current_source_symtab == 0) ! 520: error ("No default source file yet. Do \"help list\"."); ! 521: print_source_lines (current_source_symtab, ! 522: max (first_line_listed - 10, 1), ! 523: first_line_listed, 0); ! 524: return; ! 525: } ! 526: ! 527: /* Now if there is only one argument, decode it in SAL ! 528: and set NO_END. ! 529: If there are two arguments, decode them in SAL and SAL_END ! 530: and clear NO_END; however, if one of the arguments is blank, ! 531: set DUMMY_BEG or DUMMY_END to record that fact. */ ! 532: ! 533: arg1 = arg; ! 534: if (*arg1 == ',') ! 535: dummy_beg = 1; ! 536: else ! 537: sal = decode_line_1 (&arg1, 0, 0, 0); ! 538: ! 539: /* Record whether the BEG arg is all digits. */ ! 540: ! 541: for (p = arg; p != arg1 && *p >= '0' && *p <= '9'; p++); ! 542: linenum_beg = (p == arg1); ! 543: ! 544: while (*arg1 == ' ' || *arg1 == '\t') ! 545: arg1++; ! 546: if (*arg1 == ',') ! 547: { ! 548: no_end = 0; ! 549: arg1++; ! 550: while (*arg1 == ' ' || *arg1 == '\t') ! 551: arg1++; ! 552: if (*arg1 == 0) ! 553: dummy_end = 1; ! 554: else if (dummy_beg) ! 555: sal_end = decode_line_1 (&arg1, 0, 0, 0); ! 556: else ! 557: sal_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line); ! 558: } ! 559: ! 560: if (*arg1) ! 561: error ("Junk at end of line specification."); ! 562: ! 563: if (!no_end && !dummy_beg && !dummy_end ! 564: && sal.symtab != sal_end.symtab) ! 565: error ("Specified start and end are in different files."); ! 566: if (dummy_beg && dummy_end) ! 567: error ("Two empty args do not say what lines to list."); ! 568: ! 569: /* if line was specified by address, ! 570: first print exactly which line, and which file. ! 571: In this case, sal.symtab == 0 means address is outside ! 572: of all known source files, not that user failed to give a filename. */ ! 573: if (*arg == '*') ! 574: { ! 575: if (sal.symtab == 0) ! 576: error ("No source file for address 0x%x.", sal.pc); ! 577: sym = find_pc_function (sal.pc); ! 578: if (sym) ! 579: printf ("0x%x is in %s (%s, line %d).\n", ! 580: sal.pc, SYMBOL_NAME (sym), sal.symtab->filename, sal.line); ! 581: else ! 582: printf ("0x%x is in %s, line %d.\n", ! 583: sal.pc, sal.symtab->filename, sal.line); ! 584: } ! 585: ! 586: /* If line was not specified by just a line number, ! 587: and it does not imply a symtab, it must be an undebuggable symbol ! 588: which means no source code. */ ! 589: ! 590: if (! linenum_beg && sal.symtab == 0) ! 591: error ("No line number known for %s.", arg); ! 592: ! 593: /* If this command is repeated with RET, ! 594: turn it into the no-arg variant. */ ! 595: ! 596: if (from_tty) ! 597: *arg = 0; ! 598: ! 599: if (dummy_beg && sal_end.symtab == 0) ! 600: error ("No default source file yet. Do \"help list\"."); ! 601: if (dummy_beg) ! 602: print_source_lines (sal_end.symtab, max (sal_end.line - 9, 1), ! 603: sal_end.line + 1, 0); ! 604: else if (sal.symtab == 0) ! 605: error ("No default source file yet. Do \"help list\"."); ! 606: else if (no_end) ! 607: print_source_lines (sal.symtab, max (sal.line - 5, 1), sal.line + 5, 0); ! 608: else ! 609: print_source_lines (sal.symtab, sal.line, ! 610: dummy_end ? sal.line + 10 : sal_end.line + 1, ! 611: 0); ! 612: } ! 613: ! 614: /* Print info on range of pc's in a specified line. */ ! 615: ! 616: static void ! 617: line_info (arg, from_tty) ! 618: char *arg; ! 619: int from_tty; ! 620: { ! 621: struct symtab_and_line sal; ! 622: int start_pc, end_pc; ! 623: ! 624: if (arg == 0) ! 625: { ! 626: sal.symtab = current_source_symtab; ! 627: sal.line = last_line_listed; ! 628: } ! 629: else ! 630: { ! 631: sal = decode_line_spec (arg, 0); ! 632: ! 633: /* If this command is repeated with RET, ! 634: turn it into the no-arg variant. */ ! 635: ! 636: if (from_tty) ! 637: *arg = 0; ! 638: } ! 639: ! 640: if (sal.symtab == 0) ! 641: error ("No source file specified."); ! 642: if (sal.line > 0 ! 643: && find_line_pc_range (sal.symtab, sal.line, &start_pc, &end_pc)) ! 644: { ! 645: if (start_pc == end_pc) ! 646: printf ("Line %d of \"%s\" is at pc 0x%x but contains no code.\n", ! 647: sal.line, sal.symtab->filename, start_pc); ! 648: else ! 649: printf ("Line %d of \"%s\" starts at pc 0x%x and ends at 0x%x.\n", ! 650: sal.line, sal.symtab->filename, start_pc, end_pc); ! 651: /* x/i should display this line's code. */ ! 652: set_next_address (start_pc); ! 653: /* Repeating "info line" should do the following line. */ ! 654: last_line_listed = sal.line + 1; ! 655: } ! 656: else ! 657: printf ("Line number %d is out of range for \"%s\".\n", ! 658: sal.line, sal.symtab->filename); ! 659: } ! 660: ! 661: /* Commands to search the source file for a regexp. */ ! 662: ! 663: static void ! 664: forward_search_command (regex, from_tty) ! 665: char *regex; ! 666: { ! 667: register int c; ! 668: register int desc; ! 669: register FILE *stream; ! 670: int line = last_line_listed + 1; ! 671: char *msg; ! 672: ! 673: msg = (char *) re_comp (regex); ! 674: if (msg) ! 675: error (msg); ! 676: ! 677: if (current_source_symtab == 0) ! 678: error ("No default source file yet. Do \"help list\"."); ! 679: ! 680: /* Search from last_line_listed+1 in current_source_symtab */ ! 681: ! 682: desc = openp (source_path, 0, current_source_symtab->filename, ! 683: O_RDONLY, 0, ¤t_source_symtab->fullname); ! 684: if (desc < 0) ! 685: perror_with_name (current_source_symtab->filename); ! 686: ! 687: if (current_source_symtab->line_charpos == 0) ! 688: find_source_lines (current_source_symtab, desc); ! 689: ! 690: if (line < 1 || line > current_source_symtab->nlines) ! 691: { ! 692: close (desc); ! 693: error ("Expression not found"); ! 694: } ! 695: ! 696: if (lseek (desc, current_source_symtab->line_charpos[line - 1], 0) < 0) ! 697: { ! 698: close (desc); ! 699: perror_with_name (current_source_symtab->filename); ! 700: } ! 701: ! 702: stream = fdopen (desc, "r"); ! 703: clearerr (stream); ! 704: while (1) { ! 705: char buf[4096]; /* Should be reasonable??? */ ! 706: register char *p = buf; ! 707: ! 708: c = fgetc (stream); ! 709: if (c == EOF) ! 710: break; ! 711: do { ! 712: *p++ = c; ! 713: } while (c != '\n' && (c = fgetc (stream)) >= 0); ! 714: ! 715: /* we now have a source line in buf, null terminate and match */ ! 716: *p = 0; ! 717: if (re_exec (buf) > 0) ! 718: { ! 719: /* Match! */ ! 720: fclose (stream); ! 721: print_source_lines (current_source_symtab, ! 722: line, line+1, 0); ! 723: current_source_line = max (line - 5, 1); ! 724: return; ! 725: } ! 726: line++; ! 727: } ! 728: ! 729: printf ("Expression not found\n"); ! 730: fclose (stream); ! 731: } ! 732: ! 733: static void ! 734: reverse_search_command (regex, from_tty) ! 735: char *regex; ! 736: { ! 737: register int c; ! 738: register int desc; ! 739: register FILE *stream; ! 740: int line = last_line_listed - 1; ! 741: char *msg; ! 742: ! 743: msg = (char *) re_comp (regex); ! 744: if (msg) ! 745: error (msg); ! 746: ! 747: if (current_source_symtab == 0) ! 748: error ("No default source file yet. Do \"help list\"."); ! 749: ! 750: /* Search from last_line_listed-1 in current_source_symtab */ ! 751: ! 752: desc = openp (source_path, 0, current_source_symtab->filename, ! 753: O_RDONLY, 0, ¤t_source_symtab->fullname); ! 754: if (desc < 0) ! 755: perror_with_name (current_source_symtab->filename); ! 756: ! 757: if (current_source_symtab->line_charpos == 0) ! 758: find_source_lines (current_source_symtab, desc); ! 759: ! 760: if (line < 1 || line > current_source_symtab->nlines) ! 761: { ! 762: close (desc); ! 763: error ("Expression not found"); ! 764: } ! 765: ! 766: if (lseek (desc, current_source_symtab->line_charpos[line - 1], 0) < 0) ! 767: { ! 768: close (desc); ! 769: perror_with_name (current_source_symtab->filename); ! 770: } ! 771: ! 772: stream = fdopen (desc, "r"); ! 773: clearerr (stream); ! 774: while (1) ! 775: { ! 776: char buf[4096]; /* Should be reasonable??? */ ! 777: register char *p = buf; ! 778: ! 779: c = fgetc (stream); ! 780: if (c == EOF) ! 781: break; ! 782: do { ! 783: *p++ = c; ! 784: } while (c != '\n' && (c = fgetc (stream)) >= 0); ! 785: ! 786: /* We now have a source line in buf; null terminate and match. */ ! 787: *p = 0; ! 788: if (re_exec (buf) > 0) ! 789: { ! 790: /* Match! */ ! 791: fclose (stream); ! 792: print_source_lines (current_source_symtab, ! 793: line, line+1, 0); ! 794: current_source_line = max (line - 5, 1); ! 795: return; ! 796: } ! 797: line--; ! 798: if (fseek (stream, current_source_symtab->line_charpos[line - 1], 0) < 0) ! 799: { ! 800: fclose (stream); ! 801: perror_with_name (current_source_symtab->filename); ! 802: } ! 803: } ! 804: ! 805: printf ("Expression not found\n"); ! 806: fclose (stream); ! 807: return; ! 808: } ! 809: ! 810: static ! 811: initialize () ! 812: { ! 813: current_source_symtab = 0; ! 814: init_source_path (); ! 815: ! 816: add_com ("directory", class_files, directory_command, ! 817: "Add directory DIR to end of search path for source files.\n\ ! 818: With no argument, reset the search path to just the working directory\n\ ! 819: and forget cached info on line positions in source files."); ! 820: ! 821: add_info ("directories", directories_info, ! 822: "Current search path for finding source files."); ! 823: ! 824: add_info ("line", line_info, ! 825: "Core addresses of the code for a source line.\n\ ! 826: Line can be specified as\n\ ! 827: LINENUM, to list around that line in current file,\n\ ! 828: FILE:LINENUM, to list around that line in that file,\n\ ! 829: FUNCTION, to list around beginning of that function,\n\ ! 830: FILE:FUNCTION, to distinguish among like-named static functions.\n\ ! 831: Default is to describe the last source line that was listed.\n\n\ ! 832: This sets the default address for \"x\" to the line's first instruction\n\ ! 833: so that \"x/i\" suffices to start examining the machine code.\n\ ! 834: The address is also stored as the value of \"$_\"."); ! 835: ! 836: add_com ("forward-search", class_files, forward_search_command, ! 837: "Search for regular expression (see regex(3)) from last line listed."); ! 838: add_com_alias ("search", "forward-search", class_files, 0); ! 839: ! 840: add_com ("reverse-search", class_files, reverse_search_command, ! 841: "Search backward for regular expression (see regex(3)) from last line listed."); ! 842: ! 843: add_com ("list", class_files, list_command, ! 844: "List specified function or line.\n\ ! 845: With no argument, lists ten more lines after or around previous listing.\n\ ! 846: \"list -\" lists the ten lines before a previous ten-line listing.\n\ ! 847: One argument specifies a line, and ten lines are listed around that line.\n\ ! 848: Two arguments with comma between specify starting and ending lines to list.\n\ ! 849: Lines can be specified in these ways:\n\ ! 850: LINENUM, to list around that line in current file,\n\ ! 851: FILE:LINENUM, to list around that line in that file,\n\ ! 852: FUNCTION, to list around beginning of that function,\n\ ! 853: FILE:FUNCTION, to distinguish among like-named static functions.\n\ ! 854: *ADDRESS, to list around the line containing that address.\n\ ! 855: With two args if one is empty it stands for ten lines away from the other arg."); ! 856: } ! 857: ! 858: END_FILE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.