/Users/mourrain/Devel/mmx/basix/src/system.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : system.cpp
* DESCRIPTION: Operating system interface
* COPYRIGHT  : (C) 2000  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#define USE_STANDARD_NEW_DELETE
#include <basix/system.hpp>
#include <basix/vector_sort.hpp>
#include <stdlib.h>
#include <math.h>
#include <dirent.h>
#include <unistd.h>

#if defined (BASIX_HAVE_SYS_TYPES_H) && defined (BASIX_HAVE_SYS_STAT_H)
#include <sys/types.h>
#include <sys/stat.h>
#endif

namespace mmx {

bool var_load (const string& file_name, string& s);
bool var_load (const string& file_path, const string& file_name, string& s);
bool var_mkdir (const string& name);

/******************************************************************************
* System commands
******************************************************************************/

string
get_env (const string& var) {
  char* _var= as_charp (var);
  char* _ret= getenv (_var);
  free_charp (_var);
  if (_ret == NULL) return "";
  string ret (_ret);
  return ret;
  // do not delete _ret !
}

// int
// set_env (const string& var, const string& value) {
//   char* _var= as_charp (var);
//   char* _value= as_charp (value);
//   int ret= setenv (_var, _value, 1);
//   free_charp (_var);
//   free_charp (_value);
//   return ret;
// }

int
system (const string& s) {
  //mmout << "Execute] " << s << "\n";
  char* _s= as_charp (s);
  int r= ::system (_s);
  free_charp (_s);
  return r;
}

void
init_system () {
  string path = user_dir ();
  if (!file_exists (path)) {
    printf ("This is your first use of Mathemagix.\n");
    printf ("I am creating a .mathemagix directory in your home directory\n");
    var_mkdir (path);
  }
  var_mkdir (path * "/etc");
  var_mkdir (path * "/lib");
  var_mkdir (path * "/var");
  var_mkdir (path * "/mmx");
  var_mkdir (path * "/tmp");
}

struct system_instance {
  system_instance () {
    init_system (); }
};

system_instance system_inst;

string
user_dir () {
  string dir= get_env ("MMX_USER_DIR");
  if (dir == "") {
    string home = get_env ("HOME");
    ASSERT (home != "", "Can not determine user's directory.\n Please set $MMX_USER_DIR or $HOME.\n");
    dir= home * "/.mathemagix";
  }
  return dir;
}
  
string
prefix_dir () {
  string dir= get_env ("MMX_PREFIX_DIR");
  if (dir == "") dir= string (BASIX_PREFIX);
  if (!file_exists (dir)) dir= eval_system ("basix-config --prefix");
  return dir;
}

string
sysconf_dir () {
  string dir= get_env ("MMX_SYSCONF_DIR");
  if (dir == "") dir= prefix_dir () * "/etc";
  return dir;
}

string
load_path () {
  string path= get_env ("MMX_LOAD_PATH");
  if (path != "" && path[0] != ':') path= ":" * path;
  path= ".:" * user_dir () * "/mmx:" * prefix_dir () * "/share:"
             * prefix_dir () * "/share/mmx" * path;
  return path;
}

string
eval_system (const string& s) {
  init_system ();
  string temp= user_dir () * "/tmp/eval_system";
  system (s * " > " * temp);
  string r;
  bool flag= var_load (temp, r);
  system ("rm -rf " * temp);
  if (flag) return "";
  while ((N(r)>0) && (r[N(r)-1] == '\n')) r= r (0, N(r)-1);
  return r;
}

/******************************************************************************
* Routines for file names
******************************************************************************/

string
decode_name (const string& name) {
  if (name == "~") return get_env ("HOME");
  if (starts (name, "~/")) return get_env ("HOME") * "/" * name (2, N(name));
  if (starts (name, "$")) {
    nat i;
    for (i=0; i<N(name); i++)
      if (name[i] == '/') break;
    string r= get_env (name (1, i));
    if (i == N(name)) return r;
    return r * "/" * name (i+1, N(name));
  }
  return name;
}

bool
file_exists (const string& name) {
  string name_s= decode_name (name);
  char* temp= as_charp (name_s);
  FILE* f= fopen (temp, "r");
  free_charp (temp);
  if (f == NULL) return false;
  fclose (f);
  return true;
}

string
canonical_name (const string& name) {
  for (int i= N(name)-1; i>=0; i--)
    if (name[i] == '/') {
      nat j=i;
      while (j>0 && name[j-1] == '/') j--;
      string pre = canonical_name (name (0, j));
      string post= name (i+1, N(name));
      if (pre == "") return "/" * post;
      else if (pre == ".") return post;
      else if (post == ".") return pre;
      else if (ends (pre, "..") && post == "..") return pre * "/" * post;
      else if (post == "..") return get_directory (pre);
      else return pre * "/" * post;
    }
  return name;
}

string
path_name (const string& file_path, const string& file_name) {
  //mmout << "path_name " << file_path << ", " << file_name << "\n";
  if (N (file_name) > 0 && file_name[0] == '/') {
    if (file_exists (file_name)) return canonical_name (file_name);
    else return "";
  }
  else {
    nat i, n= N(file_path), start= 0;
    for (i=0; i<=n; i++)
      if ((i==n) || (file_path[i] == ':')) {
        string ss= file_path (start, i);
        if ((N(ss) > 0) && (ss[0] == '$')) {
          init_system ();
          if (ss == "$MMX_LOAD_PATH") ss= load_path ();
          else ss= get_env (ss (1, N(ss)));
          string r= path_name (ss, file_name);
          if (r != "") return r;
        }
        else {
          if (ss == "" || ss == ".") ss= get_env ("PWD");
          if (ss[N(ss)-1] != '/') ss= ss * "/";
          if (file_exists (ss * file_name))
            return canonical_name (ss * file_name);
        }
        start= i+1;
      }
    return "";
  }
}

bool
file_is_script (const string& file_name) {
  char* _file_name= as_charp (file_name);
  FILE* f= fopen (_file_name, "r");
  free_charp (_file_name);
  if (f == NULL) return false;
  char c;
  string s= string ("");
  while ((c = fgetc (f)) != EOF && c != '\n') s << c;
  fclose (f);
  return starts (s, "#!/usr/bin/env mmx-light");

  /*
  port f= input_file_port (file_name);
  if (error_flag (f)) return false;
  char c;
  string s= "";
  while (can_read (f) > 0) {
    f >> c;
    if (c == '\n') break;
    s << c;
  }
  return starts (s, "#!/usr/bin/env mmx-light");
  */
}

string
get_directory (const string& name) {
  for (int i= N(name)-1; i>=0; i--)
    if (name[i]=='/')
      return name (0, i);
  return ".";
}

string
strip_directory (const string& name) {
  for (int i= N(name)-1; i>=0; i--)
    if (name[i]=='/')
      return name (i+1, N(name));
  return name;
}

string
strip_extension (const string& name) {
  for (int i= N(name)-1; i>=0; i--)
    if (name[i]=='.')
      return name (0, i);
    else if (name[i]=='/')
      return name;
  return name;
}

string
get_extension (const string& name) {
  for (int i= N(name)-1; i>=0; i--)
    if (name[i]=='.')
      return name (i+1, N(name));
    else if (name[i]=='/')
      return "";
  return "";
}

string
relative_name (const string& base, const string& name) {
  string file_name= name;
  if (base != "" && file_name != "" && file_name[0] != '/') {
    int i;
    for (i= N(base)-1; i>=0; i--)
      if (base[i] == '/') break;
    file_name= base (0, i+1) * file_name;
  }
  return canonical_name (file_name);
}

string
resolve_name (const string& base, const string& name) {
  //mmout << "Resolve " << base << ", " << name << "\n";
  string r= relative_name (base, name);
  if (file_exists (r)) return r;
  if (get_directory (name) != ".") {
    r= relative_name (canonical_name (base * "/.."), name);
    if (file_exists (r)) return r;
  }
  r= path_name ("$MMX_LOAD_PATH", name);
  if (r != "") return r;
  nat i;
  for (i=0; i<N(name); i++)
    if (name[i] == '/') break;
  if (i == N(name)) return "";
  string d= name (0, i);
  string f= name (i+1, N(name));
  r= path_name ("$MMX_LOAD_PATH", d * "/mmx/" * f);
  if (r != "") return r;
  r= path_name ("$MMX_LOAD_PATH", d * "/glue/" * f);
  if (r != "") return r;
  return "";
}

#ifdef BASIX_HAVE_SYS_STAT_H

static bool
get_attributes (const string& name, struct stat* buf) {
  string name_s= decode_name (name);
  bool flag;
  char* temp= as_charp (name_s);
  flag= stat (temp, buf);
  free_charp (temp);
  return flag;
}

bool
file_test (const string& name, const string& filter) {
  if (filter == "") return true;
  struct stat buf;
  if (get_attributes (name, &buf)) return false;
  int i, n= N (filter);
  for (i=0; i<n; i++)
    switch (filter [i]) {
      // FIXME: should check user id and group id for r, w and x
    case 'f':
      if (!S_ISREG (buf.st_mode)) return false;
      break;
    case 'd':
      if (!S_ISDIR (buf.st_mode)) return false;
      break;
    case 'r':
#ifndef __MINGW32__
      if ((buf.st_mode & (S_IRUSR | S_IRGRP | S_IROTH)) == 0) return false;
#else
      if ((buf.st_mode & 292) == 0) return false;
#endif
      break;
    case 'w':
#ifndef __MINGW32__
      if ((buf.st_mode & (S_IWUSR | S_IWGRP | S_IWOTH)) == 0) return false;
#else
      if ((buf.st_mode & 146) == 0) return false;
#endif
      break;
    case 'x':
#ifdef OS_WIN32
      if (suffix(name) == "bat") break;
#endif
#ifndef __MINGW32__
      if ((buf.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) == 0) return false;
#else
      if ((buf.st_mode & 73) == 0) return false;
#endif
      break;
    }
  return true;
}

double
file_last_modified (const string& name) {
  struct stat u_stat;
  ASSERT (!get_attributes (name, &u_stat), "could not stat file");
  return (double) u_stat.st_mtime;
}

#else // !BASIX_HAVE_SYS_STAT_H

static bool
get_attributes (const string& name, struct stat* buf) {
  (void) name; (void) buf;
  return 1;
}

bool
file_test (const string& name, const string& filter) {
  (void) name; (void) buf;
}

double
file_last_modified (const string& name) {
  ERROR ("could not get file's last modification time");
}

#endif // BASIX_HAVE_SYS_STAT_H

string
follow_link (const string& name, const bool& recurse) {
  char buf[1024];
  string name_s= decode_name (name);
  char* temp= as_charp (name_s);
  int n= readlink (temp, buf, 1024);
  free_charp (temp);
  if (n >= 0 && n < 1024) {
    string r (buf, n);
    if (recurse) return follow_link (r, true);
    else return r;
  }
  else {
    if (recurse) return name;
    else return "";
  }
}

bool file_is_file (const string& name) { return file_test (name, "f"); }
bool file_is_directory (const string& name) { return file_test (name, "d"); }

/******************************************************************************
* Loading and saving
******************************************************************************/

bool
var_load (const string& file_name, string& s) {
  port f= input_file_port (file_name);
  if (error_flag (f)) return true;
  char c;
  while (can_read (f) > 0) {
    f >> c;
    s << c;
  }
  return false;
}

bool
load (const string& orig_file_name, string& s) {
  return var_load (decode_name (orig_file_name), s);
}

bool
var_load (const string& file_path, const string& file_name, string& s) {
  if ((N(file_name) > 0) && (file_name[0] == '/'))
    return var_load (file_name, s);
  nat i, n= N(file_path), start= 0;
  for (i=0; i<=n; i++)
    if ((i==n) || (file_path[i] == ':')) {
      string ss= file_path (start, i);
      if ((N(ss) > 0) && (ss[0] == '$')) {
        init_system ();
        if (ss == "$MMX_LOAD_PATH") ss= load_path ();
        else ss= get_env (ss (1, N(ss)));
        if (!var_load (ss, file_name, s)) return false;
      }
      else {
        if (ss == "") ss= ".";
        if (ss[N(ss)-1] != '/') ss= ss * "/";
        if (!var_load (ss * file_name, s)) return false;
      }
      start= i+1;
    }
  return true;
}

bool
load (const string& file_path, const string& file_name, string& s) {
  return var_load (file_path, decode_name (file_name), s);
}

bool
save (const string& orig_file_name, const string& s) {
  string file_name= decode_name (orig_file_name);
  port f= output_file_port (file_name);
  if (error_flag (f)) return true;
  f << s;
  return false;
}

bool
load_directory (const string& orig_name, vector<string>& dir) {
  string name= decode_name (orig_name);
  DIR* dp;
  char* temp= as_charp (name);
  dp= opendir (temp);
  free_charp (temp);
  dir= vector<string> ();
  if (dp == NULL) return true;

  struct dirent* ep;
  while (true) {
    ep= readdir (dp);
    if (ep == NULL) break;
    dir << string (ep->d_name);
  }
  (void) closedir (dp);
  sort (dir);
  return false;
}

/******************************************************************************
* Commands on files
******************************************************************************/

bool
var_mkdir (const string& name) {
#if defined (BASIX_HAVE_SYS_TYPES_H) && defined (BASIX_HAVE_SYS_STAT_H)
  if (file_exists (name)) return false;
  char* _name= as_charp (name);
#if defined(__MINGW__) || defined(__MINGW32__)
  int r= ::mkdir (_name);
  ::chmod (_name, 744);
#else
  int r= ::mkdir (_name, S_IRWXU + S_IRGRP + S_IROTH);
#endif
  free_charp (_name);
  return r != 0;
#else  
  return system ("mkdir -m 744 -p " * orig_name) != 0;
#endif
}

bool
mkdir (const string& name) {
  return var_mkdir (decode_name (name));
}

} // namespace mmx