X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fstlplus%2Fsubsystems%2Flibrary_manager.cpp;fp=src%2Fstlplus%2Fsubsystems%2Flibrary_manager.cpp;h=0000000000000000000000000000000000000000;hb=5846afb00833cc72fe72422ca896d2387c712cb4;hp=0daf1be4c0adb0adf28829e6344936e657d59873;hpb=a97500609dc3c1b11f9786d32bc458eb00de4c36;p=chaz%2Fyoink

diff --git a/src/stlplus/subsystems/library_manager.cpp b/src/stlplus/subsystems/library_manager.cpp
deleted file mode 100644
index 0daf1be..0000000
--- a/src/stlplus/subsystems/library_manager.cpp
+++ /dev/null
@@ -1,2332 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-
-//   Author:    Andy Rushton
-//   Copyright: (c) Southampton University 1999-2004
-//              (c) Andy Rushton           2004-2009
-//   License:   BSD License, see ../docs/license.html
-
-////////////////////////////////////////////////////////////////////////////////
-#include "library_manager.hpp"
-#include "file_system.hpp"
-#include <algorithm>
-#include <fstream>
-#include <ctype.h>
-
-////////////////////////////////////////////////////////////////////////////////
-
-static const char* LibraryNameExtension = "lmn";
-static const char* HeaderExtension = "lmh";
-
-////////////////////////////////////////////////////////////////////////////////
-// local operations
-////////////////////////////////////////////////////////////////////////////////
-
-typedef std::map<std::string,stlplus::lm_callback_entry> lm_callback_map;
-
-static std::string lowercase(const std::string& val)
-{
-  std::string text = val;
-  for (unsigned i = 0; i < text.size(); i++)
-    text[i] = tolower(text[i]);
-  return text;
-}
-
-// Context file and library operations
-// These must be readable/writeable without a library data structure present
-// so that the name of the library is known before creation
-
-static bool read_context(const std::string& path, const std::string& owner, std::string& name, bool& writable)
-{
-  std::string spec = stlplus::create_filespec(path, owner, LibraryNameExtension);
-  name = "";
-  writable = false;
-  if (!stlplus::file_exists(spec)) return false;
-  std::ifstream input(spec.c_str());
-  input >> name >> writable;
-  return !input.fail();
-}
-
-static bool write_context(const std::string& path, const std::string& owner, const std::string& name, bool writable)
-{
-  std::string spec = stlplus::create_filespec(path, owner, LibraryNameExtension);
-  std::ofstream output(spec.c_str());
-  output << name << " " << writable << std::endl;
-  return !output.fail();
-}
-
-static bool create_library(const std::string& path, const std::string& owner, const std::string& name, bool writable)
-{
-  std::string spec = stlplus::create_filespec(path, owner, LibraryNameExtension);
-  if (stlplus::is_present(path) && !stlplus::is_folder(path)) return false;
-  if (!stlplus::folder_exists(path) && !stlplus::folder_create(path)) return false;
-  return write_context(path, owner, name, writable);
-}
-
-static bool erase_library(const std::string& path, const std::string& owner)
-{
-  // check that it is a library before deleting it!
-  std::string spec = stlplus::create_filespec(path, owner, LibraryNameExtension);
-  if (!stlplus::file_exists(spec)) return false;
-  return stlplus::folder_delete(path, true);
-}
-
-// dependency checking
-
-typedef std::map<std::pair<std::string,stlplus::lm_unit_name>,stlplus::lm_dependencies> visited_map;
-
-static stlplus::lm_dependencies& out_of_date_check (visited_map& visited,
-                                                    const stlplus::library_manager* manager,
-                                                    const std::string& library,
-                                                    const stlplus::lm_unit_name& name)
-{
-  // the visited field contains an entry if a unit has been visited - it also contains the reason for out-of-date-ness
-  // this is initially set empty (up to date) since the unit has to be added
-  // before it is checked just in case there is a recursive loop
-  // the dependencies field is filled in if the unit is subsequently found to be out of date
-  std::pair<std::string,stlplus::lm_unit_name> full_name = std::make_pair(library,name);
-  // first check whether this unit has already been visited - this should in
-  // principle never happen because the same test is performed before trying
-  // to recurse, so consider this to be paranoid-mode programming
-  visited_map::iterator found = visited.find(full_name);
-  if (found != visited.end())
-    return found->second;
-  // now add this unit to prevent recursion loops later. This entry is added
-  // to when out-of-date dependencies are found and is also the return value
-  // of the function
-  visited[full_name] = stlplus::lm_dependencies();
-  // now find the unit
-  const stlplus::lm_unit_ptr unit = manager->find(library,name);
-  if (!unit)
-  {
-    // if a unit is missing it fails with a dependency on itself - this is a
-    // bit of a work-around, but this again is paranoid-mode programming since
-    // the calling function (this function calling itself recursively) should
-    // check the unit's existence before recursing
-    visited[full_name].unit_add(stlplus::lm_unit_dependency(library,name));
-  }
-  else
-  {
-    // we're onto the real checks now - first get the datestamp of this unit:
-    // all dependencies must be older than this
-    time_t unit_modified = unit->modified();
-    // check dependency on source file if there is one
-    if (unit->source_file_present())
-    {
-      std::string source_file = unit->source_file().path_full(unit->library_path());
-      time_t source_modified = stlplus::file_modified(source_file);
-      if (source_modified == 0 || source_modified > unit_modified)
-      {
-        visited[full_name].set_source_file(unit->source_file());
-      }
-    }
-    // now check the other file dependencies
-    for (unsigned i = 0; i < unit->file_size(); i++)
-    {
-      // a file dependency is a dependency on a file outside of the library system
-      const stlplus::lm_file_dependency& dependency = unit->file_dependency(i);
-      std::string file_full = dependency.path_full(unit->library_path());
-      time_t source_modified = stlplus::file_modified(file_full);
-      if (source_modified == 0 || source_modified > unit_modified)
-      {
-        visited[full_name].file_add(dependency);
-      }
-    }
-    // now check and recurse on unit dependencies
-    for (unsigned j = 0; j < unit->unit_size(); j++)
-    {
-      const stlplus::lm_unit_dependency& dependency = unit->unit_dependency(j);
-      std::pair<std::string,stlplus::lm_unit_name> other_name = std::make_pair(dependency.library(), dependency.unit_name());
-      // perform the datestamp checking at this level and only recurse if this does not detect an error
-      const stlplus::lm_unit_ptr other_unit = manager->find(other_name.first, other_name.second);
-      if (!other_unit)
-      {
-        visited[full_name].unit_add(dependency);
-      }
-      else
-      {
-        time_t other_modified = other_unit->modified();
-        if (other_modified == 0 || other_modified > unit_modified)
-        {
-          visited[full_name].unit_add(dependency);
-        }
-        else
-        {
-          // prevent recursion before doing it
-          visited_map::iterator other_found = visited.find(other_name);
-          if (other_found != visited.end())
-          {
-            // if the unit was found to be out of date on the previous visit, add it to the failed dependencies
-            if (!other_found->second.empty())
-            {
-              visited[full_name].unit_add(dependency);
-            }
-          }
-          else
-          {
-            // the unit hasn't been visited before, so recurse on it now
-            stlplus::lm_dependencies other_dependencies = 
-              out_of_date_check(visited, manager, other_name.first, other_name.second);
-            if (!other_dependencies.empty())
-            {
-              visited[full_name].unit_add(dependency);
-            }
-          }
-        }
-      }
-    }
-  }
-  return visited[full_name];
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// class lm_unit_name
-
-stlplus::lm_unit_name::lm_unit_name(const std::string& name, const std::string& type) :
-  m_name(name), m_type(type)
-{
-}
-
-stlplus::lm_unit_name::~lm_unit_name(void)
-{
-}
-
-const std::string& stlplus::lm_unit_name::name(void) const
-{
-  return m_name;
-}
-
-void stlplus::lm_unit_name::set_name(const std::string& name)
-{
-  m_name = name;
-}
-
-void stlplus::lm_unit_name::lowercase(void)
-{
-  m_name = ::lowercase(m_name);
-}
-
-const std::string& stlplus::lm_unit_name::type(void) const
-{
-  return m_type;
-}
-
-void stlplus::lm_unit_name::set_type(const std::string& type)
-{
-  m_type = type;
-}
-
-bool stlplus::lm_unit_name::write(std::ostream& context) const
-{
-  context << m_name << " " << m_type;
-  return !context.fail();
-}
-
-bool stlplus::lm_unit_name::read(std::istream& context)
-{
-  context >> m_name >> m_type;
-  return !context.fail();
-}
-
-std::string stlplus::lm_unit_name::to_string(void) const
-{
-  return m_name + ":" + m_type;
-}
-
-bool stlplus::lm_unit_name::print(std::ostream& str) const
-{
-  str << to_string();
-  return !str.fail();
-}
-
-std::ostream& stlplus::operator << (std::ostream& str, const stlplus::lm_unit_name& name)
-{
-  name.print(str);
-  return str;
-}
-
-bool stlplus::operator == (const stlplus::lm_unit_name& l, const stlplus::lm_unit_name& r)
-{
-  return l.name() == r.name() && l.type() == r.type();
-}
-
-bool stlplus::operator < (const stlplus::lm_unit_name& l, const stlplus::lm_unit_name& r)
-{
-  // sort by name then type
-  return (l.name() != r.name()) ? l.name() < r.name() : l.type() < r.type();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// dependencies
-
-// file dependencies
-
-stlplus::lm_file_dependency::lm_file_dependency(void) : m_line(0), m_column(0)
-{
-}
-
-stlplus::lm_file_dependency::lm_file_dependency(const std::string& library_path, const std::string& path, unsigned line, unsigned column)
-{
-  set_path(library_path, path);
-  set_line(line);
-  set_column(column);
-}
-
-stlplus::lm_file_dependency::~lm_file_dependency(void)
-{
-}
-
-const std::string& stlplus::lm_file_dependency::path(void) const
-{
-  return m_path;
-}
-
-std::string stlplus::lm_file_dependency::path_full(const std::string& library_path) const
-{
-  return filespec_to_path(library_path, m_path);
-}
-
-void stlplus::lm_file_dependency::set_path(const std::string& library_path, const std::string& path)
-{
-  m_path = filespec_to_relative_path(library_path, path);
-}
-
-unsigned stlplus::lm_file_dependency::line(void) const
-{
-  return m_line;
-}
-
-void stlplus::lm_file_dependency::set_line(unsigned line)
-{
-  m_line = line;
-}
-
-unsigned stlplus::lm_file_dependency::column(void) const
-{
-  return m_column;
-}
-
-void stlplus::lm_file_dependency::set_column(unsigned column)
-{
-  m_column = column;
-}
-
-bool stlplus::lm_file_dependency::write(std::ostream& context) const
-{
-  context << m_path << " " << m_line << " " << m_column;
-  return !context.fail();
-}
-
-bool stlplus::lm_file_dependency::read(std::istream& context)
-{
-  context >> m_path >> m_line >> m_column;
-  return !context.fail();
-}
-
-bool stlplus::lm_file_dependency::print(std::ostream& str) const
-{
-  str << "file: " << m_path;
-  if (m_line != 0)
-    str << ":" << m_line << ":" << m_column;
-  return !str.fail();
-}
-
-std::ostream& stlplus::operator << (std::ostream& str, const stlplus::lm_file_dependency& dependency)
-{
-  dependency.print(str);
-  return str;
-}
-
-// unit dependency
-
-stlplus::lm_unit_dependency::lm_unit_dependency(void)
-{
-}
-
-stlplus::lm_unit_dependency::lm_unit_dependency(const std::string& library, const lm_unit_name& name) : 
-  m_library(library), m_name(name)
-{
-}
-
-stlplus::lm_unit_dependency::~lm_unit_dependency(void)
-{
-}
-
-const std::string& stlplus::lm_unit_dependency::library(void) const
-{
-  return m_library;
-}
-
-void stlplus::lm_unit_dependency::set_library(const std::string& library)
-{
-  m_library = library;
-}
-
-const stlplus::lm_unit_name& stlplus::lm_unit_dependency::unit_name(void) const
-{
-  return m_name;
-}
-
-void stlplus::lm_unit_dependency::set_unit_name(const lm_unit_name& unit_name)
-{
-  m_name = unit_name;
-}
-
-const std::string& stlplus::lm_unit_dependency::name(void) const
-{
-  return m_name.name();
-}
-
-void stlplus::lm_unit_dependency::set_name(const std::string& name)
-{
-  m_name.set_name(name);
-}
-
-const std::string& stlplus::lm_unit_dependency::type(void) const
-{
-  return m_name.type();
-}
-
-void stlplus::lm_unit_dependency::set_type(const std::string& type)
-{
-  m_name.set_type(type);
-}
-
-bool stlplus::lm_unit_dependency::write(std::ostream& context) const
-{
-  context << m_library;
-  m_name.write(context);
-  return !context.fail();
-}
-
-bool stlplus::lm_unit_dependency::read(std::istream& context)
-{
-  context >> m_library;
-  m_name.read(context);;
-  return !context.fail();
-}
-
-bool stlplus::lm_unit_dependency::print(std::ostream& str) const
-{
-  str << "unit: " << m_library << "." << m_name;
-  return !str.fail();
-}
-
-std::ostream& stlplus::operator << (std::ostream& str, const stlplus::lm_unit_dependency& dependency)
-{
-  dependency.print(str);
-  return str;
-}
-
-// dependencies
-
-stlplus::lm_dependencies::lm_dependencies(void) : m_source(0)
-{
-}
-
-stlplus::lm_dependencies::lm_dependencies(const lm_dependencies& r) : m_source(0)
-{
-  *this = r;
-}
-
-stlplus::lm_dependencies& stlplus::lm_dependencies::operator=(const stlplus::lm_dependencies& r)
-{
-  if (m_source)
-    delete m_source;
-  m_source = 0;
-  if (r.m_source)
-    m_source = new lm_file_dependency(*r.m_source);
-  m_files = r.m_files;
-  m_units = r.m_units;
-  return *this;
-}
-
-stlplus::lm_dependencies::~lm_dependencies(void)
-{
-  if (m_source)
-    delete m_source;
-}
-
-void stlplus::lm_dependencies::set_source_file(const lm_file_dependency& source)
-{
-  if (m_source)
-    delete m_source;
-  m_source = new lm_file_dependency(source);
-}
-
-bool stlplus::lm_dependencies::source_file_present(void) const
-{
-  return (m_source != 0);
-}
-
-const stlplus::lm_file_dependency& stlplus::lm_dependencies::source_file(void) const
-{
-  return *m_source;
-}
-
-unsigned stlplus::lm_dependencies::file_add(const lm_file_dependency& dependency)
-{
-  m_files.push_back(dependency);
-  return m_files.size()-1;
-}
-
-unsigned stlplus::lm_dependencies::file_size(void) const
-{
-  return m_files.size();
-}
-
-const stlplus::lm_file_dependency& stlplus::lm_dependencies::file_dependency(unsigned i) const
-{
-  return m_files[i];
-}
-
-void stlplus::lm_dependencies::file_erase(unsigned i)
-{
-  m_files.erase(m_files.begin()+i);
-}
-
-unsigned stlplus::lm_dependencies::unit_add(const lm_unit_dependency& dependency)
-{
-  m_units.push_back(dependency);
-  return m_units.size()-1;
-}
-
-unsigned stlplus::lm_dependencies::unit_size(void) const
-{
-  return m_units.size();
-}
-
-const stlplus::lm_unit_dependency& stlplus::lm_dependencies::unit_dependency(unsigned i) const
-{
-  return m_units[i];
-}
-
-void stlplus::lm_dependencies::unit_erase(unsigned i)
-{
-  m_units.erase(m_units.begin()+i);
-}
-
-void stlplus::lm_dependencies::clear(void)
-{
-  if (m_source)
-    delete m_source;
-  m_source = 0;
-  m_files.clear();
-  m_units.clear();
-}
-
-bool stlplus::lm_dependencies::empty(void) const
-{
-  return (m_source == 0) && m_files.empty() && m_units.empty();
-}
-
-bool stlplus::lm_dependencies::write(std::ostream& context) const
-{
-  context << (m_source ? true : false) << " ";
-  if (m_source) m_source->write(context);
-  context << std::endl;
-  context << m_files.size() << std::endl;
-  for (unsigned i = 0; i < m_files.size(); i++)
-  {
-    m_files[i].write(context);
-    context << std::endl;
-  }
-  context << m_units.size() << std::endl;
-  for (unsigned j = 0; j < m_units.size(); j++)
-  {
-    m_units[j].write(context);
-    context << std::endl;
-  }
-  return !context.fail();
-}
-
-bool stlplus::lm_dependencies::read(std::istream& context)
-{
-  clear();
-  bool source_present = false;
-  context >> source_present;
-  if (source_present)
-  {
-    m_source = new lm_file_dependency();
-    m_source->read(context);
-  }
-  unsigned files_size = 0;
-  context >> files_size;
-  for (unsigned i = 0; i < files_size; i++)
-  {
-    m_files.push_back(lm_file_dependency());
-    m_files.back().read(context);
-  }
-  unsigned units_size = 0;
-  context >> units_size;
-  for (unsigned j = 0; j < units_size; j++)
-  {
-    m_units.push_back(lm_unit_dependency());
-    m_units.back().read(context);
-  }
-  return !context.fail();
-}
-
-bool stlplus::lm_dependencies::print(std::ostream& str) const
-{
-  if (m_source)
-    str << "  source file: " << *m_source << std::endl;
-  for (unsigned i = 0; i < m_files.size(); i++)
-    str << "  " << m_files[i] << std::endl;
-  for (unsigned j = 0; j < m_units.size(); j++)
-    str << "  " << m_units[j] << std::endl;
-  return !str.fail();
-}
-
-std::ostream& stlplus::operator << (std::ostream& str, const stlplus::lm_dependencies& dependencies)
-{
-  dependencies.print(str);
-  return str;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// lm_unit
-////////////////////////////////////////////////////////////////////////////////
-
-stlplus::lm_unit::lm_unit(const lm_unit_name& name, lm_library* library) : 
-  m_name(name), m_header_modified(false), m_loaded(false), m_marked(false), m_library(library), m_error(false)
-{
-  read_header();
-}
-
-stlplus::lm_unit::~lm_unit(void)
-{
-  write_header();
-}
-
-////////////////////////////////////////
-// Header data
-
-const stlplus::lm_unit_name& stlplus::lm_unit::unit_name(void) const
-{
-  return m_name;
-}
-
-const std::string& stlplus::lm_unit::name(void) const
-{
-  return m_name.name();
-}
-
-const std::string& stlplus::lm_unit::type(void) const
-{
-  return m_name.type();
-}
-
-// dependencies
-
-// source file dependency
-
-void stlplus::lm_unit::set_source_file(const lm_file_dependency& dependency)
-{
-  m_header_modified = true;
-  m_dependencies.set_source_file(dependency);
-}
-
-bool stlplus::lm_unit::source_file_present(void) const
-{
-  return m_dependencies.source_file_present();
-}
-
-const stlplus::lm_file_dependency& stlplus::lm_unit::source_file(void) const
-{
-  return m_dependencies.source_file();
-}
-
-// other file dependencies
-
-unsigned stlplus::lm_unit::file_add(const lm_file_dependency& dependency)
-{
-  m_header_modified = true;
-  return m_dependencies.file_add(dependency);
-}
-
-unsigned stlplus::lm_unit::file_size(void) const
-{
-  return m_dependencies.file_size();
-}
-
-const stlplus::lm_file_dependency& stlplus::lm_unit::file_dependency(unsigned i) const
-{
-  return m_dependencies.file_dependency(i);
-}
-
-void stlplus::lm_unit::file_erase(unsigned i)
-{
-  m_header_modified = true;
-  m_dependencies.file_erase(i);
-}
-
-// unit dependencies
-
-unsigned stlplus::lm_unit::unit_add(const lm_unit_dependency& dependency)
-{
-  m_header_modified = true;
-  return m_dependencies.unit_add(dependency);
-}
-
-unsigned stlplus::lm_unit::unit_size(void) const
-{
-  return m_dependencies.unit_size();
-}
-
-const stlplus::lm_unit_dependency& stlplus::lm_unit::unit_dependency(unsigned i) const
-{
-  return m_dependencies.unit_dependency(i);
-}
-
-void stlplus::lm_unit::unit_erase(unsigned i)
-{
-  m_header_modified = true;
-  m_dependencies.unit_erase(i);
-}
-
-const stlplus::lm_dependencies& stlplus::lm_unit::dependencies(void) const
-{
-  return m_dependencies;
-}
-
-void stlplus::lm_unit::set_dependencies(const lm_dependencies& dependencies)
-{
-  m_header_modified = true;
-  m_dependencies = dependencies;
-}
-
-void stlplus::lm_unit::clear_dependencies(void)
-{
-  m_header_modified = true;
-  m_dependencies.clear();
-}
-
-bool stlplus::lm_unit::empty_dependencies(void) const
-{
-  return m_dependencies.empty();
-}
-
-// dependency checking
-
-bool stlplus::lm_unit::out_of_date(void) const
-{
-  return m_library->out_of_date(m_name);
-}
-
-bool stlplus::lm_unit::up_to_date(void) const
-{
-  return m_library->up_to_date(m_name);
-}
-
-stlplus::lm_dependencies stlplus::lm_unit::out_of_date_reason(void) const
-{
-  return m_library->out_of_date_reason(m_name);
-}
-
-// supplementary data
-
-const std::string& stlplus::lm_unit::supplementary_data(void) const
-{
-  return m_supplement;
-}
-
-void stlplus::lm_unit::set_supplementary_data(const std::string& data)
-{
-  m_supplement = data;
-  m_header_modified = true;
-}
-
-////////////////////////////////////////
-// unit data management
-
-bool stlplus::lm_unit::load(void)
-{
-  if (out_of_date()) return false;
-  if (m_loaded) return true;
-  // get the user data for this type
-  lm_callback_map::iterator callback = m_library->m_manager->m_callbacks.find(type());
-  if (callback == m_library->m_manager->m_callbacks.end()) return false;
-  void* data = callback->second.m_type_data;
-  bool result = read(filename(), data);
-  m_loaded = true;
-  return result;
-}
-
-bool stlplus::lm_unit::save(void)
-{
-  if (!m_marked) return true;
-  if (!m_loaded) return false;
-  // get the user data for this type
-  lm_callback_map::iterator callback = m_library->m_manager->m_callbacks.find(type());
-  if (callback == m_library->m_manager->m_callbacks.end()) return false;
-  void* data = callback->second.m_type_data;
-  bool result = write(filename(), data);
-  if (result) m_marked = false;
-  return result;
-}
-
-bool stlplus::lm_unit::loaded(void) const
-{
-  return m_loaded;
-}
-
-void stlplus::lm_unit::mark(void)
-{
-  m_marked = true;
-}
-
-time_t stlplus::lm_unit::modified(void) const
-{
-  return file_modified(filename());
-}
-
-////////////////////////////////////////
-// containing library manager details
-
-const stlplus::lm_library* stlplus::lm_unit::library(void) const
-{
-  return m_library;
-}
-
-stlplus::lm_library* stlplus::lm_unit::library(void)
-{
-  return m_library;
-}
-
-const std::string& stlplus::lm_unit::library_name(void) const
-{
-  return m_library->name();
-}
-
-const std::string& stlplus::lm_unit::library_path(void) const
-{
-  return m_library->path();
-}
-
-// error handling - these apply to the last read/write operation
-
-bool stlplus::lm_unit::error(void) const
-{
-  return m_error;
-}
-
-// functions that customise subclasses of this superclass
-
-bool stlplus::lm_unit::read(const std::string& filespec, void* type_data)
-{
-  std::ifstream input(filespec.c_str());
-  bool result = read(input, type_data);
-  if (input.fail())
-  {
-    result = false;
-    m_error = true;
-  }
-  return result;
-}
-
-bool stlplus::lm_unit::read(std::istream&, void*)
-{
-  return false;
-}
-
-bool stlplus::lm_unit::write(const std::string& filespec, void* type_data)
-{
-  std::ofstream output(filespec.c_str());
-  bool result = write(output, type_data);
-  if (output.fail())
-  {
-    result = false;
-    m_error = true;
-  }
-  return result;
-}
-
-bool stlplus::lm_unit::write(std::ostream&, void*)
-{
-  return false;
-}
-
-bool stlplus::lm_unit::purge(void)
-{
-  return true;
-}
-
-stlplus::lm_unit* stlplus::lm_unit::clone(void) const
-{
-  return new lm_unit(*this);
-}
-
-bool stlplus::lm_unit::print(std::ostream& str) const
-{
-  str << m_name << " " << (m_loaded ? "loaded" : "") << " " << (m_marked ? "needs saving" : "");
-  return !str.fail();
-}
-
-bool stlplus::lm_unit::print_long(std::ostream& str) const
-{
-  str << "header:" << std::endl;
-  str << "  name: " << m_name.name() << std::endl;
-  str << "  type: " << library()->manager()->description(m_name.type()) << std::endl;
-  str << "  dependencies:" << std::endl;
-  // Note: I've inlined this rather than call the above-defined print for dependencies
-  // This is so that I can use the library manager to look up the descriptions of unit types
-  // I can also convert paths so that they are relative to the current directory rather than the library
-  // print the source file dependency if present
-  if (m_dependencies.source_file_present())
-  {
-    str << "  source file: ";
-    str << filespec_to_relative_path(m_dependencies.source_file().path_full(library()->path()));
-    if (m_dependencies.source_file().line() != 0)
-      str << ":" << m_dependencies.source_file().line() << ":" << m_dependencies.source_file().column();
-    str << std::endl;
-  }
-  // now print other file dependencies
-  // convert these to relative paths too
-  for (unsigned f = 0; f < m_dependencies.file_size(); f++)
-  {
-    str << "  file: ";
-    str << filespec_to_relative_path(m_dependencies.file_dependency(f).path_full(library()->path()));
-    if (m_dependencies.file_dependency(f).line() != 0)
-      str << ":" << m_dependencies.file_dependency(f).line() << ":" << m_dependencies.file_dependency(f).column();
-    str << std::endl;
-  }
-  // now print unit dependencies
-  // convert unit types to their descriptive strings
-  for (unsigned u = 0; u < m_dependencies.unit_size(); u++)
-  {
-    str << "  " << library()->manager()->description(m_dependencies.unit_dependency(u).type()) << ": ";
-    str << m_dependencies.unit_dependency(u).library() << "." << m_dependencies.unit_dependency(u).name();
-    str << std::endl;
-  }
-  if (!m_supplement.empty())
-  {
-    str << "  supplementary data: " << m_supplement << std::endl;
-  }
-  return !str.fail();
-}
-
-// header file management
-
-std::string stlplus::lm_unit::filename(void) const
-{
-  return stlplus::create_filespec(library_path(), m_name.name(), m_name.type());
-}
-
-std::string stlplus::lm_unit::header_filename(void) const
-{
-  return stlplus::create_filespec(library_path(), m_name.name(), m_name.type() + std::string(HeaderExtension));
-}
-
-bool stlplus::lm_unit::read_header(void)
-{
-  if (file_exists(header_filename()))
-  {
-    std::ifstream input(header_filename().c_str());
-    m_dependencies.read(input);
-    input.get();
-    std::getline(input, m_supplement);
-  }
-  m_header_modified = false;
-  return true;
-}
-
-bool stlplus::lm_unit::write_header(void)
-{
-  if (!m_header_modified) return true;
-  std::ofstream output(header_filename().c_str());
-  m_dependencies.write(output);
-  output << m_supplement << std::endl;
-  m_header_modified = false;
-  return true;
-}
-
-// print diagnostics
-
-std::ostream& stlplus::operator << (std::ostream& str, const stlplus::lm_unit& u)
-{
-  u.print(str);
-  return str;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// lm_library
-////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////
-// constructors/destructors
-// copy operations only legal on unopened libraries
-
-stlplus::lm_library::lm_library(library_manager* manager) : m_writable(false), m_manager(manager)
-{
-}
-
-stlplus::lm_library::lm_library(const lm_library& library) : m_writable(library.m_writable), m_manager(library.m_manager)
-{
-}
-
-stlplus::lm_library& stlplus::lm_library::operator = (const stlplus::lm_library& library)
-{
-  m_writable = library.m_writable;
-  m_manager = library.m_manager;
-  return *this;
-}
-
-stlplus::lm_library::~lm_library(void)
-{
-  close();
-}
-
-const stlplus::library_manager* stlplus::lm_library::manager(void) const
-{
-  return m_manager;
-}
-
-stlplus::library_manager* stlplus::lm_library::manager(void)
-{
-  return m_manager;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// initialisers
-
-bool stlplus::lm_library::create(const std::string& name, const std::string& path, bool writable)
-{
-  close();
-  if (!create_library(path, m_manager->m_owner, name, writable)) return false;
-  return open(path);
-}
-
-bool stlplus::lm_library::open(const std::string& path)
-{
-  close();
-  if (!read_context(path, m_manager->m_owner, m_name, m_writable)) return false;
-  // convert path to full path on load
-  m_path = folder_to_path(path);
-  return load_types();
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// management of types
-
-bool stlplus::lm_library::load_type(const std::string& type)
-{
-  lm_callback_map::iterator callback = m_manager->m_callbacks.find(type);
-  if (callback == m_manager->m_callbacks.end()) return false;
-  // a null callback means create a dummy unit from the baseclass only
-  lm_create_callback fn = callback->second.m_callback;
-  void* data = callback->second.m_type_data;
-  // for each file in the library folder that matches the type of the create callback, create an unloaded unit
-  std::vector<std::string> files = folder_wildcard(m_path, stlplus::create_filename("*", type), false, true);
-  for (unsigned i = 0; i < files.size(); i++)
-  {
-    // key by unit name - lowercase name if case-insensitive
-    lm_unit_name uname(basename_part(files[i]),type);
-    if (!m_manager->m_unit_case) uname.lowercase();
-    lm_unit_ptr unit;
-    // if there's a callback, use it to create the subclass, else create the
-    // superclass which only contains header information
-    if (fn)
-      unit.set(fn(uname,this,data));
-    else
-      unit.set(new lm_unit(uname,this));
-    m_units[uname] = unit;
-  }
-  return true;
-}
-
-bool stlplus::lm_library::load_types(void)
-{
-  bool result = true;
-  for (lm_callback_map::const_iterator i = m_manager->m_callbacks.begin(); i != m_manager->m_callbacks.end(); i++)
-    result &= load_type(i->first);
-  return result;
-}
-
-bool stlplus::lm_library::remove_type(const std::string& type)
-{
-  bool result = true;
-  std::vector<std::string> units = names(type);
-  for (std::vector<std::string>::iterator i = units.begin(); i != units.end(); i++)
-  {
-    lm_unit_name name(*i, type);
-    std::map<lm_unit_name,lm_unit_ptr>::iterator ni = local_find(name);
-    if (ni != m_units.end())
-      m_units.erase(ni);
-  }
-  return result;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// whole library operations
-
-bool stlplus::lm_library::load(void)
-{
-  bool result = true;
-  for (std::map<lm_unit_name,lm_unit_ptr>::iterator i = m_units.begin(); i != m_units.end(); i++)
-    result &= i->second->load();
-  return result;
-}
-
-bool stlplus::lm_library::save(void)
-{
-  bool result = true;
-  for (std::map<lm_unit_name,lm_unit_ptr>::iterator i = m_units.begin(); i != m_units.end(); i++)
-    result &= i->second->save();
-  return result;
-}
-
-bool stlplus::lm_library::purge(void)
-{
-  bool result = true;
-  for (std::map<lm_unit_name,lm_unit_ptr>::iterator i = m_units.begin(); i != m_units.end(); i++)
-    result &= i->second->purge();
-  return result;
-}
-
-bool stlplus::lm_library::close(void)
-{
-  bool result = save();
-  m_units.clear();
-  m_path = "";
-  m_writable = false;
-  return result;
-}
-
-bool stlplus::lm_library::erase(void)
-{
-  // preserve the path because close destroys it
-  std::string path = m_path;
-  return close() && erase_library(path, m_manager->m_owner);
-}
-
-const std::string& stlplus::lm_library::name(void) const
-{
-  return m_name;
-}
-
-const std::string& stlplus::lm_library::path(void) const
-{
-  return m_path;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// managing read/write status
-
-bool stlplus::lm_library::set_read_write(bool writable)
-{
-  if (m_writable == writable) return true;
-  if (os_read_only()) return false;
-  m_writable = writable;
-  if (!write_context(m_path, m_manager->m_owner, m_name, m_writable))
-    read_context(m_path, m_manager->m_owner, m_name, m_writable);
-  return m_writable == writable;
-}
-
-bool stlplus::lm_library::set_writable(void)
-{
-  return set_read_write(true);
-}
-
-bool stlplus::lm_library::set_read_only(void)
-{
-  return set_read_write(false);
-}
-
-bool stlplus::lm_library::writable(void) const
-{
-  return os_writable() && lm_writable();
-}
-
-bool stlplus::lm_library::read_only(void) const
-{
-  return os_read_only() || lm_read_only();
-}
-
-bool stlplus::lm_library::os_writable(void) const
-{
-  return folder_writable(path());
-}
-
-bool stlplus::lm_library::os_read_only(void) const
-{
-  return !folder_writable(path());
-}
-
-bool stlplus::lm_library::lm_writable(void) const
-{
-  return m_writable;
-}
-
-bool stlplus::lm_library::lm_read_only(void) const
-{
-  return !m_writable;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// unit management
-
-std::map<stlplus::lm_unit_name,stlplus::lm_unit_ptr>::iterator stlplus::lm_library::local_find(const lm_unit_name& name)
-{
-  // implement the case-sensitivity
-  lm_unit_name local = name;
-  if (!m_manager->m_unit_case) local.lowercase();
-  return m_units.find(local);
-}
-
-std::map<stlplus::lm_unit_name,stlplus::lm_unit_ptr>::const_iterator stlplus::lm_library::local_find(const lm_unit_name& name) const
-{
-  // implement the case-sensitivity
-  lm_unit_name local = name;
-  if (!m_manager->m_unit_case) local.set_name(lowercase(local.name()));
-  return m_units.find(local);
-}
-
-bool stlplus::lm_library::exists(const lm_unit_name& name) const
-{
-  return find(name).present();
-}
-
-stlplus::lm_unit_ptr stlplus::lm_library::create(const stlplus::lm_unit_name& name)
-{
-  if (read_only()) return lm_unit_ptr();
-  // preserve the unit's name, but use a lowercase key in case-insensitive mode
-  lm_unit_name uname = name;
-  if (!m_manager->m_unit_case) uname.lowercase();
-  // remove any existing unit with the same name
-  erase(uname);
-  // use the callbacks to create a new unit
-  lm_callback_map::iterator callback = m_manager->m_callbacks.find(name.type());
-  if (callback == m_manager->m_callbacks.end()) return lm_unit_ptr();
-  lm_unit_ptr new_unit;
-  new_unit.set(callback->second.m_callback(name,this,callback->second.m_type_data));
-  new_unit->m_loaded = true;
-  // add it to the library manager
-  m_units[uname] = new_unit;
-  return m_units[uname];
-}
-
-bool stlplus::lm_library::loaded(const lm_unit_name& name) const
-{
-  lm_unit_ptr unit = find(name);
-  return unit && unit->loaded();
-}
-
-bool stlplus::lm_library::load(const lm_unit_name& name)
-{
-  lm_unit_ptr unit = find(name);
-  if (!unit) return false;
-  return unit->load();
-}
-
-bool stlplus::lm_library::purge(const lm_unit_name& name)
-{
-  lm_unit_ptr unit = find(name);
-  if (!unit) return false;
-  bool result = save(name);
-  result &= unit->purge();
-  unit->m_loaded = false;
-  return result;
-}
-
-bool stlplus::lm_library::save(const lm_unit_name& name)
-{
-  if (read_only()) return false;
-  lm_unit_ptr unit = find(name);
-  if (!unit) return false;
-  return unit->save();
-}
-
-bool stlplus::lm_library::erase(const lm_unit_name& name)
-{
-  if (read_only()) return false;
-  std::map<lm_unit_name,lm_unit_ptr>::iterator i = local_find(name);
-  if (i == m_units.end()) return false;
-  std::string spec = i->second->filename();
-  std::string header_spec = i->second->header_filename();
-  m_units.erase(i);
-  file_delete(spec);
-  file_delete(header_spec);
-  return true;
-}
-
-bool stlplus::lm_library::mark(const lm_unit_name& name)
-{
-  if (read_only()) return false;
-  lm_unit_ptr unit = find(name);
-  if (!unit) return false;
-  unit->mark();
-  return true;
-}
-
-time_t stlplus::lm_library::modified(const lm_unit_name& name) const
-{
-  lm_unit_ptr unit = find(name);
-  return unit ? unit->modified() : 0;
-}
-
-bool stlplus::lm_library::erase_by_source(const std::string& source_file)
-{
-  if (read_only()) return false;
-  if (source_file.empty()) return false;
-  bool result = false;
-  std::string source_file_full = filespec_to_path(source_file);
-  // erase by unit name so that I don't have to deal with an iterator to a changing map
-  std::vector<lm_unit_name> units = names();
-  for (std::vector<lm_unit_name>::iterator i = units.begin(); i != units.end(); i++)
-  {
-    lm_unit_ptr unit = find(*i);
-    if (unit && unit->source_file_present())
-    {
-      std::string file_full = unit->source_file().path_full(unit->library_path());
-      if (file_full == source_file_full)
-      {
-        erase(*i);
-        result = true;
-      }
-    }
-  }
-  return result;
-}
-
-const stlplus::lm_unit_ptr stlplus::lm_library::find(const stlplus::lm_unit_name& name) const
-{
-  std::map<lm_unit_name,lm_unit_ptr>::const_iterator i = local_find(name);
-  if (i == m_units.end()) return lm_unit_ptr();
-  return i->second;
-}
-
-stlplus::lm_unit_ptr stlplus::lm_library::find(const stlplus::lm_unit_name& name)
-{
-  std::map<lm_unit_name,lm_unit_ptr>::iterator i = local_find(name);
-  if (i == m_units.end()) return lm_unit_ptr();
-  return i->second;
-}
-
-std::vector<stlplus::lm_unit_name> stlplus::lm_library::names(void) const
-{
-  std::vector<stlplus::lm_unit_name> result;
-  for (std::map<stlplus::lm_unit_name,stlplus::lm_unit_ptr>::const_iterator i = m_units.begin(); i != m_units.end(); i++)
-    result.push_back(i->second->unit_name());
-  return result;
-}
-
-std::vector<std::string> stlplus::lm_library::names(const std::string& type) const
-{
-  std::vector<std::string> result;
-  for (std::map<stlplus::lm_unit_name,stlplus::lm_unit_ptr>::const_iterator i = m_units.begin(); i != m_units.end(); i++)
-    if (i->first.type() == type)
-      result.push_back(i->second->name());
-  return result;
-}
-
-std::vector<stlplus::lm_unit_ptr> stlplus::lm_library::handles(void) const
-{
-  std::vector<stlplus::lm_unit_ptr> result;
-  for (std::map<stlplus::lm_unit_name,stlplus::lm_unit_ptr>::const_iterator i = m_units.begin(); i != m_units.end(); i++)
-    result.push_back(i->second);
-  return result;
-}
-
-std::vector<stlplus::lm_unit_ptr> stlplus::lm_library::handles(const std::string& type) const
-{
-  std::vector<stlplus::lm_unit_ptr> result;
-  for (std::map<stlplus::lm_unit_name,stlplus::lm_unit_ptr>::const_iterator i = m_units.begin(); i != m_units.end(); i++)
-    if (i->first.type() == type)
-      result.push_back(i->second);
-  return result;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// dependency checking
-
-bool stlplus::lm_library::out_of_date(const stlplus::lm_unit_name& name) const
-{
-  return m_manager->out_of_date(m_name, name);
-}
-
-bool stlplus::lm_library::up_to_date(const stlplus::lm_unit_name& name) const
-{
-  return m_manager->up_to_date(m_name, name);
-}
-
-stlplus::lm_dependencies stlplus::lm_library::out_of_date_reason(const stlplus::lm_unit_name& unit) const
-{
-  return m_manager->out_of_date_reason(m_name, unit);
-}
-
-std::pair<bool,unsigned> stlplus::lm_library::tidy(void)
-{
-  std::pair<bool,unsigned> result = std::make_pair(true,0);
-  // erase every unit that is out of date
-  // this will potentially make other units out of date, so keep erasing until
-  // everything is up to date or an error occurs
-  for (;;)
-  {
-    std::vector<stlplus::lm_unit_name> units = names();
-    unsigned initial_count = result.second;
-    for (std::vector<stlplus::lm_unit_name>::iterator i = units.begin(); i != units.end(); i++)
-    {
-      if (out_of_date(*i))
-      {
-        if (!erase(*i))
-          result.first = false;
-        else
-          result.second++;
-      }
-    }
-    if (!result.first) break;
-    if (result.second == initial_count) break;
-  }
-  return result;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// do-everything print routine!
-
-bool stlplus::lm_library::pretty_print(std::ostream& str,
-                                       bool print_units,
-                                       const std::string& type) const
-{
-  // print the library information
-  if (this == m_manager->work())
-    str << "->> ";
-  else
-    str << "    ";
-  str << name() << " in directory " << folder_to_relative_path(path());
-  if (read_only()) str << " (locked)";
-  str << std::endl;
-  // select the units
-  if (print_units)
-  {
-    // separate into a block per unit kind
-    for (lm_callback_map::const_iterator j = m_manager->m_callbacks.begin(); j != m_manager->m_callbacks.end(); j++)
-    {
-      // select the requested unit kind
-      if (type.empty() || type == j->first)
-      {
-        // get all the units of this kind
-        std::vector<std::string> unit_names = names(j->first);
-        if (!unit_names.empty())
-        {
-          str << "    " << j->second.m_description << std::endl;
-          for (unsigned k = 0; k < unit_names.size(); k++)
-          {
-            lm_dependencies reason = out_of_date_reason(stlplus::lm_unit_name(unit_names[k],j->first));
-            str << "    - " << unit_names[k];
-            if (!reason.empty()) str << " (out of date)";
-            str << std::endl;
-            if (!reason.empty())
-            {
-              if (reason.source_file_present())
-              {
-                const lm_file_dependency& file = reason.source_file();
-                str << "    * source file " << filespec_to_relative_path(file.path_full(path())) << " has changed" << std::endl;
-              }
-              for (unsigned i1 = 0; i1 < reason.file_size(); i1++)
-              {
-                const lm_file_dependency& file = reason.file_dependency(i1);
-                str << "    * file " << filespec_to_relative_path(file.path_full(path())) << " has changed" << std::endl;
-              }
-              for (unsigned i2 = 0; i2 < reason.unit_size(); i2++)
-              {
-                const lm_unit_dependency& file = reason.unit_dependency(i2);
-                lm_callback_map::const_iterator entry = m_manager->m_callbacks.find(file.type());
-                str << "    * " << entry->second.m_description << " " << file.library() << "." << file.name() << " has changed" << std::endl;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// diagnostic print routines
-
-bool stlplus::lm_library::print(std::ostream& str) const
-{
-  str << name() << " in " << path() << " " << (writable() ? "writable" : "read-only") << std::endl;
-  for (std::map<stlplus::lm_unit_name,stlplus::lm_unit_ptr>::const_iterator i = m_units.begin(); i != m_units.end(); i++)
-    i->second->print(str);
-  return !str.fail();
-}
-
-bool stlplus::lm_library::print_long(std::ostream& str) const
-{
-  str << name() << " in " << path() << " " << (writable() ? "writable" : "read-only") << std::endl;
-  for (std::map<stlplus::lm_unit_name,stlplus::lm_unit_ptr>::const_iterator i = m_units.begin(); i != m_units.end(); i++)
-    i->second->print_long(str);
-  return !str.fail();
-}
-
-std::ostream& stlplus::operator << (std::ostream& str, const stlplus::lm_library& lib)
-{
-  lib.print(str);
-  return str;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// library manager
-////////////////////////////////////////////////////////////////////////////////
-
-// static functions allow you to test whether a directory is a library before opening it
-// you can also find the library's name without opening it
-
-bool stlplus::library_manager::is_library(const std::string& path, const std::string& owner)
-{
-  std::string spec = stlplus::create_filespec(path, owner, LibraryNameExtension);
-  return file_exists(spec);
-}
-
-std::string stlplus::library_manager::library_name(const std::string& path, const std::string& owner)
-{
-  std::string name;
-  bool writable = false;
-  if (!read_context(path, owner, name, writable))
-    return std::string();
-  return name;
-}
-
-bool stlplus::library_manager::is_library(const std::string& path)
-{
-  return is_library(path, m_owner);
-}
-
-std::string stlplus::library_manager::library_name(const std::string& path)
-{
-  return library_name(path, m_owner);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// tructors
-
-stlplus::library_manager::library_manager(const std::string& owner, bool library_case, bool unit_case) :
-  m_owner(owner), m_ini_files(0), m_library_case(library_case), m_unit_case(unit_case)
-{
-}
-
-stlplus::library_manager::~library_manager(void)
-{
-  close();
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// case sensitivity
-
-bool stlplus::library_manager::library_case(void) const
-{
-  return m_library_case;
-}
-
-void stlplus::library_manager::set_library_case(bool library_case)
-{
-  m_library_case = library_case;
-}
-
-bool stlplus::library_manager::unit_case(void) const
-{
-  return m_unit_case;
-}
-
-void stlplus::library_manager::set_unit_case(bool unit_case)
-{
-  m_unit_case = unit_case;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// type handling
-
-bool stlplus::library_manager::add_type(const std::string& type,
-                                        const std::string& description,
-                                        lm_create_callback fn,
-                                        void* type_data)
-{
-  bool result = true;
-  m_callbacks[type] = lm_callback_entry(fn, description, type_data);
-  for (std::list<lm_library>::iterator i = m_libraries.begin(); i != m_libraries.end(); i++)
-    result &= i->load_type(type);
-  return result;
-}
-
-bool stlplus::library_manager::remove_type(const std::string& type)
-{
-  bool result = true;
-  for (std::list<lm_library>::iterator i = m_libraries.begin(); i != m_libraries.end(); i++)
-    result &= i->remove_type(type);
-  m_callbacks.erase(type);
-  return result;
-}
-
-std::vector<std::string> stlplus::library_manager::types(void) const
-{
-  std::vector<std::string> result;
-  for (lm_callback_map::const_iterator i = m_callbacks.begin(); i != m_callbacks.end(); i++)
-    result.push_back(i->first);
-  return result;
-}
-
-std::string stlplus::library_manager::description(const std::string& type) const
-{
-  lm_callback_map::const_iterator found = m_callbacks.find(type);
-  if (found == m_callbacks.end()) return std::string();
-  return found->second.m_description;
-}
-
-stlplus::lm_create_callback stlplus::library_manager::callback(const std::string& type) const
-{
-  lm_callback_map::const_iterator found = m_callbacks.find(type);
-  if (found == m_callbacks.end()) return 0;
-  return found->second.m_callback;
-}
-
-void* stlplus::library_manager::type_data(const std::string& type) const
-{
-  lm_callback_map::const_iterator found = m_callbacks.find(type);
-  if (found == m_callbacks.end()) return 0;
-  return found->second.m_type_data;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// mapping file handling
-
-void stlplus::library_manager::set_mapping_file(const std::string& mapping_file)
-{
-  m_mapping_file = mapping_file;
-}
-
-bool stlplus::library_manager::load_mappings(const std::string& mapping_file)
-{
-  m_mapping_file = mapping_file;
-  if (!file_exists(mapping_file))
-  {
-    return false;
-  }
-  std::ifstream input(mapping_file.c_str());
-  if (input.fail())
-    return false;
-  // each line of the map file is a path to a library
-  // the first line is the work library - may be empty
-  // mappings are saved as paths relative to the mapping file and converted to full paths on load
-  bool result = true;
-  unsigned line = 1;
-  for (std::string path = ""; std::getline(input,path); line++)
-  {
-    if (path.empty()) continue;
-    std::string full_path = folder_to_path(folder_part(m_mapping_file), path);
-    if (!is_library(full_path))
-    {
-      result = false;
-    }
-    else
-    {
-      lm_library* lib = open(full_path);
-      if (!lib)
-        result = false;
-      else if (line == 1)
-        setwork(lib->name());
-    }
-  }
-  return result;
-}
-
-std::string stlplus::library_manager::mapping_file()
-{
-  return m_mapping_file;
-}
-
-bool stlplus::library_manager::set_ini_manager(ini_manager* ini_files, const std::string& library_section, const std::string& work_name)
-{
-  if (!ini_files) return false;
-  bool result = true;
-  m_ini_files = ini_files;
-  m_ini_section = library_section;
-  m_ini_work = work_name;
-  // now load the existing library mappings if present - in any case create the sections
-  // Note: a library mapping is saved as a path relative to the ini file - on load convert it to a path relative to the current directory
-  if (m_ini_files->section_exists(m_ini_section))
-  {
-    std::vector<std::string> library_names = m_ini_files->variable_names(m_ini_section);
-    std::string work_name;
-    for (unsigned i = 0; i < library_names.size(); i++)
-    {
-      std::string library_name = library_names[i];
-      // if the variable name is the work name, then this is a mapping to an existing library name
-      // if it is null, then it is masking a global library definition so ignore it
-      // otherwise it is a mapping to a directory containing the library
-      if (library_name.empty())
-      {
-      }
-      else if (library_name == m_ini_work)
-      {
-        work_name = m_ini_files->variable_value(m_ini_section, library_name);
-      }
-      else
-      {
-        std::string value = m_ini_files->variable_value(m_ini_section, library_name);
-        std::string filename = m_ini_files->variable_filename(m_ini_section, library_name);
-        // get the path to the ini file defining this library, strip off the ini filename to get the folder
-        // then combine this with the library path from that ini file to the library to get a full path to the library
-        // whew!
-        std::string full_path = folder_to_path(folder_part(filename),value);
-        if (!is_library(full_path))
-          result = false;
-        else
-        {
-          lm_library* lib = open(full_path);
-          if (!lib)
-            result = false;
-        }
-      }
-    }
-    // work must be set after all the libraries have been opened because it is
-    // illegal to set work to a library that doesn't already exist in the
-    // library manager
-    if (work_name.empty())
-      unsetwork();
-    else
-      result &= setwork(work_name);
-  }
-  return result;
-}
-
-stlplus::ini_manager* stlplus::library_manager::get_ini_manager(void) const
-{
-  return m_ini_files;
-}
-
-bool stlplus::library_manager::save_mappings (void)
-{
-  bool result = true;
-  // save to mapping file or ini manager or both
-  if (!m_mapping_file.empty())
-  {
-    if (m_libraries.size() == 0)
-    {
-      // if the file would be empty, delete it
-      if (!file_delete(m_mapping_file))
-        result = false;
-    }
-    else
-    {
-      std::ofstream output(m_mapping_file.c_str());
-      if (output.fail())
-      {
-        result = false;
-      }
-      else
-      {
-        // each line of the map file is a path to a library
-        // the first line is the work library
-        // mappings are saved as relative paths to the mapping file and converted to full paths on load
-        if (!work_name().empty())
-          output << folder_to_relative_path(folder_part(m_mapping_file), path(work_name()));
-        output << std::endl;
-        std::vector<std::string> libraries = names();
-        for (unsigned i = 0; i < libraries.size(); ++i)
-        {
-          if (libraries[i] != work_name())
-            output << folder_to_relative_path(folder_part(m_mapping_file), path(libraries[i])) << std::endl;
-        }
-        if (output.fail())
-          result = false;
-      }
-    }
-  }
-  if (m_ini_files)
-  {
-    // this is somewhat tricky!
-    // first remove all local mappings
-    // then need to compare the surviving library mappings with the contents of the library manager
-    // if there's a library in the ini files not in the library manager, mask it with an empty local declaration
-    // if there's a library in the ini files with the same mapping as the library manager, do nothing
-    // if there's a library in the ini files with a different mapping write that library mapping
-    // if there's a mapping missing from the ini files, write it
-    // finally write the work mapping if there is one
-    // clear all local mappings
-    // TODO - rework this so that the ini files only change if the mappings change
-    m_ini_files->clear_section(m_ini_section);
-    m_ini_files->add_comment(m_ini_section, "generated automatically by the library manager");
-    // look for globally defined library mappings that need to be overridden in the local ini file
-    std::vector<std::string> ini_names = m_ini_files->variable_names(m_ini_section);
-    for (unsigned i = 0; i < ini_names.size(); i++)
-    {
-      std::string ini_name = ini_names[i];
-      // check for a global library that needs to be locally masked
-      if (!exists(ini_name))
-        m_ini_files->add_variable(m_ini_section, ini_name, "");
-      else
-      {
-        // check for a library that is locally remapped
-        std::string value = m_ini_files->variable_value(m_ini_section, ini_name);
-        std::string filename = m_ini_files->variable_filename(m_ini_section, ini_name);
-        std::string full_ini_path = folder_to_path(folder_part(filename), value);
-        std::string full_lib_path = folder_to_path(path(ini_name));
-        if (full_ini_path != full_lib_path)
-        {
-          // write the path relative to the ini file
-          std::string relative_path = folder_to_relative_path(folder_part(filename), full_lib_path);
-          m_ini_files->add_variable(m_ini_section, ini_name, relative_path);
-        }
-      }
-    }
-    // now scan the library for mappings that aren't yet in the ini file
-    std::vector<std::string> lib_names = names();
-    for (unsigned j = 0; j < lib_names.size(); j++)
-    {
-      std::string lib_name = lib_names[j];
-      if (std::find(ini_names.begin(), ini_names.end(), lib_name) == ini_names.end())
-      {
-        // write the path relative to the ini file
-        std::string full_lib_path = folder_to_path(path(lib_name));
-        std::string filename = m_ini_files->variable_filename(m_ini_section, lib_name);
-        std::string relative_path = folder_to_relative_path(folder_part(filename), full_lib_path);
-        m_ini_files->add_variable(m_ini_section, lib_name, relative_path);
-      }
-    }
-    // write the work library - also write a blank value if work is not set but is defined in another library
-    if (!work_name().empty())
-      m_ini_files->add_variable(m_ini_section, m_ini_work, work_name());
-    else if (m_ini_files->variable_exists(m_ini_section, m_ini_work))
-      m_ini_files->add_variable(m_ini_section, m_ini_work, "");
-    m_ini_files->add_blank(m_ini_section);
-    // remove the section from the ini file manager if there's nothing in it
-    if (m_ini_files->empty_section(m_ini_section))
-      m_ini_files->erase_section(m_ini_section);
-    if (!m_ini_files->save())
-      result = false;
-  }
-  return result;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// library management
-
-bool stlplus::library_manager::exists(const std::string& name) const
-{
-  return find(name) != 0;
-}
-
-stlplus::lm_library* stlplus::library_manager::create(const std::string& name, const std::string& path, bool writable)
-{
-  if (!create_library(path, m_owner, name, writable)) return 0;
-  return open(path);
-}
-
-stlplus::lm_library* stlplus::library_manager::open(const std::string& path)
-{
-  std::string name;
-  bool writable = false;
-  if (!read_context(path, m_owner, name, writable)) return 0;
-  // remove any pre-existing library with the same name
-  close(name);
-  // add the library to the manager and open it
-  m_libraries.push_back(lm_library(this));
-  if (!m_libraries.back().open(folder_to_path(path)))
-  {
-    // remove the library in the event of an error
-    m_libraries.erase(--m_libraries.end());
-    return 0;
-  }
-  return &m_libraries.back();
-}
-
-bool stlplus::library_manager::load(const std::string& name)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  return found->load();
-}
-
-bool stlplus::library_manager::save(const std::string& name)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  return found->save();
-}
-
-bool stlplus::library_manager::purge(const std::string& name)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  return found->purge();
-}
-
-bool stlplus::library_manager::close(const std::string& name)
-{
-  bool result= true;
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  result &= found->close();
-  m_libraries.erase(found);
-  if (name == m_work) m_work = "";
-  return result;
-}
-
-bool stlplus::library_manager::erase(const std::string& name)
-{
-  bool result= true;
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  result &= found->erase();
-  m_libraries.erase(found);
-  if (name == m_work) m_work = "";
-  return result;
-}
-
-// operations on all libraries - as above but applied to all the libraries in the manager
-
-bool stlplus::library_manager::load(void)
-{
-  bool result = true;
-  for (std::list<lm_library>::iterator i = m_libraries.begin(); i != m_libraries.end(); i++)
-    result &= i->load();
-  return result;
-}
-
-bool stlplus::library_manager::save(void)
-{
-  bool result = true;
-  for (std::list<lm_library>::iterator i = m_libraries.begin(); i != m_libraries.end(); i++)
-    result &= i->save();
-  return result;
-}
-
-bool stlplus::library_manager::purge(void)
-{
-  bool result = true;
-  for (std::list<lm_library>::iterator i = m_libraries.begin(); i != m_libraries.end(); i++)
-    result &= i->purge();
-  return result;
-}
-
-bool stlplus::library_manager::close(void)
-{
-  bool result = true;
-  for (std::list<lm_library>::iterator i = m_libraries.begin(); i != m_libraries.end(); )
-  {
-    std::list<lm_library>::iterator next = i;
-    next++;
-    result &= i->close();
-    m_libraries.erase(i);
-    i = next;
-  }
-  return result;
-}
-
-bool stlplus::library_manager::erase(void)
-{
-  bool result = true;
-  for (std::list<lm_library>::iterator i = m_libraries.begin(); i != m_libraries.end(); )
-  {
-    std::list<lm_library>::iterator next = i;
-    next++;
-    result &= i->erase();
-    m_libraries.erase(i);
-    i = next;
-  }
-  return result;
-}
-
-// get name and path of a library - name can differ in case if the library manager is case-insensitive
-
-std::string stlplus::library_manager::name(const std::string& name) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return std::string();
-  return found->name();
-}
-
-std::string stlplus::library_manager::path(const std::string& name) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return std::string();
-  return found->path();
-}
-
-// control and test read/write status
-
-bool stlplus::library_manager::set_writable(const std::string& name)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  return found->set_writable();
-}
-
-bool stlplus::library_manager::set_read_only(const std::string& name)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  return found->set_read_only();
-}
-
-bool stlplus::library_manager::writable(const std::string& name) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  return found->writable();
-}
-
-bool stlplus::library_manager::read_only(const std::string& name) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  return found->read_only();
-}
-
-bool stlplus::library_manager::os_writable(const std::string& library) const
-{
-  std::list<lm_library>::const_iterator found = local_find(library);
-  if (found == m_libraries.end()) return false;
-  return found->os_writable();
-}
-
-bool stlplus::library_manager::os_read_only(const std::string& library) const
-{
-  std::list<lm_library>::const_iterator found = local_find(library);
-  if (found == m_libraries.end()) return false;
-  return found->os_read_only();
-}
-
-bool stlplus::library_manager::lm_writable(const std::string& library) const
-{
-  std::list<lm_library>::const_iterator found = local_find(library);
-  if (found == m_libraries.end()) return false;
-  return found->lm_writable();
-}
-
-bool stlplus::library_manager::lm_read_only(const std::string& library) const
-{
-  std::list<lm_library>::const_iterator found = local_find(library);
-  if (found == m_libraries.end()) return false;
-  return found->lm_read_only();
-}
-
-// find a library in the manager - returns null if not found
-
-stlplus::lm_library* stlplus::library_manager::find(const std::string& name)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return 0;
-  return &(*found);
-}
-
-const stlplus::lm_library* stlplus::library_manager::find(const std::string& name) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return 0;
-  return &(*found);
-}
-
-// get the set of all library names
-
-std::vector<std::string> stlplus::library_manager::names(void) const
-{
-  std::vector<std::string> result;
-  for (std::list<lm_library>::const_iterator i = m_libraries.begin(); i != m_libraries.end(); i++)
-    result.push_back(i->name());
-  return result;
-}
-
-// get the set of all libraries
-
-std::vector<const stlplus::lm_library*> stlplus::library_manager::handles(void) const
-{
-  std::vector<const lm_library*> result;
-  for (std::list<lm_library>::const_iterator i = m_libraries.begin(); i != m_libraries.end(); i++)
-    result.push_back(&(*i));
-  return result;
-}
-
-std::vector<stlplus::lm_library*> stlplus::library_manager::handles(void)
-{
-  std::vector<stlplus::lm_library*> result;
-  for (std::list<stlplus::lm_library>::iterator i = m_libraries.begin(); i != m_libraries.end(); i++)
-    result.push_back(&(*i));
-  return result;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// current library management
-
-bool stlplus::library_manager::setwork(const std::string& name)
-{
-  unsetwork();
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  m_work = found->name();
-  return true;
-}
-
-bool stlplus::library_manager::unsetwork(void)
-{
-  m_work = "";
-  return true;
-}
-
-const stlplus::lm_library* stlplus::library_manager::work(void) const
-{
-  if (m_work.empty()) return 0;
-  return find(m_work);
-}
-
-stlplus::lm_library* stlplus::library_manager::work(void)
-{
-  if (m_work.empty()) return 0;
-  return find(m_work);
-}
-
-std::string stlplus::library_manager::work_name(void) const
-{
-  return m_work;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// unit management within a library
-
-bool stlplus::library_manager::exists(const std::string& name, const stlplus::lm_unit_name& unit) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  return found->exists(unit);
-}
-
-stlplus::lm_unit_ptr stlplus::library_manager::create(const std::string& name, const stlplus::lm_unit_name& unit)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return stlplus::lm_unit_ptr();
-  return found->create(unit);
-}
-
-bool stlplus::library_manager::loaded(const std::string& name, const stlplus::lm_unit_name& unit) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return stlplus::lm_unit_ptr();
-  return found->loaded(unit);
-}
-
-bool stlplus::library_manager::load(const std::string& name, const stlplus::lm_unit_name& unit)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return stlplus::lm_unit_ptr();
-  return found->load(unit);
-}
-
-bool stlplus::library_manager::purge(const std::string& name, const stlplus::lm_unit_name& unit)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  return found->purge(unit);
-}
-
-bool stlplus::library_manager::save(const std::string& name, const stlplus::lm_unit_name& unit)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  return found->save(unit);
-}
-
-bool stlplus::library_manager::erase(const std::string& name, const stlplus::lm_unit_name& unit)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  return found->erase(unit);
-}
-
-bool stlplus::library_manager::mark(const std::string& name, const stlplus::lm_unit_name& unit)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return false;
-  return found->mark(unit);
-}
-
-time_t stlplus::library_manager::modified(const std::string& name, const stlplus::lm_unit_name& unit) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return 0;
-  return found->modified(unit);
-}
-
-bool stlplus::library_manager::erase_by_source(const std::string& source_file)
-{
-  bool result = true;
-  for (std::list<lm_library>::iterator i = m_libraries.begin(); i != m_libraries.end(); i++)
-    if (i->writable())
-      result &= i->erase_by_source(source_file);
-  return result;
-}
-
-const stlplus::lm_unit_ptr stlplus::library_manager::find(const std::string& name, const stlplus::lm_unit_name& unit) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end())
-    return stlplus::lm_unit_ptr();
-  return found->find(unit);
-}
-
-stlplus::lm_unit_ptr stlplus::library_manager::find(const std::string& name, const stlplus::lm_unit_name& unit)
-{
-  std::list<lm_library>::iterator found = local_find(name);
-  if (found == m_libraries.end()) return stlplus::lm_unit_ptr();
-  return found->find(unit);
-}
-
-std::vector<stlplus::lm_unit_name> stlplus::library_manager::names(const std::string& name) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return std::vector<stlplus::lm_unit_name>();
-  return found->names();
-}
-
-std::vector<std::string> stlplus::library_manager::names(const std::string& name, const std::string& type) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return std::vector<std::string>();
-  return found->names(type);
-}
-
-std::vector<stlplus::lm_unit_ptr> stlplus::library_manager::handles(const std::string& name) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return std::vector<stlplus::lm_unit_ptr>();
-  return found->handles();
-}
-
-std::vector<stlplus::lm_unit_ptr> stlplus::library_manager::handles(const std::string& name, const std::string& type) const
-{
-  std::list<lm_library>::const_iterator found = local_find(name);
-  if (found == m_libraries.end()) return std::vector<stlplus::lm_unit_ptr>();
-  return found->handles(type);
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// dependency checking
-// done at the top level because a global view of the libraries is required
-
-bool stlplus::library_manager::out_of_date(const std::string& library, const stlplus::lm_unit_name& name) const
-{
-  return !up_to_date(library, name);
-}
-
-bool stlplus::library_manager::up_to_date(const std::string& library, const stlplus::lm_unit_name& name) const
-{
-  lm_dependencies reason = out_of_date_reason(library, name);
-  return reason.empty();
-}
-
-stlplus::lm_dependencies stlplus::library_manager::out_of_date_reason(const std::string& library, const stlplus::lm_unit_name& name) const
-{
-  std::map<std::pair<std::string,stlplus::lm_unit_name>,lm_dependencies> visited;
-  return out_of_date_check(visited, this, library, name);
-}
-
-std::pair<bool,unsigned> stlplus::library_manager::tidy(const std::string& library)
-{
-  std::list<lm_library>::iterator found = local_find(library);
-  if (found == m_libraries.end()) return std::make_pair(false,0);
-  return found->tidy();
-}
-
-std::pair<bool,unsigned> stlplus::library_manager::tidy(void)
-{
-  std::pair<bool,unsigned> result = std::make_pair(true,0);
-  for (std::list<lm_library>::iterator i = m_libraries.begin(); i != m_libraries.end(); i++)
-  {
-    if (i->writable())
-    {
-      std::pair<bool,unsigned> library_result = i->tidy();
-      result.second += library_result.second;
-      result.first &= library_result.first;
-    }
-  }
-  return result;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// do-everything print routine!
-
-bool stlplus::library_manager::pretty_print(std::ostream& str,
-                                            bool print_units,
-                                            const std::string& lib,
-                                            const std::string& type) const
-{
-  bool library_found = false;
-  for (std::list<lm_library>::const_iterator l = m_libraries.begin(); l != m_libraries.end(); l++)
-  {
-    // select the library
-    if (lib.empty() || lib == l->name())
-    {
-      l->pretty_print(str, print_units, type);
-      library_found = true;
-    }
-  }
-  if (!library_found)
-  {
-    if (lib.empty())
-      str << "there are no libraries in the library list" << std::endl;
-    else
-      str << "there is no library called " << lib << " in the library list" << std::endl;
-    return false;
-  }
-  return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// diagnostic print routines
-
-bool stlplus::library_manager::print(std::ostream& str) const
-{
-  for (std::list<lm_library>::const_iterator l = m_libraries.begin(); l != m_libraries.end(); l++)
-    l->print(str);
-  return str;
-}
-
-bool stlplus::library_manager::print_long(std::ostream& str) const
-{
-  for (std::list<lm_library>::const_iterator l = m_libraries.begin(); l != m_libraries.end(); l++)
-    l->print_long(str);
-  return str;
-}
-
-// find a library by name
-
-std::list<stlplus::lm_library>::iterator stlplus::library_manager::local_find(const std::string& name)
-{
-  for (std::list<stlplus::lm_library>::iterator i = m_libraries.begin(); i != m_libraries.end(); i++)
-  {
-    if (m_library_case)
-    {
-      if (i->name() == name) return i;
-    }
-    else
-    {
-      if (lowercase(i->name()) == lowercase(name)) return i;
-    }
-  }
-  return m_libraries.end();
-}
-
-std::list<stlplus::lm_library>::const_iterator stlplus::library_manager::local_find(const std::string& name) const
-{
-  for (std::list<stlplus::lm_library>::const_iterator i = m_libraries.begin(); i != m_libraries.end(); i++)
-  {
-    if (m_library_case)
-    {
-      if (i->name() == name) return i;
-    }
-    else
-    {
-      if (lowercase(i->name()) == lowercase(name)) return i;
-    }
-  }
-  return m_libraries.end();
-}
-
-std::ostream& stlplus::operator << (std::ostream& str, const stlplus::library_manager& manager)
-{
-  manager.print(str);
-  return str;
-}
-
-////////////////////////////////////////////////////////////////////////////////