"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "src/file.c" between
most-5.1.0.tar.gz and most-5.2.0.tar.gz

About: most is a textfile paging program (supports multiple windows and can scroll left and right).

file.c  (most-5.1.0):file.c  (most-5.2.0)
/* /*
This file is part of MOST. This file is part of MOST.
Copyright (c) 1991, 1999, 2002, 2005-2018, 2019 John E. Davis Copyright (c) 1991, 1999, 2002, 2005-2021, 2022 John E. Davis
This program is free software; you can redistribute it and/or modify it This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the Free under the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2 of the License, or (at your option) Software Foundation; either version 2 of the License, or (at your option)
any later version. any later version.
This program is distributed in the hope that it will be useful, but WITHOUT This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details. more details.
skipping to change at line 77 skipping to change at line 77
char *efile; char *efile;
if (NULL == (efile = most_escape_filename (file, '"'))) if (NULL == (efile = most_escape_filename (file, '"')))
return -1; return -1;
(void) _pSLsnprintf (buf, sizeof_buf, cmd, efile); (void) _pSLsnprintf (buf, sizeof_buf, cmd, efile);
SLfree (efile); SLfree (efile);
return 0; return 0;
} }
static int open_compressed_file(char *file, int mode, int *size) static int open_compressed_file(char *file, int mode, size_t *sizep)
{ {
int fd; int fd;
char buf[4], cmdbuf[2*MAX_PATHLEN]; char buf[4], cmdbuf[2*MAX_PATHLEN];
struct stat st; struct stat st;
# ifdef O_BINARY # ifdef O_BINARY
mode |= O_BINARY; mode |= O_BINARY;
# endif # endif
# ifdef IBMPC_SYSTEM # ifdef IBMPC_SYSTEM
Most_Z_Opt = 1; Most_Z_Opt = 1;
# endif # endif
if (Most_Z_Opt) if (Most_Z_Opt)
{ {
if (stat(file, &st)) return(-1); if (stat(file, &st)) return(-1);
*size = st.st_size; *sizep = st.st_size;
return (open(file,mode)); return (open(file,mode));
} }
fd = open(file, O_RDONLY); fd = open(file, O_RDONLY);
if (fd < 0) return fd; if (fd < 0) return fd;
if (4 == read(fd, buf, 4)) if (4 == read(fd, buf, 4))
{ {
char *cmd = NULL; char *cmd = NULL;
skipping to change at line 129 skipping to change at line 129
FILE *fp; FILE *fp;
close (fd); close (fd);
most_flush_message ("Uncompressing file..."); most_flush_message ("Uncompressing file...");
if (-1 == create_gunzip_cmd (cmd, file, cmdbuf, sizeof(cmdbuf))) if (-1 == create_gunzip_cmd (cmd, file, cmdbuf, sizeof(cmdbuf)))
return -1; return -1;
fp = popen (cmdbuf, "r"); /* GLIBC doe not support "rb" */ fp = popen (cmdbuf, "r"); /* GLIBC doe not support "rb" */
if (fp == NULL) if (fp == NULL)
return -1; return -1;
*size = 0; *sizep = 0;
fd = fileno (fp); fd = fileno (fp);
Most_Buf->fp = fp; Most_Buf->fp = fp;
/* pclose (fp); */ /* pclose (fp); */
return fd; return fd;
} }
} }
close (fd); close (fd);
if (stat(file, &st)) return(-1); if (stat(file, &st)) return(-1);
*size = st.st_size; *sizep = st.st_size;
return (open(file,mode)); return (open(file,mode));
} }
#endif /* VMS */ #endif /* VMS */
#if MOST_HAS_MMAP #if MOST_HAS_MMAP
#ifdef HAVE_SYS_MMAN_H #ifdef HAVE_SYS_MMAN_H
# include <sys/mman.h> # include <sys/mman.h>
#endif #endif
#ifndef MAP_FAILED #ifndef MAP_FAILED
skipping to change at line 171 skipping to change at line 171
if (-1 == fstat (fd, &st)) if (-1 == fstat (fd, &st))
return -1; return -1;
addr = (unsigned char *)mmap (NULL,st.st_size,PROT_READ,MAP_SHARED,fd,0); addr = (unsigned char *)mmap (NULL,st.st_size,PROT_READ,MAP_SHARED,fd,0);
if (addr == (unsigned char *)MAP_FAILED) if (addr == (unsigned char *)MAP_FAILED)
return -1; return -1;
Most_Buf->fd = fd; Most_Buf->fd = fd;
Most_Eob = Most_Beg = Most_Buf->end = Most_Buf->beg = addr; Most_Eob = Most_Beg = Most_Buf->end = Most_Buf->beg = addr;
Most_Buf->size = 0; Most_Buf->bufsize = 0;
Most_Buf->mmap_size = st.st_size; Most_Buf->mmap_file_size = st.st_size;
Most_Buf->is_mmaped = 1; Most_Buf->is_mmaped = 1;
return 0; return 0;
} }
static int unmmap_buffer (Most_Buffer_Type *b) static int unmmap_buffer (Most_Buffer_Type *b)
{ {
if (b->is_mmaped == 0) if (b->is_mmaped == 0)
return 0; return 0;
if (b->beg != NULL) if (b->beg != NULL)
munmap ((char *)b->beg, b->size); munmap ((char *)b->beg, b->bufsize);
b->end = b->beg = NULL; b->end = b->beg = NULL;
if (b == Most_Buf) if (b == Most_Buf)
{ {
Most_Beg = Most_Eob = NULL; Most_Beg = Most_Eob = NULL;
Most_C_Line = 0; Most_C_Line = 0;
Most_Num_Lines = Most_C_Line = 0; Most_Num_Lines = Most_C_Line = 0;
} }
return 0; return 0;
} }
skipping to change at line 206 skipping to change at line 206
static int resync_mmap (void) static int resync_mmap (void)
{ {
struct stat st; struct stat st;
int line = Most_C_Line; int line = Most_C_Line;
if (Most_Buf->fd == -1) if (Most_Buf->fd == -1)
return 0; return 0;
if (-1 == fstat (Most_Buf->fd, &st)) if (-1 == fstat (Most_Buf->fd, &st))
return -1; return -1;
if ((unsigned int) st.st_size == Most_Buf->mmap_size) if (st.st_size == Most_Buf->mmap_file_size)
return 0; return 0;
(void) unmmap_buffer (Most_Buf); (void) unmmap_buffer (Most_Buf);
if (-1 == try_mmap_buffer (Most_Buf->fd)) if (-1 == try_mmap_buffer (Most_Buf->fd))
return -1; return -1;
most_goto_line (line); most_goto_line (line);
return 0; return 0;
} }
skipping to change at line 240 skipping to change at line 240
unmmap_buffer (b); unmmap_buffer (b);
#endif #endif
if (b->beg != NULL) if (b->beg != NULL)
SLFREE(b->beg); SLFREE(b->beg);
b->beg = NULL; b->beg = NULL;
b->fd = -1; b->fd = -1;
return 0; return 0;
} }
/* If file[0] == 0, the file represents stdin */ /* If file is NULL, the file represents stdin */
static int insert_file(char *file) static int insert_file(char *file)
{ {
int size = 0, fd; size_t size = 0;
/* int mode; */ /* int mode; */
#ifdef VMS #ifdef VMS
struct stat st; struct stat st;
unsigned recsz = 512; unsigned recsz = 512;
/* extern int stat(char *, struct stat *); */ /* extern int stat(char *, struct stat *); */
#endif #endif
int fd;
if (file[0] == '\0') /* assume stdin */ if (file == NULL) /* assume stdin */
{ {
fd = 0; fd = fileno (stdin);
strcpy (Most_Buf->file, "*stdin*"); strcpy (Most_Buf->file, "*stdin*");
} }
else else
{ {
#ifdef VMS #ifdef VMS
if (stat(file, &st)) return(-1); if (stat(file, &st)) return(-1);
/* mode = st.st_mode & S_IFMT; */ /* mode = st.st_mode & S_IFMT; */
size = st.st_size; size = st.st_size;
recsz = st.st_fab_mrs; recsz = st.st_fab_mrs;
if (recsz <= 255) recsz = 255; if (recsz <= 255) recsz = 255;
skipping to change at line 287 skipping to change at line 288
if (fd < 0) return(-1); if (fd < 0) return(-1);
if (!fd || (size <= 0)) size = 0x7FFF; if (!fd || (size <= 0)) size = 0x7FFF;
#ifdef VMS #ifdef VMS
Most_Buf->rec = recsz; Most_Buf->rec = recsz;
#endif #endif
Most_Buf->fd = fd; Most_Buf->fd = fd;
/* This will fail on really large files. */ /* This will fail on really large files. */
Most_Eob = Most_Beg = Most_Buf->beg = (unsigned char *) MOSTMALLOC(size); Most_Eob = Most_Beg = Most_Buf->beg = (unsigned char *) MOSTMALLOC(size);
Most_Buf->size = size; Most_Buf->bufsize = size;
return most_read_file_dsc (1, 1); return most_read_file_dsc (1, 1);
} }
static void update_buffer_windows (Most_Buffer_Type *b) static void update_buffer_windows (Most_Buffer_Type *b)
{ {
Most_Window_Type *w; Most_Window_Type *w;
if (NULL == (w = Most_Win)) if (NULL == (w = Most_Win))
return; return;
skipping to change at line 347 skipping to change at line 348
Most_W_Opt = 1; Most_W_Opt = 1;
} }
} }
} }
static int First_Time_Hack = 0; /* true if reading file for first time */ static int First_Time_Hack = 0; /* true if reading file for first time */
#if MOST_HAS_MMAP #if MOST_HAS_MMAP
static int read_mmap_file_dsc (int many, int count_lines) static int read_mmap_file_dsc (int many, int count_lines)
{ {
unsigned int size; MOST_INT size;
size = Most_Buf->size; size = Most_Buf->bufsize;
if (many == -1) if (many == -1)
{ {
if (-1 == resync_mmap ()) if (-1 == resync_mmap ())
return -1; return -1;
} }
if (size == Most_Buf->mmap_size) if (size == Most_Buf->mmap_file_size)
return 0; return 0;
if (many < 0) if (many < 0)
size = Most_Buf->mmap_size; size = Most_Buf->mmap_file_size;
else else
{ {
size += many * 0xFFFF; size += many * (size_t) 0xFFFF;
if (size > Most_Buf->mmap_size) if (size > Most_Buf->mmap_file_size)
size = Most_Buf->mmap_size; size = Most_Buf->mmap_file_size;
} }
Most_Eob = Most_Buf->end = Most_Buf->beg + size; Most_Eob = Most_Buf->end = Most_Buf->beg + size;
Most_Buf->size = size; Most_Buf->bufsize = size;
most_flush_message ("Mapping file..."); most_flush_message ("Mapping file...");
if (First_Time_Hack) if (First_Time_Hack)
examine_file_contents (); examine_file_contents ();
if (count_lines) if (count_lines)
Most_Num_Lines = most_count_lines (Most_Beg, Most_Eob); Most_Num_Lines = most_count_lines (Most_Beg, Most_Eob);
most_message(Most_Global_Msg, 0); most_message(Most_Global_Msg, 0);
return 1; return 1;
} }
#endif #endif
/* if read something, return non zero (1) */ /* if read something, return non zero (1) */
int most_read_file_dsc (int many, int count_lines) MOST_INT most_read_file_dsc (MOST_INT many, int count_lines)
{ {
int fd = Most_Buf->fd, n = 0, i; MOST_INT dsize, size, n = 0;
int dsize, size, passes = 0; int fd = Most_Buf->fd;
int passes = 0;
unsigned char *pos; unsigned char *pos;
#ifdef VMS #ifdef VMS
int recsz = Most_Buf->rec; int recsz = Most_Buf->rec;
#endif #endif
if (fd < 0) return 0; if (fd < 0) return 0;
#if MOST_HAS_MMAP #if MOST_HAS_MMAP
if (Most_Buf->is_mmaped) if (Most_Buf->is_mmaped)
{ {
skipping to change at line 415 skipping to change at line 417
if (Most_Buf->is_mmaped) if (Most_Buf->is_mmaped)
return -1; return -1;
/* No longer mapped..... */ /* No longer mapped..... */
} }
#endif #endif
dsize = 0x3FFF; dsize = 0x3FFF;
while (many--) while (many--)
{ {
ssize_t i;
passes++; passes++;
most_flush_message ("Reading..."); most_flush_message ("Reading...");
size = (Most_Eob - Most_Beg) + dsize; size = (Most_Eob - Most_Beg) + dsize;
if (Most_Buf->size > size) pos = Most_Beg; if (Most_Buf->bufsize > size) pos = Most_Beg;
else else
{ {
size = Most_Buf->size + 0xFFFF; size = Most_Buf->bufsize + 0xFFFF;
pos = (unsigned char *) MOSTREALLOC(Most_Beg, (unsigned) size); pos = (unsigned char *) MOSTREALLOC(Most_Beg, (unsigned) size);
Most_Buf->size = size; Most_Buf->bufsize = size;
} }
Most_Eob = pos + (unsigned int) (Most_Eob - Most_Beg); Most_Eob = pos + (Most_Eob - Most_Beg);
Most_Beg = pos; Most_Beg = pos;
pos = Most_Eob; pos = Most_Eob;
n = 0; n = 0;
while (1) while (1)
{ {
#ifdef VMS #ifdef VMS
i = read (fd, (char *) pos, recsz); i = read (fd, (char *) pos, recsz);
#else #else
skipping to change at line 497 skipping to change at line 501
update_buffer_windows (Most_Buf); update_buffer_windows (Most_Buf);
most_message("reading...done", 0); most_message("reading...done", 0);
most_put_message(); most_put_message();
most_message(Most_Global_Msg, 0); most_message(Most_Global_Msg, 0);
return n; return n;
} }
/* This routines makes sure line n is read in. */ /* This routines makes sure line n is read in. */
void most_read_to_line(int n) void most_read_to_line(MOST_INT n)
{ {
int dn; MOST_INT dn, nbytes;
long nbytes;
if (Most_Buf->fd == -1) return; if (Most_Buf->fd == -1) return;
n += 2 * SLtt_Screen_Rows; n += 2 * SLtt_Screen_Rows;
dn = n - Most_Num_Lines; dn = n - Most_Num_Lines;
if (dn < 0) return; if (dn < 0) return;
nbytes = 0; nbytes = 0;
if (Most_Num_Lines) if (Most_Num_Lines)
nbytes = dn * ((Most_Eob - Most_Beg) / Most_Num_Lines); nbytes = dn * ((Most_Eob - Most_Beg) / Most_Num_Lines);
skipping to change at line 525 skipping to change at line 528
&& (0 != most_read_file_dsc (nbytes / 0x3FFF, 1)) && (0 != most_read_file_dsc (nbytes / 0x3FFF, 1))
&& (SLKeyBoard_Quit == 0)) && (SLKeyBoard_Quit == 0))
{ {
nbytes = 0; nbytes = 0;
if (Most_Num_Lines) if (Most_Num_Lines)
nbytes = dn * ((Most_Eob - Most_Beg) / Most_Num_Lines); nbytes = dn * ((Most_Eob - Most_Beg) / Most_Num_Lines);
if (nbytes < 0x3FFF) nbytes = 0x3FFF; if (nbytes < 0x3FFF) nbytes = 0x3FFF;
} }
} }
/* file may be NULL, which implies *stdin* */
int most_find_file(char *file) int most_find_file(char *file)
{ {
Most_Buffer_Type *new_buf; Most_Buffer_Type *new_buf;
int n;
char msg[MAX_PATHLEN+20], *msgp; char msg[MAX_PATHLEN+20], *msgp;
int ret = 0; int ret = 0;
new_buf = most_create_buffer(file); new_buf = most_create_buffer(file);
(void) most_switch_to_buffer(new_buf); (void) most_switch_to_buffer(new_buf);
First_Time_Hack = 1; First_Time_Hack = 1;
if (insert_file(file) < 0) if (insert_file(file) < 0)
{ {
size_t n;
if (file == NULL) file = "*stdin*";
sprintf (msg, "%s failed to open.", file); sprintf (msg, "%s failed to open.", file);
n = strlen (msg); n = strlen (msg);
msgp = (char *) MOSTMALLOC((unsigned int) (n + 1)); msgp = (char *) MOSTMALLOC(n + 1);
strcpy (msgp, msg); strcpy (msgp, msg);
Most_Buf->beg = (unsigned char *) msgp; Most_Buf->beg = (unsigned char *) msgp;
Most_Buf->end = Most_Buf->beg + n; Most_Buf->end = Most_Buf->beg + n;
Most_Buf->fd = -1; Most_Buf->fd = -1;
Most_Num_Lines = 1; Most_Num_Lines = 1;
ret = -1; ret = -1;
} }
First_Time_Hack = 0; First_Time_Hack = 0;
Most_Beg = Most_Buf->beg; Most_Beg = Most_Buf->beg;
 End of changes. 33 change blocks. 
34 lines changed or deleted 40 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)