Tanl Linguistic Pipeline

search/ixe/Common/util.cpp

/*
**      IXE
**      Common/util.cpp
** ----------------------------------------------------------------------
**      Copyright (c) 2000  Ideare SpA. All rights reserved.
**      Copyright (c) 2000  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of IXE.
**
**  IXE is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  IXE 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 this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

// Settings
#include "Common/util.h"
#include "io/File.h"

// standard
#include <ctime>                // needed by sys/resource.h
#include <iostream>
#include <stdlib.h> 
#include <dirent.h>             // for DIR, opendir(), readdir()
#ifdef _WIN32
# include <sys/resource.h>      // for RLIMIT_*
# include <WinSock2.h>          // For GlobalMemoryStatus, timeval
#endif

#ifdef __linux__
# include <sys/sysinfo.h>       // sysinfo
#endif

using namespace std;

namespace IXE {

//=============================================================================
//=============================================================================

void mapDir(char const* pathname, FileAction& action,
            bool recurse_subdirectories, bool follow_symbolic_links,
            int verbosity)
{
  io::File file(pathname);
# ifndef IXE_NO_SYMBOLIC_LINKS
  if (file.isLink() && !follow_symbolic_links) {
    if (verbosity > 3)
      std::cout << "  " << pathname << " (skipped: symbolic link)" << std::endl;
    return;
  }
# endif
        
# ifdef __unix__
  if (file.isDirectory()) {
    if (recurse_subdirectories) {
      DIR* dirp = ::opendir(pathname);
      if (dirp == NULL) {
        if (verbosity > 3)
          std::cerr << "  " << pathname << " (skipped: can not open)" << std::endl;
        return;
      }
      std::string const dir_string(pathname);
      struct dirent const* dir_ent;
      while ((dir_ent = readdir(dirp)) != NULL) {
        if (dir_ent->d_name[0] == '.')  // skip dot files
          continue;
        std::string const path(dir_string + PATH_SEPARATOR + dir_ent->d_name);
        mapDir(path.c_str(), action,
               recurse_subdirectories, follow_symbolic_links, verbosity);
      }
      ::closedir(dirp);
    }
  }
# elif defined(_WIN32)
  if (file.isDirectory()) {
      if (recurse_subdirectories) {
        WIN32_FIND_DATA find;
        HANDLE directory;
        
        std::string const dir_string(pathname + std::string("\\*"));

        directory = FindFirstFile(dir_string.c_str(), &find); /* eat .  */
        if (directory == INVALID_HANDLE_VALUE) {
          if (verbosity > 3)
            std::cerr << "  " << pathname << " (skipped: can not open)" << std::endl;
          return;
        }
        if (verbosity > 1)
          std::cerr << pathname << std::endl;

        FindNextFile(directory, &find);           /* eat .. */

        while (FindNextFile(directory, &find)) {
          string const path(string(pathname) + PATH_SEPARATOR + 
                            find.cFileName);
          mapDir(path.c_str(), action,
                 recurse_subdirectories, follow_symbolic_links, verbosity);
        }
      }
    }
# endif // _WIN32
  else
    action(pathname);
}

static int htoi(char const* s)
{
  int c = s[0];
  if (isupper(c))
    c = tolower(c);
  int value = (c >= '0' && c <= '9' ? c - '0' : c - 'a' + 10) * 16;
  c = s[1];
  if (isupper(c))
    c = tolower(c);
  value += c >= '0' && c <= '9' ? c - '0' : c - 'a' + 10;
  return (value);
}

//=============================================================================
//=============================================================================

int url_decode(char* dest, char const* src, int len)
{
  char* cur = dest;
  if (!len)
    len = ::strlen(src) ;

  while (len--) {
    if (*src == '+')
      *cur = ' ';
    else if (*src == '%' && len >= 2 && isxdigit((int)(src[1]))
             && isxdigit((int)(src[2]))) {
#     ifdef CHARSET_EBCDIC
      *cur = os_toebcdic[(char)htoi(src + 1)];
#     else
      *cur = (char)htoi(src + 1);
#     endif
      src += 2;
      len -= 2;
    } else
      *cur = *src;
    src++;
    cur++;
  }
  *cur = '\0';
  return cur - dest;
}

static unsigned char hexchars[] = "0123456789abcdef";

