Mercurial > hg > octave-terminal
changeset 1765:a51354c34bea
[project @ 1996-01-23 03:33:34 by jwe]
Initial revision
author | jwe |
---|---|
date | Tue, 23 Jan 1996 03:33:34 +0000 |
parents | 4688b760ccb2 |
children | e8e76be43e79 |
files | liboctave/file-ops.cc liboctave/file-ops.h |
diffstat | 2 files changed, 407 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
new file mode 100644 --- /dev/null +++ b/liboctave/file-ops.cc @@ -0,0 +1,202 @@ +// file-ops.cc -*- C++ -*- +/* + +Copyright (C) 1996 John W. Eaton + +This file is part of Octave. + +Octave 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 Software Foundation; either version 2, or (at your option) any +later version. + +Octave is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with Octave; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +*/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <cerrno> +#include <cstring> + +#ifdef HAVE_UNISTD_H +#include <sys/types.h> +#include <unistd.h> +#endif + +#include "file-ops.h" +#include "statdefs.h" + +// XXX FIXME XXX -- the is_* and mode_as_string functions are only valid +// for initialized objects. If called for an object that is not +// initialized, they should throw an exception. + +bool +file_stat::is_blk (void) const +{ + return S_ISBLK (fs_mode); +} + +bool +file_stat::is_chr (void) const +{ + return S_ISCHR (fs_mode); +} + +bool +file_stat::is_dir (void) const +{ + return S_ISDIR (fs_mode); +} + +bool +file_stat::is_fifo (void) const +{ + return S_ISFIFO (fs_mode); +} + +bool +file_stat::is_lnk (void) const +{ + return S_ISLNK (fs_mode); +} + +bool +file_stat::is_reg (void) const +{ + return S_ISREG (fs_mode); +} + +bool +file_stat::is_sock (void) const +{ + return S_ISSOCK (fs_mode); +} + +extern "C" void mode_string (); + +string +file_stat::mode_as_string (void) const +{ + char buf[11]; + + mode_string (fs_mode, buf); + + buf[10] = '\0'; + + return buf; +} + +// Private stuff: + +void +file_stat::update_internal (bool force) +{ + if (! initialized || force) + { + initialized = false; + fail = false; + + const char *cname = file_name.c_str (); + + struct stat buf; + + int status = follow_links + ? stat (cname, &buf) : lstat (cname, &buf); + + if (status < 0) + { + fail = true; + errmsg = strerror (errno); + } + else + { + fs_mode = buf.st_mode; + fs_ino = buf.st_ino; + fs_dev = buf.st_dev; + fs_nlink = buf.st_nlink; + fs_uid = buf.st_uid; + fs_gid = buf.st_gid; + fs_size = buf.st_size; + fs_atime = buf.st_atime; + fs_mtime = buf.st_mtime; + fs_ctime = buf.st_ctime; + +#if defined (HAVE_ST_RDEV) + fs_rdev = buf.st_rdev; +#endif + +#if defined (HAVE_ST_BLKSIZE) + fs_blksize = buf.st_blksize; +#endif + +#if defined (HAVE_ST_BLOCKS) + fs_blocks = buf.st_blocks; +#endif + } + + initialized = true; + } +} + +// Functions for octave. + +// Has FILE been modified since TIME? Returns 1 for yes, 0 for no, +// and -1 for any error. +int +is_newer (const string& file, time_t time) +{ + file_stat fs (file); + + return fs ? fs.is_newer (time) : -1; +} + +int +xmkdir (const string& name, mode_t mode) +{ + return mkdir (name.c_str (), mode); +} + +int +xrmdir (const string& name) +{ + return rmdir (name.c_str ()); +} + +int +xrename (const string& from, const string& to) +{ + return rename (from.c_str (), to.c_str ()); +} + +int +xmkfifo (const string& name, mode_t mode) +{ + return mkfifo (name.c_str (), mode); +} + +int +xumask (mode_t mode) +{ +#if defined (HAVE_UMASK) + return umask (mode); +#else + return 0; +#endif +} + +/* +;;; Local Variables: *** +;;; mode: C++ *** +;;; page-delimiter: "^/\\*" *** +;;; End: *** +*/
new file mode 100644 --- /dev/null +++ b/liboctave/file-ops.h @@ -0,0 +1,205 @@ +// file-ops.h -*- C++ -*- +/* + +Copyright (C) 1996 John W. Eaton + +This file is part of Octave. + +Octave 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 Software Foundation; either version 2, or (at your option) any +later version. + +Octave is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with Octave; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +*/ + +#if !defined (octave_file_ops_h) +#define octave_file_ops_h 1 + +#include <string> + +class +file_stat +{ +public: + + file_stat (const string& n = string (), bool fl = 1) + : file_name (n), follow_links (fl), initialized (false) + { + if (! file_name.empty ()) + update_internal (); + } + + file_stat (const file_stat& f) + : file_name (f.file_name), follow_links (f.follow_links), + initialized (f.initialized) { } + + file_stat& operator = (const file_stat& f) + { + file_name = f.file_name; + follow_links = f.follow_links; + initialized = f.initialized; + + return *this; + } + + ~file_stat (void) { } + + void get_stats (bool force = false) + { + if (! initialized || force) + update_internal (force); + } + + void get_stats (const string& n, bool force = false) + { + if (n != file_name || ! initialized || force) + { + initialized = false; + + file_name = n; + + update_internal (force); + } + } + + // File status and info. These should only be called for objects + // that are already properly initialized. + + bool is_blk (void) const; + bool is_chr (void) const; + bool is_dir (void) const; + bool is_fifo (void) const; + bool is_lnk (void) const; + bool is_reg (void) const; + bool is_sock (void) const; + + ino_t ino (void) const { return fs_ino; } + dev_t dev (void) const { return fs_dev; } + + nlink_t nlink (void) const { return fs_nlink; } + + uid_t uid (void) const { return fs_uid; } + gid_t gid (void) const { return fs_gid; } + + off_t size (void) const { return fs_size; } + + time_t atime (void) const { return fs_atime; } + time_t mtime (void) const { return fs_mtime; } + time_t ctime (void) const { return fs_ctime; } + +#if defined (HAVE_ST_RDEV) + dev_t rdev (void) const { return fs_rdev; } +#endif + +#if defined (HAVE_ST_BLKSIZE) + long blksize (void) const { return fs_blksize; } +#endif + +#if defined (HAVE_ST_BLOCKS) + long blocks (void) const { return fs_blocks; } +#endif + + string mode_as_string (void) const; + + bool ok (void) const { return initialized && ! fail; } + + operator void* () const { return ok () ? (void *) -1 : (void *) 0; } + + bool exists (void) const { return ok (); } + + string error (void) const { return ok () ? string () : errmsg; } + + // Has the file referenced by this object been modified since TIME? + bool is_newer (time_t time) const { return fs_mtime > time; } + +private: + + // Name of the file. + string file_name; + + // TRUE means follow symbolic links to the ultimate file (stat). + // FALSE means get information about the link itself (lstat). + bool follow_links; + + // TRUE means we have already called stat. + bool initialized; + + // TRUE means the stat for this file failed. + bool fail; + + // If a failure occurs, this contains the system error text. + string errmsg; + + // file type and permissions + mode_t fs_mode; + + // serial number + ino_t fs_ino; + + // device number + dev_t fs_dev; + + // number of links + nlink_t fs_nlink; + + // user ID of owner + uid_t fs_uid; + + // group ID of owner + gid_t fs_gid; + + // size in bytes, for regular files + off_t fs_size; + + // time of last access + time_t fs_atime; + + // time of last modification + time_t fs_mtime; + + // time of last file status change + time_t fs_ctime; + +#if defined (HAVE_ST_RDEV) + // device number for special files + dev_t fs_rdev; +#endif + +#if defined (HAVE_ST_BLKSIZE) + // best I/O block size + long fs_blksize; +#endif + +#if defined (HAVE_ST_BLOCKS) + // number of 512-byte blocks allocated + long fs_blocks; +#endif + + void update_internal (bool force = false); +}; + +extern int is_newer (const string&, time_t); + +extern int xmkdir (const string&, mode_t); +extern int xrmdir (const string&); +extern int xrename (const string&, const string&); +extern int xmkfifo (const string&, mode_t); +extern int xumask (mode_t); + +#endif + +/* +;;; Local Variables: *** +;;; mode: C++ *** +;;; page-delimiter: "^/\\*" *** +;;; End: *** +*/