avoid preprocessor macros for path constants

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@34610 a592a061-630c-0410-9148-cb99ea01b6c8

src/AspellChecker.cpp

@@ -19,6 +19,7 @@
 #include "support/debug.h"
 #include "support/docstring_list.h"
 
+#include "support/filetools.h"
 #include "support/Package.h"
 #include "support/FileName.h"
 #include "support/Path.h"
@@ -28,30 +29,6 @@
 #include <map>
 #include <string>
 
-#ifdef __APPLE__
-
-# ifndef ASPELL_FRAMEWORK
-# define ASPELL_FRAMEWORK "Aspell.framework"
-# endif
-# ifndef ASPELL_FRAMEWORK_DATA
-# define ASPELL_FRAMEWORK_DATA "/Resources/data"
-# endif
-# ifndef ASPELL_FRAMEWORK_DICT
-# define ASPELL_FRAMEWORK_DICT "/Resources/dict"
-# endif
-
-# ifndef ASPELL_MACPORTS
-# define ASPELL_MACPORTS "/opt/local"
-# endif
-# ifndef ASPELL_MACPORTS_DATA
-# define ASPELL_MACPORTS_DATA "/lib/aspell-0.60"
-# endif
-# ifndef ASPELL_MACPORTS_DICT
-# define ASPELL_MACPORTS_DICT "/share/aspell"
-# endif
-
-#endif /* __APPLE__ */
-
 using namespace std;
 using namespace lyx::support;
 
@@ -60,7 +37,6 @@ namespace lyx {
 namespace {
 
 struct Speller {
-	///AspellSpeller * speller;
 	AspellConfig * config;
 	AspellCanHaveError * e_speller;
 };
@@ -87,9 +63,40 @@ struct AspellChecker::Private
 	string const spellerID(string const & lang,
 			       string const & variety);
 
+	bool isValidDictionary(AspellConfig * config,
+			string const & lang, string const & variety);
+	bool checkAspellData(AspellConfig * config,
+		string const & basepath, string const & datapath, string const & dictpath,
+		string const & lang, string const & variety);
+	AspellConfig * getConfig(string const & lang, string const & variety);
+
 	/// the spellers
 	Spellers spellers_;
 
+	/// the location below system/user directory
+	/// there the rws files lookup will happen
+	const string dictDirectory(void) { return "dict"; }
+	/// there the dat+cmap files lookup will happen
+	const string dataDirectory(void) { return "data"; }
+	/// os package directory constants
+	/// macports on Mac OS X or
+	/// aspell rpms on Linux
+	const string osPackageBase(void) {
+#ifdef USE_MACOSX_PACKAGING
+		return "/opt/local";
+#else
+		return "/usr";
+#endif
+	}
+	const string osPackageDictDirectory(void) {
+#ifdef USE_MACOSX_PACKAGING
+		return "/share/aspell";
+#else
+		return "/lib/aspell-0.60";
+#endif
+	}
+	const string osPackageDataDirectory(void) { return "/lib/aspell-0.60"; }
+
 };
 
 
@@ -109,7 +116,7 @@ AspellChecker::Private::~Private()
 }
 
 
