[ntk/apt.git] / apt-pkg / aptconfiguration.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
/* ######################################################################

   Provide access methods to various configuration settings,
   setup defaults and returns validate settings.

   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#include <apt-pkg/aptconfiguration.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/fileutl.h>
#include <apt-pkg/macros.h>
#include <apt-pkg/strutl.h>

#include <sys/types.h>
#include <dirent.h>

#include <algorithm>
#include <string>
#include <vector>
									/*}}}*/
namespace APT {
// getCompressionTypes - Return Vector of usbale compressiontypes	/*{{{*/
// ---------------------------------------------------------------------
/* return a vector of compression types in the prefered order. */
std::vector<std::string>
const Configuration::getCompressionTypes(bool const &Cached) {
	static std::vector<std::string> types;
	if (types.empty() == false) {
		if (Cached == true)
			return types;
		else
			types.clear();
	}

	// setup the defaults for the compressiontypes => method mapping
	_config->CndSet("Acquire::CompressionTypes::bz2","bzip2");
	_config->CndSet("Acquire::CompressionTypes::lzma","lzma");
	_config->CndSet("Acquire::CompressionTypes::gz","gzip");

	// Set default application paths to check for optional compression types
	_config->CndSet("Dir::Bin::lzma", "/usr/bin/lzma");
	_config->CndSet("Dir::Bin::bzip2", "/bin/bzip2");

	// accept non-list order as override setting for config settings on commandline
	std::string const overrideOrder = _config->Find("Acquire::CompressionTypes::Order","");
	if (overrideOrder.empty() == false)
		types.push_back(overrideOrder);

	// load the order setting into our vector
	std::vector<std::string> const order = _config->FindVector("Acquire::CompressionTypes::Order");
	for (std::vector<std::string>::const_iterator o = order.begin();
	     o != order.end(); o++) {
		if ((*o).empty() == true)
			continue;
		// ignore types we have no method ready to use
		if (_config->Exists(string("Acquire::CompressionTypes::").append(*o)) == false)
			continue;
		// ignore types we have no app ready to use
		string const appsetting = string("Dir::Bin::").append(*o);
		if (_config->Exists(appsetting) == true) {
			std::string const app = _config->FindFile(appsetting.c_str(), "");
			if (app.empty() == false && FileExists(app) == false)
				continue;
		}
		types.push_back(*o);
	}

	// move again over the option tree to add all missing compression types
	::Configuration::Item const *Types = _config->Tree("Acquire::CompressionTypes");
	if (Types != 0)
		Types = Types->Child;

	for (; Types != 0; Types = Types->Next) {
		if (Types->Tag == "Order" || Types->Tag.empty() == true)
			continue;
		// ignore types we already have in the vector
		if (std::find(types.begin(),types.end(),Types->Tag) != types.end())
			continue;
		// ignore types we have no app ready to use
		string const appsetting = string("Dir::Bin::").append(Types->Value);
		if (appsetting.empty() == false && _config->Exists(appsetting) == true) {
			std::string const app = _config->FindFile(appsetting.c_str(), "");
			if (app.empty() == false && FileExists(app) == false)
				continue;
		}
		types.push_back(Types->Tag);
	}

	return types;
}
									/*}}}*/
// GetLanguages - Return Vector of Language Codes			/*{{{*/
// ---------------------------------------------------------------------
/* return a vector of language codes in the prefered order.
   the special word "environment" will be replaced with the long and the short
   code of the local settings and it will be insured that this will not add
   duplicates. So in an german local the setting "environment, de_DE, en, de"
   will result in "de_DE, de, en".
   The special word "none" is the stopcode for the not-All code vector */
std::vector<std::string> const Configuration::getLanguages(bool const &All,
				bool const &Cached, char const ** const Locale) {
	using std::string;

	// The detection is boring and has a lot of cornercases,
	// so we cache the results to calculated it only once.
	std::vector<string> static allCodes;
	std::vector<string> static codes;

	// we have something in the cache
	if (codes.empty() == false || allCodes.empty() == false) {
		if (Cached == true) {
			if(All == true && allCodes.empty() == false)
				return allCodes;
			else
				return codes;
		} else {
			allCodes.clear();
			codes.clear();
		}
	}

	// Include all Language codes we have a Translation file for in /var/lib/apt/lists
	// so they will be all included in the Cache.
	std::vector<string> builtin;
	DIR *D = opendir(_config->FindDir("Dir::State::lists").c_str());
	if (D != 0) {
		builtin.push_back("none");
		for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D)) {
			string const name = Ent->d_name;
			size_t const foundDash = name.rfind("-");
			size_t const foundUnderscore = name.rfind("_");
			if (foundDash == string::npos || foundUnderscore == string::npos ||
			    foundDash <= foundUnderscore ||
			    name.substr(foundUnderscore+1, foundDash-(foundUnderscore+1)) != "Translation")
				continue;
			string const c = name.substr(foundDash+1);
			if (unlikely(c.empty() == true) || c == "en")
				continue;
			// Skip unusual files, like backups or that alike
			string::const_iterator s = c.begin();
			for (;s != c.end(); ++s) {
				if (isalpha(*s) == 0)
					break;
			}
			if (s != c.end())
				continue;
			if (std::find(builtin.begin(), builtin.end(), c) != builtin.end())
				continue;
			builtin.push_back(c);
		}
	}

	// get the environment language codes: LC_MESSAGES (and later LANGUAGE)
	// we extract both, a long and a short code and then we will
	// check if we actually need both (rare) or if the short is enough
	string const envMsg = string(Locale == 0 ? std::setlocale(LC_MESSAGES, NULL) : *Locale);
	size_t const lenShort = (envMsg.find('_') != string::npos) ? envMsg.find('_') : 2;
	size_t const lenLong = (envMsg.find_first_of(".@") != string::npos) ? envMsg.find_first_of(".@") : (lenShort + 3);

	string envLong = envMsg.substr(0,lenLong);
	string const envShort = envLong.substr(0,lenShort);
	bool envLongIncluded = true;

	// first cornercase: LANG=C, so we use only "en" Translation
	if (envLong == "C") {
		codes.push_back("en");
		allCodes = codes;
		allCodes.insert(allCodes.end(), builtin.begin(), builtin.end());
		if (All == true)
			return allCodes;
		else
			return codes;
	}

	// to save the servers from unneeded queries, we only try also long codes
	// for languages it is realistic to have a long code translation file…
	// TODO: Improve translation acquire system to drop them dynamic
	char const *needLong[] = { "cs", "en", "pt", "sv", "zh", NULL };
	if (envLong != envShort) {
		for (char const **l = needLong; *l != NULL; l++)
			if (envShort.compare(*l) == 0) {
				envLongIncluded = false;
				break;
			}
	}

	// we don't add the long code, but we allow the user to do so
	if (envLongIncluded == true)
		envLong.clear();

	// FIXME: Remove support for the old APT::Acquire::Translation
	// it was undocumented and so it should be not very widthly used
	string const oldAcquire = _config->Find("APT::Acquire::Translation","");
	if (oldAcquire.empty() == false && oldAcquire != "environment") {
		if (oldAcquire != "none")
			codes.push_back(oldAcquire);
		codes.push_back("en");
		allCodes = codes;
		for (std::vector<string>::const_iterator b = builtin.begin();
		     b != builtin.end(); ++b)
			if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
				allCodes.push_back(*b);
		if (All == true)
			return allCodes;
		else
			return codes;
	}

	// It is very likely we will need to environment codes later,
	// so let us generate them now from LC_MESSAGES and LANGUAGE
	std::vector<string> environment;
	// take care of LC_MESSAGES
	if (envLongIncluded == false)
		environment.push_back(envLong);
	environment.push_back(envShort);
	// take care of LANGUAGE
	const char *language_env = getenv("LANGUAGE") == 0 ? "" : getenv("LANGUAGE");
	string envLang = Locale == 0 ? language_env : *(Locale+1);
	if (envLang.empty() == false) {
		std::vector<string> env = ExplodeString(envLang,':');
		short addedLangs = 0; // add a maximum of 3 fallbacks from the environment
		for (std::vector<string>::const_iterator e = env.begin();
		     e != env.end() && addedLangs < 3; ++e) {
			if (unlikely(e->empty() == true) || *e == "en")
				continue;
			if (*e == envLong || *e == envShort)
				continue;
			if (std::find(environment.begin(), environment.end(), *e) != environment.end())
				continue;
			if (e->find('_') != string::npos) {
				// Drop LongCodes here - ShortCodes are also included
				string const shorty = e->substr(0, e->find('_'));
				char const **n = needLong;
				for (; *n != NULL; ++n)
					if (shorty == *n)
						break;
				if (*n == NULL)
					continue;
			}
			++addedLangs;
			environment.push_back(*e);
		}
	}

	// Support settings like Acquire::Translation=none on the command line to
	// override the configuration settings vector of languages.
	string const forceLang = _config->Find("Acquire::Languages","");
	if (forceLang.empty() == false) {
		if (forceLang == "environment") {
			codes = environment;
		} else if (forceLang != "none")
			codes.push_back(forceLang);
		allCodes = codes;
		for (std::vector<string>::const_iterator b = builtin.begin();
		     b != builtin.end(); ++b)
			if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
				allCodes.push_back(*b);
		if (All == true)
			return allCodes;
		else
			return codes;
	}

	std::vector<string> const lang = _config->FindVector("Acquire::Languages");
	// the default setting -> "environment, en"
	if (lang.empty() == true) {
		codes = environment;
		if (envShort != "en")
			codes.push_back("en");
		allCodes = codes;
		for (std::vector<string>::const_iterator b = builtin.begin();
		     b != builtin.end(); ++b)
			if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
				allCodes.push_back(*b);
		if (All == true)
			return allCodes;
		else
			return codes;
	}

	// the configs define the order, so add the environment
	// then needed and ensure the codes are not listed twice.
	bool noneSeen = false;
	for (std::vector<string>::const_iterator l = lang.begin();
	     l != lang.end(); l++) {
		if (*l == "environment") {
			for (std::vector<string>::const_iterator e = environment.begin();
			     e != environment.end(); ++e) {
				if (std::find(allCodes.begin(), allCodes.end(), *e) != allCodes.end())
					continue;
				if (noneSeen == false)
					codes.push_back(*e);
				allCodes.push_back(*e);
			}
			continue;
		} else if (*l == "none") {
			noneSeen = true;
			continue;
		} else if (std::find(allCodes.begin(), allCodes.end(), *l) != allCodes.end())
			continue;

		if (noneSeen == false)
			codes.push_back(*l);
		allCodes.push_back(*l);
	}

	for (std::vector<string>::const_iterator b = builtin.begin();
	     b != builtin.end(); ++b)
		if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
			allCodes.push_back(*b);

	if (All == true)
		return allCodes;
	else
		return codes;
}
									/*}}}*/
}
Commit	Line	Data
e878aedb DK	1	// -- mode: cpp; mode: fold --
	2	// Description /{{{/
	3	/* ######################################################################
	4
	5	Provide access methods to various configuration settings,
	6	setup defaults and returns validate settings.
	7
	8	##################################################################### */
	9	/}}}/
	10	// Include Files /{{{/
