dictionary & csdbg::dictionary::load_file ( const i8 *  path )

virtual

Load words from a dictionary file.

Parameters

[in]

path

the path of the data file

Returns

*this

Exceptions

std::bad_alloc
csdbg::exception

Note

Each non-empty line in the file is translated as a single token. A line with only whitespace characters is considered an empty line. The tokens are trimmed to remove leading and trailing whitespace characters. If the file is empty no tokens are loaded, but the object remains valid

Attention

The file is memory mapped

Definition at line 193 of file dictionary.cpp.

References __D_ASSERT, csdbg::chain< string >::add(), csdbg::util::dbg_info(), csdbg::util::dbg_warn(), csdbg::util::is_readable(), csdbg::util::is_regular(), csdbg::string::length(), likely, m_name, csdbg::string::trim(), and unlikely.

Referenced by dictionary().

{
  __D_ASSERT(path != NULL);
  if ( unlikely(path == NULL) )
    return *this;

  /* Stat the dictionary file path and make some preliminary checks */
  fileinfo_t inf;
  i32 retval = stat(path, &inf);
  if ( unlikely(errno == ENOENT) )
    throw exception("file '%s' does not exist", path);

  else if ( unlikely(retval < 0) )
    throw exception(
      "failed to stat path '%s' (errno %d - %s)",
      path,
      errno,
      strerror(errno)
    );

  else if ( unlikely(!util::is_regular(inf)) )
    throw exception("'%s' is not a regular file", path);

  else if ( unlikely(!util::is_readable(inf)) )
    throw exception("file '%s' is not readable", path);

  i32 sz = inf.st_size;
  if ( unlikely(sz == 0) ) {
    util::dbg_warn("dictionary file '%s' is empty", path);
    return *this;
  }

  /* Open the file */
  i32 fd;
  do {
    fd = open(path, O_RDONLY);
  }
  while ( unlikely(fd < 0 && errno == EINTR) );

  if ( unlikely(fd < 0) )
    throw exception(
      "failed to open file '%s' (errno %d - %s)",
      path,
      errno,
      strerror(errno)
    );

  /* Memory map the file */
  void *mmap_base = mmap(NULL, sz, PROT_READ, MAP_SHARED, fd, 0);
  if ( unlikely(mmap_base == MAP_FAILED) ) {
    close(fd);
    throw exception(
      "failed to memory map file '%s' (errno %d - %s)",
      path,
      errno,
      strerror(errno)
    );
  }

  string *word = NULL;
  i32 cnt = 0;

  /* If an exception occurs, unmap/close the file, clean up and rethrow it */
  try {
    i32 bytes = sz;
    i8 *offset, *cur;
    offset = cur = static_cast<i8*> (mmap_base);

    /* Load the dictionary words */
    while ( likely(bytes-- > 0) )
      if ( unlikely(*cur == '\n') ) {
        if ( likely(cur != offset) ) {
          word = new string("%.*s", cur - offset, offset);
          word->trim();

          if ( unlikely(word->length() == 0) )
            delete word;

          else {
            cnt++;
            add(word);
          }

          word = NULL;
        }

        offset = ++cur;
      }
      else
        ++cur;
  }

  catch (...) {
    delete word;
    munmap(mmap_base, sz);
    close(fd);
    throw;
  }

  munmap(mmap_base, sz);
  close(fd);

#if CSDBG_DBG_LEVEL & CSDBG_DBGL_INFO
  if ( likely(cnt > 0) )
    util::dbg_info(
      "file '%s' (%d word%s) loaded on dictionary %s",
      path,
      cnt,
      (cnt != 1) ? "s" : "",
      m_name
    );

  else
    util::dbg_info("dictionary file '%s' is empty", path);
#endif

  return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function: