/* Take a snapshot of Emacs and make a Mach-O format executable file from it. The file names of the output and input files are outfile and infile, respectively. The three other parameters are ignored. */ void unexec (const char *outfile, const char *infile) { if (in_dumped_exec) unexec_error ("Unexec from a dumped executable is not supported."); pagesize = getpagesize (); infd = emacs_open (infile, O_RDONLY, 0); if (infd < 0) { unexec_error ("cannot open input file `%s'", infile); } outfd = emacs_open (outfile, O_WRONLY | O_TRUNC | O_CREAT, 0755); if (outfd < 0) { emacs_close (infd); unexec_error ("cannot open output file `%s'", outfile); } build_region_list (); read_load_commands (); find_emacs_zone_regions (); unexec_regions_merge (); in_dumped_exec = 1; dump_it (); emacs_close (outfd); }
void unexec (const char *outfile, const char *infile) { char infile_buffer[FILENAME_MAX]; char outfile_buffer[FILENAME_MAX]; int fd_in; int fd_out; int ret; int ret2; if (bss_sbrk_did_unexec) { /* can only dump once */ printf ("You can only dump Emacs once on this platform.\n"); return; } report_sheap_usage (1); infile = add_exe_suffix_if_necessary (infile, infile_buffer); outfile = add_exe_suffix_if_necessary (outfile, outfile_buffer); fd_in = emacs_open (infile, O_RDONLY | O_BINARY, 0); assert (fd_in >= 0); fd_out = emacs_open (outfile, O_RDWR | O_TRUNC | O_CREAT | O_BINARY, 0755); assert (fd_out >= 0); for (;;) { char buffer[4096]; ret = read (fd_in, buffer, sizeof (buffer)); if (ret == 0) { /* eof */ break; } assert (ret > 0); /* data */ ret2 = write (fd_out, buffer, ret); assert (ret2 == ret); } ret = emacs_close (fd_in); assert (ret == 0); bss_sbrk_did_unexec = 1; fixup_executable (fd_out); bss_sbrk_did_unexec = 0; ret = emacs_close (fd_out); assert (ret == 0); }
static Lisp_Object call_process_cleanup (Lisp_Object arg) { Lisp_Object fdpid = Fcdr (arg); int fd; #if defined (MSDOS) Lisp_Object file; #else pid_t pid; #endif Fset_buffer (Fcar (arg)); CONS_TO_INTEGER (Fcar (fdpid), int, fd); #if defined (MSDOS) /* for MSDOS fdpid is really (fd . tempfile) */ file = Fcdr (fdpid); /* FD is -1 and FILE is "" when we didn't actually create a temporary file in call-process. */ if (fd >= 0) emacs_close (fd); if (!(strcmp (SDATA (file), NULL_DEVICE) == 0 || SREF (file, 0) == '\0')) unlink (SDATA (file)); #else /* not MSDOS */ CONS_TO_INTEGER (Fcdr (fdpid), pid_t, pid); if (call_process_exited) { emacs_close (fd); return Qnil; } if (EMACS_KILLPG (pid, SIGINT) == 0) { ptrdiff_t count = SPECPDL_INDEX (); record_unwind_protect (call_process_kill, fdpid); message1 ("Waiting for process to die...(type C-g again to kill it instantly)"); immediate_quit = 1; QUIT; wait_for_termination (pid); immediate_quit = 0; specpdl_ptr = specpdl + count; /* Discard the unwind protect. */ message1 ("Waiting for process to die...done"); } synch_process_alive = 0; emacs_close (fd); #endif /* not MSDOS */ return Qnil; }
/* Remove all watches associated with the watch list element after PREVTAIL, or after the first element if PREVTAIL is t. If INVALID_P is true, the descriptor is already invalid, i.e., it received a IN_IGNORED event. In this case skip calling inotify_rm_watch. */ static void remove_descriptor (Lisp_Object prevtail, bool invalid_p) { Lisp_Object tail = CONSP (prevtail) ? XCDR (prevtail) : watch_list; int inotify_errno = 0; if (! invalid_p) { int wd; CONS_TO_INTEGER (XCAR (XCAR (tail)), int, wd); if (inotify_rm_watch (inotifyfd, wd) != 0) inotify_errno = errno; } if (CONSP (prevtail)) XSETCDR (prevtail, XCDR (tail)); else { watch_list = XCDR (tail); if (NILP (watch_list)) { delete_read_fd (inotifyfd); emacs_close (inotifyfd); inotifyfd = -1; } } if (inotify_errno != 0) { errno = inotify_errno; report_file_notify_error ("Could not rm watch", XCAR (tail)); } }
static void vox_close (struct sound_device *sd) { if (sd->fd >= 0) { /* On GNU/Linux, it seems that the device driver doesn't like to be interrupted by a signal. Block the ones we know to cause troubles. */ #ifdef SIGIO sigblock (sigmask (SIGIO)); #endif turn_on_atimers (0); /* Flush sound data, and reset the device. */ ioctl (sd->fd, SNDCTL_DSP_SYNC, NULL); turn_on_atimers (1); #ifdef SIGIO sigunblock (sigmask (SIGIO)); #endif /* Close the device. */ emacs_close (sd->fd); sd->fd = -1; } }
static DIR * open_directory (Lisp_Object dirname, int *fdp) { char *name = SSDATA (dirname); DIR *d; int fd, opendir_errno; #ifdef DOS_NT /* Directories cannot be opened. The emulation assumes that any file descriptor other than AT_FDCWD corresponds to the most recently opened directory. This hack is good enough for Emacs. */ fd = 0; d = opendir (name); opendir_errno = errno; #else fd = emacs_open (name, O_RDONLY | O_DIRECTORY, 0); if (fd < 0) { opendir_errno = errno; d = 0; } else { d = fdopendir (fd); opendir_errno = errno; if (! d) emacs_close (fd); } #endif if (!d) report_file_errno ("Opening directory", dirname, opendir_errno); *fdp = fd; return d; }
static int vox_init (struct sound_device *sd) { const char *file; int fd; /* Open the sound device. Default is /dev/dsp. */ if (sd->file) file = sd->file; else file = DEFAULT_SOUND_DEVICE; fd = emacs_open (file, O_WRONLY, 0); if (fd >= 0) emacs_close (fd); else return 0; sd->fd = -1; sd->open = vox_open; sd->close = vox_close; sd->configure = vox_configure; sd->choose_format = vox_choose_format; sd->write = vox_write; sd->period_size = NULL; return 1; }
static void vox_close (struct sound_device *sd) { if (sd->fd >= 0) { /* On GNU/Linux, it seems that the device driver doesn't like to be interrupted by a signal. Block the ones we know to cause troubles. */ #ifdef USABLE_SIGIO sigset_t blocked, oldset; sigemptyset (&blocked); sigaddset (&blocked, SIGIO); pthread_sigmask (SIG_BLOCK, &blocked, &oldset); #endif turn_on_atimers (0); /* Flush sound data, and reset the device. */ ioctl (sd->fd, SNDCTL_DSP_SYNC, NULL); turn_on_atimers (1); #ifdef USABLE_SIGIO pthread_sigmask (SIG_SETMASK, &oldset, 0); #endif /* Close the device. */ emacs_close (sd->fd); sd->fd = -1; } }
static Lisp_Object call_process_kill (Lisp_Object fdpid) { emacs_close (XFASTINT (Fcar (fdpid))); EMACS_KILLPG (XFASTINT (Fcdr (fdpid)), SIGKILL); synch_process_alive = 0; return Qnil; }
report_error_1 (int fd, const char *msg, ...) { va_list ap; emacs_close (fd); va_start (ap, msg); verror (msg, ap); va_end (ap); }
static void report_error (const char *file, int fd) { int err = errno; if (fd) emacs_close (fd); report_file_errno ("Cannot unexec", build_string (file), err); }
static Lisp_Object call_process_cleanup (Lisp_Object arg) { Lisp_Object fdpid = Fcdr (arg); #if defined (MSDOS) Lisp_Object file; #else int pid; #endif Fset_buffer (Fcar (arg)); #if defined (MSDOS) /* for MSDOS fdpid is really (fd . tempfile) */ file = Fcdr (fdpid); emacs_close (XFASTINT (Fcar (fdpid))); if (strcmp (SDATA (file), NULL_DEVICE) != 0) unlink (SDATA (file)); #else /* not MSDOS */ pid = XFASTINT (Fcdr (fdpid)); if (call_process_exited) { emacs_close (XFASTINT (Fcar (fdpid))); return Qnil; } if (EMACS_KILLPG (pid, SIGINT) == 0) { int count = SPECPDL_INDEX (); record_unwind_protect (call_process_kill, fdpid); message1 ("Waiting for process to die...(type C-g again to kill it instantly)"); immediate_quit = 1; QUIT; wait_for_termination (pid); immediate_quit = 0; specpdl_ptr = specpdl + count; /* Discard the unwind protect. */ message1 ("Waiting for process to die...done"); } synch_process_alive = 0; emacs_close (XFASTINT (Fcar (fdpid))); #endif /* not MSDOS */ return Qnil; }
static void sound_cleanup (void) { if (current_sound_device->close) current_sound_device->close (current_sound_device); if (current_sound->fd > 0) emacs_close (current_sound->fd); xfree (current_sound_device); xfree (current_sound); }
static Lisp_Object call_process_kill (Lisp_Object fdpid) { int fd; pid_t pid; CONS_TO_INTEGER (Fcar (fdpid), int, fd); CONS_TO_INTEGER (Fcdr (fdpid), pid_t, pid); emacs_close (fd); EMACS_KILLPG (pid, SIGKILL); synch_process_alive = 0; return Qnil; }
static Lisp_Object sound_cleanup (Lisp_Object arg) { if (current_sound_device->close) current_sound_device->close (current_sound_device); if (current_sound->fd > 0) emacs_close (current_sound->fd); free (current_sound_device); free (current_sound); return Qnil; }
void get_boot_time_1 (const char *filename, int newest) { struct utmp ut, *utp; int desc; if (filename) { /* On some versions of IRIX, opening a nonexistent file name is likely to crash in the utmp routines. */ desc = emacs_open (filename, O_RDONLY, 0); if (desc < 0) return; emacs_close (desc); utmpname (filename); } setutent (); while (1) { /* Find the next reboot record. */ ut.ut_type = BOOT_TIME; utp = getutid (&ut); if (! utp) break; /* Compare reboot times and use the newest one. */ if (utp->ut_time > boot_time) { boot_time = utp->ut_time; if (! newest) break; } /* Advance on element in the file so that getutid won't repeat the same one. */ utp = getutent (); if (! utp) break; } endutent (); }
static void call_process_kill (void *ptr) { int *callproc_fd = ptr; int i; for (i = 0; i < CALLPROC_FDS; i++) if (0 <= callproc_fd[i]) emacs_close (callproc_fd[i]); if (synch_process_pid) { struct Lisp_Process proc; proc.alive = 1; proc.pid = synch_process_pid; record_kill_process (&proc, synch_process_tempfile); synch_process_pid = 0; } else if (STRINGP (synch_process_tempfile)) delete_temp_file (synch_process_tempfile); }
static bool vox_init (struct sound_device *sd) { /* Open the sound device (eg /dev/dsp). */ char const *file = string_default (sd->file, DEFAULT_SOUND_DEVICE); int fd = emacs_open (file, O_WRONLY, 0); if (fd >= 0) emacs_close (fd); else return 0; sd->fd = -1; sd->open = vox_open; sd->close = vox_close; sd->configure = vox_configure; sd->choose_format = vox_choose_format; sd->write = vox_write; sd->period_size = NULL; return 1; }
static DIR * open_directory (char const *name, int *fdp) { DIR *d; int fd, opendir_errno; block_input (); #ifdef DOS_NT /* Directories cannot be opened. The emulation assumes that any file descriptor other than AT_FDCWD corresponds to the most recently opened directory. This hack is good enough for Emacs. */ fd = 0; d = opendir (name); opendir_errno = errno; #else fd = emacs_open (name, O_RDONLY | O_DIRECTORY, 0); if (fd < 0) { opendir_errno = errno; d = 0; } else { d = fdopendir (fd); opendir_errno = errno; if (! d) emacs_close (fd); } #endif unblock_input (); *fdp = fd; errno = opendir_errno; return d; }
Lisp_Object get_doc_string (Lisp_Object filepos, int unibyte, int definition) { char *from, *to; register int fd; register char *name; register char *p, *p1; EMACS_INT minsize; EMACS_INT offset, position; Lisp_Object file, tem; if (INTEGERP (filepos)) { file = Vdoc_file_name; position = XINT (filepos); } else if (CONSP (filepos)) { file = XCAR (filepos); position = XINT (XCDR (filepos)); } else return Qnil; if (position < 0) position = - position; if (!STRINGP (Vdoc_directory)) return Qnil; if (!STRINGP (file)) return Qnil; /* Put the file name in NAME as a C string. If it is relative, combine it with Vdoc_directory. */ tem = Ffile_name_absolute_p (file); if (NILP (tem)) { minsize = SCHARS (Vdoc_directory); /* sizeof ("../etc/") == 8 */ if (minsize < 8) minsize = 8; name = (char *) alloca (minsize + SCHARS (file) + 8); strcpy (name, SSDATA (Vdoc_directory)); strcat (name, SSDATA (file)); } else { name = SSDATA (file); } fd = emacs_open (name, O_RDONLY, 0); if (fd < 0) { #ifndef CANNOT_DUMP if (!NILP (Vpurify_flag)) { /* Preparing to dump; DOC file is probably not installed. So check in ../etc. */ strcpy (name, "../etc/"); strcat (name, SSDATA (file)); fd = emacs_open (name, O_RDONLY, 0); } #endif if (fd < 0) error ("Cannot open doc string file \"%s\"", name); } /* Seek only to beginning of disk block. */ /* Make sure we read at least 1024 bytes before `position' so we can check the leading text for consistency. */ offset = min (position, max (1024, position % (8 * 1024))); if (0 > lseek (fd, position - offset, 0)) { emacs_close (fd); error ("Position %"pI"d out of range in doc string file \"%s\"", position, name); } /* Read the doc string into get_doc_string_buffer. P points beyond the data just read. */ p = get_doc_string_buffer; while (1) { EMACS_INT space_left = (get_doc_string_buffer_size - (p - get_doc_string_buffer)); int nread; /* Allocate or grow the buffer if we need to. */ if (space_left == 0) { EMACS_INT in_buffer = p - get_doc_string_buffer; get_doc_string_buffer_size += 16 * 1024; get_doc_string_buffer = (char *) xrealloc (get_doc_string_buffer, get_doc_string_buffer_size + 1); p = get_doc_string_buffer + in_buffer; space_left = (get_doc_string_buffer_size - (p - get_doc_string_buffer)); } /* Read a disk block at a time. If we read the same block last time, maybe skip this? */ if (space_left > 1024 * 8) space_left = 1024 * 8; nread = emacs_read (fd, p, space_left); if (nread < 0) { emacs_close (fd); error ("Read error on documentation file"); } p[nread] = 0; if (!nread) break; if (p == get_doc_string_buffer) p1 = strchr (p + offset, '\037'); else p1 = strchr (p, '\037'); if (p1) { *p1 = 0; p = p1; break; } p += nread; } emacs_close (fd); /* Sanity checking. */ if (CONSP (filepos)) { int test = 1; if (get_doc_string_buffer[offset - test++] != ' ') return Qnil; while (get_doc_string_buffer[offset - test] >= '0' && get_doc_string_buffer[offset - test] <= '9') test++; if (get_doc_string_buffer[offset - test++] != '@' || get_doc_string_buffer[offset - test] != '#') return Qnil; } else { int test = 1; if (get_doc_string_buffer[offset - test++] != '\n') return Qnil; while (get_doc_string_buffer[offset - test] > ' ') test++; if (get_doc_string_buffer[offset - test] != '\037') return Qnil; } /* Scan the text and perform quoting with ^A (char code 1). ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */ from = get_doc_string_buffer + offset; to = get_doc_string_buffer + offset; while (from != p) { if (*from == 1) { int c; from++; c = *from++; if (c == 1) *to++ = c; else if (c == '0') *to++ = 0; else if (c == '_') *to++ = 037; else { unsigned char uc = c; error ("\ Invalid data in documentation file -- %c followed by code %03o", 1, uc); } } else *to++ = *from++; } /* If DEFINITION, read from this buffer the same way we would read bytes from a file. */ if (definition) { read_bytecode_pointer = (unsigned char *) get_doc_string_buffer + offset; return Fread (Qlambda); } if (unibyte) return make_unibyte_string (get_doc_string_buffer + offset, to - (get_doc_string_buffer + offset)); else { /* The data determines whether the string is multibyte. */ EMACS_INT nchars = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer + offset), to - (get_doc_string_buffer + offset)); return make_string_from_bytes (get_doc_string_buffer + offset, nchars, to - (get_doc_string_buffer + offset)); } }
Lisp_Object get_doc_string (Lisp_Object filepos, bool unibyte, bool definition) { char *from, *to, *name, *p, *p1; int fd; ptrdiff_t minsize; int offset; EMACS_INT position; Lisp_Object file, tem, pos; USE_SAFE_ALLOCA; if (INTEGERP (filepos)) { file = Vdoc_file_name; pos = filepos; } else if (CONSP (filepos)) { file = XCAR (filepos); pos = XCDR (filepos); } else return Qnil; position = eabs (XINT (pos)); if (!STRINGP (Vdoc_directory)) return Qnil; if (!STRINGP (file)) return Qnil; /* Put the file name in NAME as a C string. If it is relative, combine it with Vdoc_directory. */ tem = Ffile_name_absolute_p (file); file = ENCODE_FILE (file); if (NILP (tem)) { Lisp_Object docdir = ENCODE_FILE (Vdoc_directory); minsize = SCHARS (docdir); /* sizeof ("../etc/") == 8 */ if (minsize < 8) minsize = 8; name = SAFE_ALLOCA (minsize + SCHARS (file) + 8); strcpy (name, SSDATA (docdir)); strcat (name, SSDATA (file)); } else { name = SSDATA (file); } fd = emacs_open (name, O_RDONLY, 0); if (fd < 0) { #ifndef CANNOT_DUMP if (!NILP (Vpurify_flag)) { /* Preparing to dump; DOC file is probably not installed. So check in ../etc. */ strcpy (name, "../etc/"); strcat (name, SSDATA (file)); fd = emacs_open (name, O_RDONLY, 0); } #endif if (fd < 0) return concat3 (build_string ("Cannot open doc string file \""), file, build_string ("\"\n")); } /* Seek only to beginning of disk block. */ /* Make sure we read at least 1024 bytes before `position' so we can check the leading text for consistency. */ offset = min (position, max (1024, position % (8 * 1024))); if (TYPE_MAXIMUM (off_t) < position || lseek (fd, position - offset, 0) < 0) { emacs_close (fd); error ("Position %"pI"d out of range in doc string file \"%s\"", position, name); } SAFE_FREE (); /* Read the doc string into get_doc_string_buffer. P points beyond the data just read. */ p = get_doc_string_buffer; while (1) { ptrdiff_t space_left = (get_doc_string_buffer_size - 1 - (p - get_doc_string_buffer)); int nread; /* Allocate or grow the buffer if we need to. */ if (space_left <= 0) { ptrdiff_t in_buffer = p - get_doc_string_buffer; get_doc_string_buffer = xpalloc (get_doc_string_buffer, &get_doc_string_buffer_size, 16 * 1024, -1, 1); p = get_doc_string_buffer + in_buffer; space_left = (get_doc_string_buffer_size - 1 - (p - get_doc_string_buffer)); } /* Read a disk block at a time. If we read the same block last time, maybe skip this? */ if (space_left > 1024 * 8) space_left = 1024 * 8; nread = emacs_read (fd, p, space_left); if (nread < 0) { emacs_close (fd); error ("Read error on documentation file"); } p[nread] = 0; if (!nread) break; if (p == get_doc_string_buffer) p1 = strchr (p + offset, '\037'); else p1 = strchr (p, '\037'); if (p1) { *p1 = 0; p = p1; break; } p += nread; } emacs_close (fd); /* Sanity checking. */ if (CONSP (filepos)) { int test = 1; /* A dynamic docstring should be either at the very beginning of a "#@ comment" or right after a dynamic docstring delimiter (in case we pack several such docstrings within the same comment). */ if (get_doc_string_buffer[offset - test] != '\037') { if (get_doc_string_buffer[offset - test++] != ' ') return Qnil; while (get_doc_string_buffer[offset - test] >= '0' && get_doc_string_buffer[offset - test] <= '9') test++; if (get_doc_string_buffer[offset - test++] != '@' || get_doc_string_buffer[offset - test] != '#') return Qnil; } } else { int test = 1; if (get_doc_string_buffer[offset - test++] != '\n') return Qnil; while (get_doc_string_buffer[offset - test] > ' ') test++; if (get_doc_string_buffer[offset - test] != '\037') return Qnil; } /* Scan the text and perform quoting with ^A (char code 1). ^A^A becomes ^A, ^A0 becomes a null char, and ^A_ becomes a ^_. */ from = get_doc_string_buffer + offset; to = get_doc_string_buffer + offset; while (from != p) { if (*from == 1) { int c; from++; c = *from++; if (c == 1) *to++ = c; else if (c == '0') *to++ = 0; else if (c == '_') *to++ = 037; else { unsigned char uc = c; error ("\ Invalid data in documentation file -- %c followed by code %03o", 1, uc); } } else *to++ = *from++; } /* If DEFINITION, read from this buffer the same way we would read bytes from a file. */ if (definition) { read_bytecode_pointer = (unsigned char *) get_doc_string_buffer + offset; return Fread (Qlambda); } if (unibyte) return make_unibyte_string (get_doc_string_buffer + offset, to - (get_doc_string_buffer + offset)); else { /* The data determines whether the string is multibyte. */ ptrdiff_t nchars = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer + offset), to - (get_doc_string_buffer + offset)); return make_string_from_bytes (get_doc_string_buffer + offset, nchars, to - (get_doc_string_buffer + offset)); } }
static void report_error_1 (int fd, const char *msg, int a1, int a2) { emacs_close (fd); error (msg, a1, a2); }
int tgetent (char *bp, const char *name) { register char *termcap_name; register int fd; struct termcap_buffer buf; register char *bp1; char *tc_search_point; char *term; ptrdiff_t malloc_size = 0; int c; char *tcenv = NULL; /* TERMCAP value, if it contains :tc=. */ char *indirect = NULL; /* Terminal type in :tc= in TERMCAP value. */ bool filep; #ifdef INTERNAL_TERMINAL /* For the internal terminal we don't want to read any termcap file, so fake it. */ if (!strcmp (name, "internal")) { term = INTERNAL_TERMINAL; if (!bp) { malloc_size = 1 + strlen (term); bp = xmalloc (malloc_size); } strcpy (bp, term); goto ret; } #endif /* INTERNAL_TERMINAL */ /* For compatibility with programs like `less' that want to put data in the termcap buffer themselves as a fallback. */ if (bp) term_entry = bp; termcap_name = getenv ("TERMCAP"); if (termcap_name && *termcap_name == '\0') termcap_name = NULL; #if defined (MSDOS) && !defined (TEST) if (termcap_name && (*termcap_name == '\\' || *termcap_name == '/' || termcap_name[1] == ':')) dostounix_filename (termcap_name); #endif filep = termcap_name && valid_filename_p (termcap_name); /* If termcap_name is non-null and starts with / (in the un*x case, that is), it is a file name to use instead of /etc/termcap. If it is non-null and does not start with /, it is the entry itself, but only if the name the caller requested matches the TERM variable. */ if (termcap_name && !filep && !strcmp (name, getenv ("TERM"))) { indirect = tgetst1 (find_capability (termcap_name, "tc"), 0); if (!indirect) { if (!bp) bp = termcap_name; else strcpy (bp, termcap_name); goto ret; } else { /* It has tc=. Need to read /etc/termcap. */ tcenv = termcap_name; termcap_name = NULL; } } if (!termcap_name || !filep) termcap_name = TERMCAP_FILE; /* Here we know we must search a file and termcap_name has its name. */ fd = emacs_open (termcap_name, O_RDONLY | O_TEXT, 0); if (fd < 0) return -1; buf.size = BUFSIZE; /* Add 1 to size to ensure room for terminating null. */ buf.beg = xmalloc (buf.size + 1); term = indirect ? indirect : (char *)name; if (!bp) { malloc_size = indirect ? strlen (tcenv) + 1 : buf.size; bp = xmalloc (malloc_size); } tc_search_point = bp1 = bp; if (indirect) /* Copy the data from the environment variable. */ { strcpy (bp, tcenv); bp1 += strlen (tcenv); } while (term) { /* Scan the file, reading it via buf, till find start of main entry. */ if (scan_file (term, fd, &buf) == 0) { emacs_close (fd); xfree (buf.beg); if (malloc_size) xfree (bp); return 0; } /* Free old `term' if appropriate. */ if (term != name) xfree (term); /* If BP is malloc'd by us, make sure it is big enough. */ if (malloc_size) { ptrdiff_t offset1 = bp1 - bp, offset2 = tc_search_point - bp; malloc_size = offset1 + buf.size; bp = termcap_name = xrealloc (bp, malloc_size); bp1 = termcap_name + offset1; tc_search_point = termcap_name + offset2; } /* Copy the line of the entry from buf into bp. */ termcap_name = buf.ptr; while ((*bp1++ = c = *termcap_name++) && c != '\n') /* Drop out any \ newline sequence. */ if (c == '\\' && *termcap_name == '\n') { bp1--; termcap_name++; } *bp1 = '\0'; /* Does this entry refer to another terminal type's entry? If something is found, copy it into heap and null-terminate it. */ tc_search_point = find_capability (tc_search_point, "tc"); term = tgetst1 (tc_search_point, 0); } emacs_close (fd); xfree (buf.beg); if (malloc_size) bp = xrealloc (bp, bp1 - bp + 1); ret: term_entry = bp; return 1; }