e878aedb DK	11	#include <apt-pkg/aptconfiguration.h>
e878aedb DK	12	#include <apt-pkg/configuration.h>
d7cf5923 DK	13	#include <apt-pkg/fileutl.h>
	14	#include <apt-pkg/macros.h>
	15	#include <apt-pkg/strutl.h>
e878aedb	16
3f2d77b5 DK	17	#include <sys/types.h>
	18	#include <dirent.h>
	19
8bd02d8b	20	#include <algorithm>
3f2d77b5 DK	21	#include <string>
3f2d77b5 DK	22	#include <vector>
e878aedb DK	23	/}}}/
	24	namespace APT {
	25	// getCompressionTypes - Return Vector of usbale compressiontypes /{{{/
	26	// ---------------------------------------------------------------------
	27	/* return a vector of compression types in the prefered order. */
	28	std::vector<std::string>
	29	const Configuration::getCompressionTypes(bool const &Cached) {
	30	static std::vector<std::string> types;
	31	if (types.empty() == false) {
	32	if (Cached == true)
	33	return types;
	34	else
	35	types.clear();
	36	}
	37
8bd02d8b DK	38	// setup the defaults for the compressiontypes => method mapping
	39	_config->CndSet("Acquire::CompressionTypes::bz2","bzip2");
	40	_config->CndSet("Acquire::CompressionTypes::lzma","lzma");
	41	_config->CndSet("Acquire::CompressionTypes::gz","gzip");
	42
e878aedb DK	43	// Set default application paths to check for optional compression types
	44	_config->CndSet("Dir::Bin::lzma", "/usr/bin/lzma");
	45	_config->CndSet("Dir::Bin::bzip2", "/bin/bzip2");
	46
8bd02d8b DK	47	// accept non-list order as override setting for config settings on commandline
	48	std::string const overrideOrder = _config->Find("Acquire::CompressionTypes::Order","");
	49	if (overrideOrder.empty() == false)
	50	types.push_back(overrideOrder);
e878aedb	51
8bd02d8b DK	52	// load the order setting into our vector
	53	std::vector<std::string> const order = _config->FindVector("Acquire::CompressionTypes::Order");
	54	for (std::vector<std::string>::const_iterator o = order.begin();
	55	o != order.end(); o++) {
	56	if ((*o).empty() == true)
	57	continue;
	58	// ignore types we have no method ready to use
	59	if (_config->Exists(string("Acquire::CompressionTypes::").append(*o)) == false)
	60	continue;
	61	// ignore types we have no app ready to use
	62	string const appsetting = string("Dir::Bin::").append(*o);
	63	if (_config->Exists(appsetting) == true) {
	64	std::string const app = _config->FindFile(appsetting.c_str(), "");
	65	if (app.empty() == false && FileExists(app) == false)
	66	continue;
	67	}
	68	types.push_back(*o);
e878aedb DK	69	}
e878aedb DK	70
8bd02d8b	71	// move again over the option tree to add all missing compression types
e878aedb DK	72	::Configuration::Item const *Types = _config->Tree("Acquire::CompressionTypes");
	73	if (Types != 0)
	74	Types = Types->Child;
	75
	76	for (; Types != 0; Types = Types->Next) {
8bd02d8b DK	77	if (Types->Tag == "Order" \|\| Types->Tag.empty() == true)
	78	continue;
	79	// ignore types we already have in the vector
	80	if (std::find(types.begin(),types.end(),Types->Tag) != types.end())
	81	continue;
	82	// ignore types we have no app ready to use
e878aedb	83	string const appsetting = string("Dir::Bin::").append(Types->Value);
e878aedb DK	84	if (appsetting.empty() == false && _config->Exists(appsetting) == true) {
	85	std::string const app = _config->FindFile(appsetting.c_str(), "");
	86	if (app.empty() == false && FileExists(app) == false)
	87	continue;
	88	}
	89	types.push_back(Types->Tag);
	90	}
	91
	92	return types;
	93	}
	94	/}}}/
