void set_gdb_data_directory (const char *new_datadir) { struct stat st; if (stat (new_datadir, &st) < 0) { int save_errno = errno; fprintf_unfiltered (gdb_stderr, "Warning: "); print_sys_errmsg (new_datadir, save_errno); } else if (!S_ISDIR (st.st_mode)) warning (_("%s is not a directory."), new_datadir); xfree (gdb_datadir); gdb_datadir = gdb_realpath (new_datadir); /* gdb_realpath won't return an absolute path if the path doesn't exist, but we still want to record an absolute path here. If the user entered "../foo" and "../foo" doesn't exist then we'll record $(pwd)/../foo which isn't canonical, but that's ok. */ if (!IS_ABSOLUTE_PATH (gdb_datadir)) { char *abs_datadir = gdb_abspath (gdb_datadir); xfree (gdb_datadir); gdb_datadir = abs_datadir; } }
ps_err_e ps_lgetxregsize (gdb_ps_prochandle_t ph, lwpid_t lwpid, int *xregsize) { #if 0 int lwp_fd; int regsize; ps_err_e val; val = get_lwp_fd (ph, lwpid, &lwp_fd); if (val != PS_OK) return val; if (ioctl (lwp_fd, PIOCGXREGSIZE, ®size)) { if (errno == EINVAL) return PS_NOFREGS; /* XXX Wrong code, but this is the closest thing in proc_service.h */ print_sys_errmsg ("ps_lgetxregsize (): PIOCGXREGSIZE", errno); return PS_ERR; } #endif return PS_OK; }
void new_tty (void) { int tty; if (inferior_thisrun_terminal == 0) return; #if !defined(__GO32__) && !defined(_WIN32) #ifdef TIOCNOTTY /* Disconnect the child process from our controlling terminal. On some systems (SVR4 for example), this may cause a SIGTTOU, so temporarily ignore SIGTTOU. */ tty = open ("/dev/tty", O_RDWR); if (tty > 0) { void (*osigttou) (); osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN); ioctl (tty, TIOCNOTTY, 0); close (tty); signal (SIGTTOU, osigttou); } #endif /* Now open the specified new terminal. */ #ifdef USE_O_NOCTTY tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY); #else tty = open (inferior_thisrun_terminal, O_RDWR); #endif if (tty == -1) { print_sys_errmsg (inferior_thisrun_terminal, errno); _exit (1); } /* Avoid use of dup2; doesn't exist on all systems. */ if (tty != 0) { close (0); dup (tty); } if (tty != 1) { close (1); dup (tty); } if (tty != 2) { close (2); dup (tty); } if (tty > 2) close (tty); #endif /* !go32 && !win32 */ }
ps_err_e ps_lsetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset) { #if 0 int lwp_fd; ps_err_e val; val = get_lwp_fd (ph, lwpid, &lwp_fd); if (val != PS_OK) return val; if (ioctl (lwp_fd, PIOCSXREG, xregset)) { print_sys_errmsg ("ps_lsetxregs (): PIOCSXREG", errno); return PS_ERR; } #endif return PS_OK; }
static ps_err_e rw_common (int dowrite, const struct ps_prochandle *ph, gdb_ps_addr_t addr, char *buf, int size) { struct cleanup *old_chain; old_chain = save_inferior_ptid (); if (is_thread (inferior_ptid) || /* A thread */ !target_thread_alive (inferior_ptid)) /* An lwp, but not alive */ inferior_ptid = procfs_first_available (); /* Find any live lwp. */ /* Note: don't need to call switch_to_thread; we're just reading memory. */ #if defined (__sparcv9) /* For Sparc64 cross Sparc32, make sure the address has not been accidentally sign-extended (or whatever) to beyond 32 bits. */ if (bfd_get_arch_size (exec_bfd) == 32) addr &= 0xffffffff; #endif while (size > 0) { int cc; /* FIXME: passing 0 as attrib argument. */ if (target_has_execution) cc = procfs_ops.to_xfer_memory (addr, buf, size, dowrite, 0, &procfs_ops); else cc = orig_core_ops.to_xfer_memory (addr, buf, size, dowrite, 0, &core_ops); if (cc < 0) { if (dowrite == 0) print_sys_errmsg ("rw_common (): read", errno); else print_sys_errmsg ("rw_common (): write", errno); do_cleanups (old_chain); return PS_ERR; } else if (cc == 0) { if (dowrite == 0) warning ("rw_common (): unable to read at addr 0x%lx", (long) addr); else warning ("rw_common (): unable to write at addr 0x%lx", (long) addr); do_cleanups (old_chain); return PS_ERR; } size -= cc; buf += cc; } do_cleanups (old_chain); return PS_OK; }
/* Function to display source in the source window. */ enum tui_status tui_set_source_content (struct symtab *s, int line_no, int noerror) { enum tui_status ret = TUI_FAILURE; if (s != (struct symtab *) NULL && s->filename != (char *) NULL) { FILE *stream; int i, desc, c, line_width, nlines; char *src_line = 0; if ((ret = tui_alloc_source_buffer (TUI_SRC_WIN)) == TUI_SUCCESS) { line_width = TUI_SRC_WIN->generic.width - 1; /* Take hilite (window border) into account, when calculating the number of lines */ nlines = (line_no + (TUI_SRC_WIN->generic.height - 2)) - line_no; desc = open_source_file (s); if (desc < 0) { if (!noerror) { char *name = alloca (strlen (s->filename) + 100); sprintf (name, "%s:%d", s->filename, line_no); print_sys_errmsg (name, errno); } ret = TUI_FAILURE; } else { if (s->line_charpos == 0) find_source_lines (s, desc); if (line_no < 1 || line_no > s->nlines) { close (desc); printf_unfiltered ( "Line number %d out of range; %s has %d lines.\n", line_no, s->filename, s->nlines); } else if (lseek (desc, s->line_charpos[line_no - 1], 0) < 0) { close (desc); perror_with_name (s->filename); } else { int offset, cur_line_no, cur_line, cur_len, threshold; struct tui_gen_win_info * locator = tui_locator_win_info_ptr (); struct tui_source_info * src = &TUI_SRC_WIN->detail.source_info; if (TUI_SRC_WIN->generic.title) xfree (TUI_SRC_WIN->generic.title); TUI_SRC_WIN->generic.title = xstrdup (s->filename); if (src->filename) xfree (src->filename); src->filename = xstrdup (s->filename); /* Determine the threshold for the length of the line and the offset to start the display. */ offset = src->horizontal_offset; threshold = (line_width - 1) + offset; stream = fdopen (desc, FOPEN_RT); clearerr (stream); cur_line = 0; src->start_line_or_addr.loa = LOA_LINE; cur_line_no = src->start_line_or_addr.u.line_no = line_no; if (offset > 0) src_line = (char *) xmalloc ( (threshold + 1) * sizeof (char)); while (cur_line < nlines) { struct tui_win_element * element = (struct tui_win_element *) TUI_SRC_WIN->generic.content[cur_line]; /* get the first character in the line */ c = fgetc (stream); if (offset == 0) src_line = ((struct tui_win_element *) TUI_SRC_WIN->generic.content[ cur_line])->which_element.source.line; /* Init the line with the line number */ sprintf (src_line, "%-6d", cur_line_no); cur_len = strlen (src_line); i = cur_len - ((cur_len / tui_default_tab_len ()) * tui_default_tab_len ()); while (i < tui_default_tab_len ()) { src_line[cur_len] = ' '; i++; cur_len++; } src_line[cur_len] = (char) 0; /* Set whether element is the execution point and whether there is a break point on it. */ element->which_element.source.line_or_addr.loa = LOA_LINE; element->which_element.source.line_or_addr.u.line_no = cur_line_no; element->which_element.source.is_exec_point = (strcmp (((struct tui_win_element *) locator->content[0])->which_element.locator.file_name, s->filename) == 0 && cur_line_no == ((struct tui_win_element *) locator->content[0])->which_element.locator.line_no); if (c != EOF) { i = strlen (src_line) - 1; do { if ((c != '\n') && (c != '\r') && (++i < threshold)) { if (c < 040 && c != '\t') { src_line[i++] = '^'; src_line[i] = c + 0100; } else if (c == 0177) { src_line[i++] = '^'; src_line[i] = '?'; } else { /* Store the charcter in the line buffer. If it is a tab, then translate to the correct number of chars so we don't overwrite our buffer. */ if (c == '\t') { int j, max_tab_len = tui_default_tab_len (); for (j = i - ( (i / max_tab_len) * max_tab_len); ((j < max_tab_len) && i < threshold); i++, j++) src_line[i] = ' '; i--; } else src_line[i] = c; } src_line[i + 1] = 0; } else { /* If we have not reached EOL, then eat chars until we do */ while (c != EOF && c != '\n' && c != '\r') c = fgetc (stream); } } while (c != EOF && c != '\n' && c != '\r' && i < threshold && (c = fgetc (stream))); } /* Now copy the line taking the offset into account */ if (strlen (src_line) > offset) strcpy (((struct tui_win_element *) TUI_SRC_WIN->generic.content[ cur_line])->which_element.source.line, &src_line[offset]); else ((struct tui_win_element *) TUI_SRC_WIN->generic.content[ cur_line])->which_element.source.line[0] = (char) 0; cur_line++; cur_line_no++; } if (offset > 0) xfree (src_line); fclose (stream); TUI_SRC_WIN->generic.content_size = nlines; ret = TUI_SUCCESS; } } } } return ret; }