-bool isValidDictionary(AspellConfig * config,
+bool AspellChecker::Private::isValidDictionary(AspellConfig * config,
 		string const & lang, string const & variety)
 {
 	bool have = false;
@@ -135,48 +142,46 @@ bool isValidDictionary(AspellConfig * config,
 }
 
 
-bool checkAspellData(AspellConfig * config,
+bool AspellChecker::Private::checkAspellData(AspellConfig * config,
-	char const * basepath, char const * datapath, char const * dictpath,
+	string const & basepath, string const & datapath, string const & dictpath,
 	string const & lang, string const & variety)
 {
-	bool have_dict = false;
 	FileName base(basepath);
-	FileName data(base.absFileName() + datapath);
+	bool have_dict = base.isDirectory() ;
-	FileName dict(base.absFileName() + dictpath);
+
-	have_dict = dict.isDirectory() && data.isDirectory();
 	if (have_dict) {
-		aspell_config_replace(config, "dict-dir", dict.absFileName().c_str());
+		FileName data(addPath(base.absFileName(), datapath));
-		aspell_config_replace(config, "data-dir", data.absFileName().c_str());
+		FileName dict(addPath(base.absFileName(), dictpath));
-		LYXERR(Debug::FILES, "aspell dict: " << dict);
+		have_dict = dict.isDirectory() && data.isDirectory();
-		have_dict = isValidDictionary(config, lang, variety);
+		if (have_dict) {
+			LYXERR(Debug::FILES, "aspell dict-dir: " << dict);
+			LYXERR(Debug::FILES, "aspell data-dir: " << data);
+			aspell_config_replace(config, "dict-dir", dict.absFileName().c_str());
+			aspell_config_replace(config, "data-dir", data.absFileName().c_str());
+			have_dict = isValidDictionary(config, lang, variety);
+		}
 	}
 	return have_dict ;
 }
 
 
-AspellConfig * getConfig(string const & lang,
+AspellConfig * AspellChecker::Private::getConfig(string const & lang, string const & variety)
-						   string const & variety)
 {
 	AspellConfig * config = new_aspell_config();
-#ifdef __APPLE__
-	char buf[2048] ;
 	bool have_dict = false;
-	char const * sysdir = lyx::support::package().system_support().absFileName().c_str() ;
+	string const sysdir = lyx::support::package().system_support().absFileName() ;
-	char const * userdir = lyx::support::package().user_support().absFileName().c_str() ;
+	string const userdir = lyx::support::package().user_support().absFileName() ;
-	char const * framework = ASPELL_FRAMEWORK ;
 
-	LYXERR(Debug::FILES, "aspell sysdir dir: " << sysdir);
 	LYXERR(Debug::FILES, "aspell user dir: " << userdir);
-	have_dict = checkAspellData(config, userdir, ASPELL_FRAMEWORK_DATA, ASPELL_FRAMEWORK_DICT, lang, variety);
+	have_dict = checkAspellData(config, userdir, dataDirectory(), dictDirectory(), lang, variety);
-	if (!have_dict && strlen(framework) && getPrivateFrameworkPathName(buf, sizeof(buf), framework)) {
+	if (!have_dict) {
-		LYXERR(Debug::FILES, "aspell bundle path: " << buf);
+		LYXERR(Debug::FILES, "aspell sysdir dir: " << sysdir);
-		have_dict = checkAspellData(config, buf, ASPELL_FRAMEWORK_DATA, ASPELL_FRAMEWORK_DICT, lang, variety);
+		have_dict = checkAspellData(config, sysdir, dataDirectory(), dictDirectory(), lang, variety);
 	}
 	if (!have_dict) {
-		// check for macports data
+		// check for package data of OS installation
-		have_dict = checkAspellData(config, ASPELL_MACPORTS, ASPELL_MACPORTS_DATA, ASPELL_MACPORTS_DICT, lang, variety);
+		have_dict = checkAspellData(config, osPackageBase(), osPackageDataDirectory(), osPackageDictDirectory(), lang, variety);
 	}
-#endif
 	return config ;
 }
 
@@ -263,7 +268,8 @@ SpellChecker::Result AspellChecker::check(WordLangTuple const & word)
 		// MSVC compiled Aspell doesn't like it.
 		return OK;
 
-	int const word_ok = aspell_speller_check(m, to_utf8(word.word()).c_str(), -1);
+	const char * word_str = to_utf8(word.word()).c_str();
+	int const word_ok = aspell_speller_check(m, word_str, -1);
 	LASSERT(word_ok != -1, /**/);
 
 	return (word_ok) ? OK : UNKNOWN_WORD;
@@ -328,11 +334,11 @@ bool AspellChecker::hasDictionary(Language const * lang) const
 
 	if (lang) {
 		for (; it != end && !have; ++it) {
-			have = isValidDictionary(it->second.config, lang->code(), lang->variety());
+			have = d->isValidDictionary(it->second.config, lang->code(), lang->variety());
 		}
 		if (!have) {
-			AspellConfig * config = getConfig(lang->code(), lang->variety());
+			AspellConfig * config = d->getConfig(lang->code(), lang->variety());
-			have = isValidDictionary(config, lang->code(), lang->variety());
+			have = d->isValidDictionary(config, lang->code(), lang->variety());
 			delete_aspell_config(config);
 		}
 	}

src/HunspellChecker.cpp

@@ -46,9 +46,6 @@ typedef vector<WordLangTuple> IgnoreList;
 
 } // anon namespace
 
-#ifndef HUNSPELL_DICT
-# define HUNSPELL_DICT "dict"
-#endif
 
 struct HunspellChecker::Private
 {
@@ -56,6 +53,8 @@ struct HunspellChecker::Private
 
 	~Private();
 
+	const string dictPath(int selector);
+	bool haveLanguageFiles(string const & hpath);
 	bool haveDictionary(string const & lang, string & hpath);
 	bool haveDictionary(string const & lang);
 	Hunspell * addSpeller(string const & lang, string & hpath);
@@ -68,6 +67,11 @@ struct HunspellChecker::Private
 	Spellers spellers_;
 	///
 	IgnoreList ignored_;
+
+	/// the location below system/user directory
+	/// there the aff+dic files lookup will happen
+	const string dictDirectory(void) { return "dict"; }
+	const int maxLookupSelector(void) { return 3; }
 };
 
 
@@ -82,8 +86,7 @@ HunspellChecker::Private::~Private()
 }
 
 
-namespace {
+bool HunspellChecker::Private::haveLanguageFiles(string const & hpath)
-bool haveLanguageFiles(string const & hpath)
 {
 	FileName const affix(hpath + ".aff");
 	FileName const dict(hpath + ".dic");
@@ -91,23 +94,20 @@ bool haveLanguageFiles(string const & hpath)
 }
 
 
-#define MAX_SELECTOR 3
+const string HunspellChecker::Private::dictPath(int selector)
-string dictPath(int selector)
 {
 	switch (selector) {
 	case 2:
-		return addName(lyx::support::package().system_support().absFileName(),HUNSPELL_DICT);
+		return addName(lyx::support::package().system_support().absFileName(),dictDirectory());
 		break;
 	case 1:
-		return addName(lyx::support::package().user_support().absFileName(),HUNSPELL_DICT);
+		return addName(lyx::support::package().user_support().absFileName(),dictDirectory());
 		break;
 	default:
 		return lyxrc.hunspelldir_path;
 	}
 }
 
-}
-
 
 bool HunspellChecker::Private::haveDictionary(string const & lang, string & hpath)
 {
@@ -135,7 +135,7 @@ bool HunspellChecker::Private::haveDictionary(string const & lang, string & hpat
 bool HunspellChecker::Private::haveDictionary(string const & lang)
 {
 	bool result = false;
-	for ( int p = 0; !result && p < MAX_SELECTOR; p++ ) {
+	for ( int p = 0; !result && p < maxLookupSelector(); p++ ) {
 		string lpath = dictPath(p);
 		result = haveDictionary(lang, lpath);
 	}
@@ -172,7 +172,7 @@ Hunspell * HunspellChecker::Private::addSpeller(string const & lang,string & pat
 Hunspell * HunspellChecker::Private::addSpeller(string const & lang)
 {
 	Hunspell * h = 0;
-	for ( int p = 0; p < MAX_SELECTOR && 0 == h; p++ ) {
+	for ( int p = 0; p < maxLookupSelector() && 0 == h; p++ ) {
 		string lpath = dictPath(p);
 		h = addSpeller(lang, lpath);
 	}

src/Thesaurus.cpp

@@ -42,10 +42,6 @@ typedef std::map<docstring, MyThes *> Thesauri;
 
 } // namespace anon
 
-#ifndef THESAURUS_LOCATION
-# define THESAURUS_LOCATION "thes"
-#endif
-
 struct Thesaurus::Private
 {
 	~Private()
@@ -77,6 +73,11 @@ struct Thesaurus::Private
 
 	/// the thesauri
 	Thesauri thes_;
+
+	/// the location below system/user directory
+	/// there the data+idx files lookup will happen
+	const string dataDirectory(void) { return "thes"; }
+
 };
 
 
@@ -125,11 +126,11 @@ pair<string,string> Thesaurus::Private::getThesaurus(docstring const & lang)
 		result = getThesaurus(thes_path, lang);
 	}
 	if (result.first.empty() || result.second.empty()) {
-		string const sys_path = external_path(addName(lyx::support::package().system_support().absFileName(),THESAURUS_LOCATION)) ;
+		string const sys_path = external_path(addName(lyx::support::package().system_support().absFileName(),dataDirectory())) ;
 		result = getThesaurus(sys_path, lang);
 	}
 	if (result.first.empty() || result.second.empty()) {
-		string const user_path = external_path(addName(lyx::support::package().user_support().absFileName(),THESAURUS_LOCATION)) ;
+		string const user_path = external_path(addName(lyx::support::package().user_support().absFileName(),dataDirectory())) ;
 		result = getThesaurus(user_path, lang);
 	}
 	return result;