45df0ad2 DK	95	// GetLanguages - Return Vector of Language Codes /{{{/
	96	// ---------------------------------------------------------------------
	97	/* return a vector of language codes in the prefered order.
	98	the special word "environment" will be replaced with the long and the short
	99	code of the local settings and it will be insured that this will not add
	100	duplicates. So in an german local the setting "environment, de_DE, en, de"
	101	will result in "de_DE, de, en".
	102	The special word "none" is the stopcode for the not-All code vector */
	103	std::vector<std::string> const Configuration::getLanguages(bool const &All,
d7cf5923	104	bool const &Cached, char const ** const Locale) {
45df0ad2 DK	105	using std::string;
	106
	107	// The detection is boring and has a lot of cornercases,
	108	// so we cache the results to calculated it only once.
	109	std::vector<string> static allCodes;
	110	std::vector<string> static codes;
	111
	112	// we have something in the cache
	113	if (codes.empty() == false \|\| allCodes.empty() == false) {
	114	if (Cached == true) {
	115	if(All == true && allCodes.empty() == false)
	116	return allCodes;
	117	else
	118	return codes;
	119	} else {
	120	allCodes.clear();
	121	codes.clear();
	122	}
	123	}
	124
3f2d77b5 DK	125	// Include all Language codes we have a Translation file for in /var/lib/apt/lists
	126	// so they will be all included in the Cache.
	127	std::vector<string> builtin;
	128	DIR *D = opendir(_config->FindDir("Dir::State::lists").c_str());
	129	if (D != 0) {
	130	builtin.push_back("none");
	131	for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D)) {
	132	string const name = Ent->d_name;
	133	size_t const foundDash = name.rfind("-");
	134	size_t const foundUnderscore = name.rfind("_");
	135	if (foundDash == string::npos \|\| foundUnderscore == string::npos \|\|
	136	foundDash <= foundUnderscore \|\|
	137	name.substr(foundUnderscore+1, foundDash-(foundUnderscore+1)) != "Translation")
	138	continue;
	139	string const c = name.substr(foundDash+1);
	140	if (unlikely(c.empty() == true) \|\| c == "en")
	141	continue;
	142	// Skip unusual files, like backups or that alike
	143	string::const_iterator s = c.begin();
	144	for (;s != c.end(); ++s) {
	145	if (isalpha(*s) == 0)
	146	break;
	147	}
	148	if (s != c.end())
	149	continue;
	150	if (std::find(builtin.begin(), builtin.end(), c) != builtin.end())
	151	continue;
	152	builtin.push_back(c);
	153	}
	154	}
	155
d7cf5923	156	// get the environment language codes: LC_MESSAGES (and later LANGUAGE)
45df0ad2 DK	157	// we extract both, a long and a short code and then we will
45df0ad2 DK	158	// check if we actually need both (rare) or if the short is enough
d7cf5923	159	string const envMsg = string(Locale == 0 ? std::setlocale(LC_MESSAGES, NULL) : *Locale);
45df0ad2	160	size_t const lenShort = (envMsg.find('_') != string::npos) ? envMsg.find('_') : 2;
d7cf5923	161	size_t const lenLong = (envMsg.find_first_of(".@") != string::npos) ? envMsg.find_first_of(".@") : (lenShort + 3);
45df0ad2 DK	162
	163	string envLong = envMsg.substr(0,lenLong);
	164	string const envShort = envLong.substr(0,lenShort);
d7cf5923	165	bool envLongIncluded = true;
45df0ad2 DK	166
	167	// first cornercase: LANG=C, so we use only "en" Translation
	168	if (envLong == "C") {
	169	codes.push_back("en");
d7cf5923	170	allCodes = codes;
3f2d77b5 DK	171	allCodes.insert(allCodes.end(), builtin.begin(), builtin.end());
	172	if (All == true)
	173	return allCodes;
	174	else
	175	return codes;
45df0ad2 DK	176	}
45df0ad2 DK	177
d7cf5923 DK	178	// to save the servers from unneeded queries, we only try also long codes
	179	// for languages it is realistic to have a long code translation file…
	180	// TODO: Improve translation acquire system to drop them dynamic
	181	char const *needLong[] = { "cs", "en", "pt", "sv", "zh", NULL };
45df0ad2	182	if (envLong != envShort) {
45df0ad2 DK	183	for (char const *l = needLong; l != NULL; l++)
	184	if (envShort.compare(*l) == 0) {
	185	envLongIncluded = false;
	186	break;
	187	}
	188	}
	189
	190	// we don't add the long code, but we allow the user to do so
	191	if (envLongIncluded == true)
	192	envLong.clear();
	193
	194	// FIXME: Remove support for the old APT::Acquire::Translation
	195	// it was undocumented and so it should be not very widthly used
	196	string const oldAcquire = _config->Find("APT::Acquire::Translation","");
	197	if (oldAcquire.empty() == false && oldAcquire != "environment") {
	198	if (oldAcquire != "none")
	199	codes.push_back(oldAcquire);
3f2d77b5	200	codes.push_back("en");
d7cf5923	201	allCodes = codes;
3f2d77b5 DK	202	for (std::vector<string>::const_iterator b = builtin.begin();
	203	b != builtin.end(); ++b)
	204	if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
	205	allCodes.push_back(*b);
	206	if (All == true)
	207	return allCodes;
	208	else
	209	return codes;
45df0ad2 DK	210	}
45df0ad2 DK	211
d7cf5923 DK	212	// It is very likely we will need to environment codes later,
	213	// so let us generate them now from LC_MESSAGES and LANGUAGE
	214	std::vector<string> environment;
	215	// take care of LC_MESSAGES
	216	if (envLongIncluded == false)
	217	environment.push_back(envLong);
	218	environment.push_back(envShort);
	219	// take care of LANGUAGE