//=============================================================================
//=============================================================================
char* url_encode(char const* s)
{
  int len = ::strlen(s);
  unsigned char* str = (unsigned char *)malloc(3 * len + 1);
  register int x, y;

  for (x = 0, y = 0; len--; x++, y++) {
    unsigned char c = str[y] = (unsigned char)s[x];
    // cant use isalnum(c) since it depends on locale
    if (!(c >= 'a' && c <= 'z') &&
        !(c >= 'A' && c <= 'Z') &&
        !(c >= '0' && c <= '9') &&
        ::strchr("-_.!~*'()", c) == NULL) {
      str[y++] = '%';
      str[y++] = hexchars[(unsigned char)s[x] >> 4];
      str[y] = hexchars[(unsigned char)s[x] & 15];
    }
  }
  str[y] = '\0';
  return (char *)str;
}

int url_encode(char* dst, char const* s)
{
  unsigned char* str = (unsigned char*)dst;
  unsigned char c;

  for (; c = *s; s++) {
    // cant use isalnum(c) since it depends on locale
    if (!(c >= 'a' && c <= 'z') &&
        !(c >= 'A' && c <= 'Z') &&
        !(c >= '0' && c <= '9') &&
        ::strchr("-_.!~*'()", c) == NULL) {
      *str++ = '%';
      *str++ = hexchars[c >> 4];
      *str++ = hexchars[c & 15];
    } else
      *str++ = c;
  }
  *str = '\0';
  return str - (unsigned char*)dst;
}

void reverseURLdomain(char* revDomain, char const* url, Size len)
{
  // Can't use "http://", since "//" is comment
  static char const http[] = "http:/" "/";
  static char const https[] = "https:/" "/";
  char const* start = url;
  if (!::strncasecmp(http, url, 7))
    start += 7;
  else if (!::strncasecmp(https, url, 8))
    start += 8;
  else {
    revDomain[0] = '\0';
    return;
  }
  char const* end = ::strchr(start, '/');
  if (!end)
    end = start + ::strlen(start);
  // strip optional port number (:8080)
  char const* port = ::strchr(start, ':');
  if (port && port < end)
    end = port;
  // handle missing /
  char const* q = ::strchr(start, '?');
  if (q && q < end)
    end = q;
  if ((Size)(end - start) > len)
    start = end - len;
  while (start < end) {
    char const* domain = end;
    while (start < domain && *--domain != '.') ;
    if (start <= domain) {
      if (start == domain &&
          *domain != '.') // not malformed URL
        domain--;
      int len = end - (domain + 1);
      ::strncpy(revDomain, domain + 1, len);
      revDomain += len;
      *revDomain++ = '.';
      end = domain;
    }
    else
      break;
  }
  // Replace last '.'
  revDomain[-1] = '\0';
}

void unreverseURLdomain(char* domain, char const* revDomain)
{
  char const* start = revDomain;
  char const* end = revDomain + ::strlen(revDomain);
  if (start == end) {
    domain[0] = '\0';
        return;
  }
  while (start < end) {
    char const* RevDomain = end;
    while (start < RevDomain && *--RevDomain != '.') ;
    if (start <= RevDomain) {
      if (start == RevDomain &&
          *RevDomain != '.') // not malformed URL
        RevDomain--;
      int len = end - (RevDomain + 1);
      ::strncpy(domain, RevDomain + 1, len);
      domain += len;
      *domain++ = '.';
      end = RevDomain;
    }
    else
      break;
  }
  // Replace last '.'
  domain[-1] = '\0';
}

Size availableMemory() {
# ifdef __linux__
# include <linux/version.h>
# if LINUX_VERSION_CODE > KERNEL_VERSION(2,3,48)
# define MEM_UNIT(info) info.mem_unit
# else
# define MEM_UNIT(info) 1
# endif
  struct sysinfo info;
  sysinfo(&info);
  return (info.totalram * MEM_UNIT(info));
# elif defined(_WIN32)
  MEMORYSTATUS ms;
  GlobalMemoryStatus(&ms);
  return ms.dwAvailPhys;
# else
  return 0;
# endif
}

void cgi_parse(map<char const*, char const*>& keyMap, char* qstart)
{
  // replace ';' with '&'
  char* qend = qstart;
  for (char c = *qstart; (c = *qend); qend++)
    if (c == ';')
      *qend = '&';

  do {
    char* key = qstart;
    char* valstart = ::strchr(qstart, '=');
    valstart = valstart ? valstart : qend;
    char* valend = ::strchr(valstart, '&');
    valend = valend ? valend : qend;
    if (key < valstart && valstart < valend) {
      *valstart = '\0';
      *valend = '\0';
      url_decode(valstart + 1, valstart + 1);
      keyMap[key] = valstart+1;
    }
    qstart = valend + 1;
  } while (qstart < qend);
}

} // namespace IXE

 

Copyright © 2005-2011 G. Attardi. Generated on 3 Mar 2011 by doxygen 1.6.1.