a100bb98 MV	220	const char *language_env = getenv("LANGUAGE") == 0 ? "" : getenv("LANGUAGE");
a100bb98 MV	221	string envLang = Locale == 0 ? language_env : *(Locale+1);
d7cf5923 DK	222	if (envLang.empty() == false) {
	223	std::vector<string> env = ExplodeString(envLang,':');
	224	short addedLangs = 0; // add a maximum of 3 fallbacks from the environment
	225	for (std::vector<string>::const_iterator e = env.begin();
	226	e != env.end() && addedLangs < 3; ++e) {
	227	if (unlikely(e->empty() == true) \|\| *e == "en")
	228	continue;
	229	if (e == envLong \|\| e == envShort)
	230	continue;
	231	if (std::find(environment.begin(), environment.end(), *e) != environment.end())
	232	continue;
	233	if (e->find('_') != string::npos) {
	234	// Drop LongCodes here - ShortCodes are also included
	235	string const shorty = e->substr(0, e->find('_'));
	236	char const **n = needLong;
	237	for (; *n != NULL; ++n)
	238	if (shorty == *n)
	239	break;
	240	if (*n == NULL)
	241	continue;
	242	}
	243	++addedLangs;
	244	environment.push_back(*e);
	245	}
	246	}
	247
45df0ad2 DK	248	// Support settings like Acquire::Translation=none on the command line to
	249	// override the configuration settings vector of languages.
	250	string const forceLang = _config->Find("Acquire::Languages","");
	251	if (forceLang.empty() == false) {
	252	if (forceLang == "environment") {
d7cf5923	253	codes = environment;
45df0ad2 DK	254	} else if (forceLang != "none")
45df0ad2 DK	255	codes.push_back(forceLang);
d7cf5923	256	allCodes = codes;
3f2d77b5 DK	257	for (std::vector<string>::const_iterator b = builtin.begin();
	258	b != builtin.end(); ++b)
	259	if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
	260	allCodes.push_back(*b);
	261	if (All == true)
	262	return allCodes;
	263	else
	264	return codes;
45df0ad2 DK	265	}
	266
	267	std::vector<string> const lang = _config->FindVector("Acquire::Languages");
	268	// the default setting -> "environment, en"
	269	if (lang.empty() == true) {
d7cf5923	270	codes = environment;
45df0ad2 DK	271	if (envShort != "en")
45df0ad2 DK	272	codes.push_back("en");
d7cf5923	273	allCodes = codes;
3f2d77b5 DK	274	for (std::vector<string>::const_iterator b = builtin.begin();
	275	b != builtin.end(); ++b)
	276	if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
	277	allCodes.push_back(*b);
	278	if (All == true)
	279	return allCodes;
	280	else
	281	return codes;
45df0ad2 DK	282	}
	283
	284	// the configs define the order, so add the environment
	285	// then needed and ensure the codes are not listed twice.
	286	bool noneSeen = false;
	287	for (std::vector<string>::const_iterator l = lang.begin();
	288	l != lang.end(); l++) {
	289	if (*l == "environment") {
d7cf5923 DK	290	for (std::vector<string>::const_iterator e = environment.begin();
	291	e != environment.end(); ++e) {
	292	if (std::find(allCodes.begin(), allCodes.end(), *e) != allCodes.end())
	293	continue;
45df0ad2	294	if (noneSeen == false)
d7cf5923 DK	295	codes.push_back(*e);
d7cf5923 DK	296	allCodes.push_back(*e);
45df0ad2 DK	297	}
	298	continue;
	299	} else if (*l == "none") {
	300	noneSeen = true;
	301	continue;
d7cf5923	302	} else if (std::find(allCodes.begin(), allCodes.end(), *l) != allCodes.end())
45df0ad2 DK	303	continue;
	304
	305	if (noneSeen == false)
	306	codes.push_back(*l);
	307	allCodes.push_back(*l);
	308	}
3f2d77b5 DK	309
	310	for (std::vector<string>::const_iterator b = builtin.begin();
	311	b != builtin.end(); ++b)
	312	if (std::find(allCodes.begin(), allCodes.end(), *b) == allCodes.end())
	313	allCodes.push_back(*b);
	314
45df0ad2 DK	315	if (All == true)
	316	return allCodes;
	317	else
	318	return codes;
	319	}
	320	/}}}/
e878aedb	321	}