Commit 1f6b1b37a97241e328455f96a50897d370f285e4 - xd

+1

-1

VERSION less more

0		#define VERSION "3.24.00"
	0	#define VERSION "3.25.00"
1	1	#define YEARS "1994-2016"

+0

-10

~~alternatives/alternatives.cc~~ less more

0		#include "alternatives.ih"
1
2		Alternatives::Alternatives()
3		:
4		d_homeDir(getHome()),
5		d_arg(configFile()),
6		d_separate(d_arg.option(0, "history-separate")),
7		d_nInHistory(0),
8		d_history(d_arg, d_homeDir)
9		{}

+10

-0

alternatives/alternatives1.cc less more

	0	#include "alternatives.ih"
	1
	2	Alternatives::Alternatives()
	3	:
	4	d_homeDir(getHome()),
	5	d_arg(configFile()),
	6	d_separate(d_arg.option(0, "history-separate")),
	7	d_nInHistory(0),
	8	d_history(d_arg, d_homeDir)
	9	{}

+0

-43

~~alternatives/alternativesdata.cc~~ less more

0		#include "alternatives.ih"
1
2		char const *Alternatives::s_merge[] =
3		{
4		"false",
5		"true"
6		};
7		char const const const Alternatives::s_mergeEnd =
8		s_triState + sizeof(s_merge) / sizeof(char *);
9
10
11		char const *Alternatives::s_triState[] =
12		{
13		"never",
14		"if-empty",
15		"always"
16		};
17
18		char const const const Alternatives::s_triStateEnd =
19		s_triState + sizeof(s_triState) / sizeof(char *);
20
21
22		char const *Alternatives::s_startAt[] =
23		{
24		"root",
25		"home",
26		};
27
28		char const const const Alternatives::s_startAtEnd =
29		s_startAt + sizeof(s_startAt) / sizeof(char *);
30
31
32		char const *Alternatives::s_dirs[] =
33		{
34		"unique",
35		"all",
36		};
37
38		char const const const Alternatives::s_dirsEnd =
39		s_dirs + sizeof(s_dirs) / sizeof(char *);
40
41
42		char Alternatives::s_defaultConfig[] = ".xdrc"; // in $HOME

+43

-0

alternatives/data.cc less more

	0	#include "alternatives.ih"
	1
	2	char const *Alternatives::s_merge[] =
	3	{
	4	"false",
	5	"true"
	6	};
	7	char const const const Alternatives::s_mergeEnd =
	8	s_triState + sizeof(s_merge) / sizeof(char *);
	9
	10
	11	char const *Alternatives::s_triState[] =
	12	{
	13	"never",
	14	"if-empty",
	15	"always"
	16	};
	17
	18	char const const const Alternatives::s_triStateEnd =
	19	s_triState + sizeof(s_triState) / sizeof(char *);
	20
	21
	22	char const *Alternatives::s_startAt[] =
	23	{
	24	"root",
	25	"home",
	26	};
	27
	28	char const const const Alternatives::s_startAtEnd =
	29	s_startAt + sizeof(s_startAt) / sizeof(char *);
	30
	31
	32	char const *Alternatives::s_dirs[] =
	33	{
	34	"unique",
	35	"all",
	36	};
	37
	38	char const const const Alternatives::s_dirsEnd =
	39	s_dirs + sizeof(s_dirs) / sizeof(char *);
	40
	41
	42	char Alternatives::s_defaultConfig[] = ".xdrc"; // in $HOME

+3

-3

alternatives/getcwd.cc less more

1	1
2	2	void Alternatives::getCwd(unique_ptr<char> *dest)
3	3	{
4		if (char *res = realpath(".", NULL))
	4	if (char *res = realpath(".", 0))
5	5	dest->reset(res);
6	6	else
7	7	{
8	8	fmsg << "Can't determine the current working dir." << endl;
9		dest->reset(new char[1]);
10		dest->get()[0] = '\0';
	9	dest->reset(new char);
	10	dest[0] = 0;
11	11	}
12	12	}
13	13

+0

-10

~~arbiter/arbiter.cc~~ less more

0		#include "arbiter.ih"
1
2		Arbiter::Arbiter(Alternatives &alternatives)
3		:
4		d_index(alternatives.size()),
5		d_alternatives(alternatives)
6		{}
7
8
9

+10

-0

arbiter/arbiter1.cc less more

	0	#include "arbiter.ih"
	1
	2	Arbiter::Arbiter(Alternatives &alternatives)
	3	:
	4	d_index(alternatives.size()),
	5	d_alternatives(alternatives)
	6	{}
	7
	8
	9

+1

-1

arguments.cc less more

0		#include "xd.ih" // program header file
	0	#include "main.ih" // program header file
1	1
2	2	namespace // the anonymous namespace can be used here
3	3	{

+19

-0

changelog less more

	0	xd (3.25.00)
	1
	2	* Initial directory specifiers 0-9 can now be used with and without
	3	separators. E.g., 'xd 0lb' and 'xd 0 lb' are equivalent.
	4
	5	* The underscore is not used as separator anymore: the man-page was updated
	6	accordingly.
	7
	8	* Renamed xd.* to main.* (synchronizing names with other projects)
	9
	10	-- Frank B. Brokken <f.b.brokken@rug.nl> Wed, 05 Oct 2016 15:06:54 +0200
	11
	12	xd (3.24.01)
	13
	14	* Applied cosmetic changes to alternatives/getcwd.c (3.24.00's changes are
	15	merged with this version).
	16
	17	-- Frank B. Brokken <f.b.brokken@rug.nl> Sun, 21 Feb 2016 14:32:19 +0100
	18
0	19	xd (3.24.00)
1	20
2	21	* The xd-support scripts that are mentioned in the man-page now allow

+0

-44

~~command/command.cc~~ less more

0		#include "command.ih"
1
2		Command::Command()
3		:
4		d_action(FROM_HOME),
5		d_parent(0)
6		{
7		concatArgs();
8
9		bool subSpecs = determineAction();
10
11		String::split(this, d_arguments, s_separators);
12
13		// When are the elements of the first argument changed into initial chars
14		// of directory elements?
15		// 1. if there is only one command line argument
16		// 2. if the first argument is not to be interpreted as a name by itself
17		// 3. if there's only one argument
18		// Can't 2 and 3 be combined to: size() == 1 ?
19		// if (!subSpecs && size() && ArgConfig::instance().nArgs() == 1)
20		if (!subSpecs && size() == 1)
21		{
22		for_each(
23		front().begin() + 1, front().end(),
24		[&](char ch)
25		{
26		this->push_back(string(1, ch));
27		}
28		);
29		front().resize(1);
30		}
31
32		if (ArgConfig::instance().option('V'))
33		{
34		cerr << "Parent nr: " << d_parent << "\n"
35		"Action: " << s_action[d_action] << "\n"
36		"Initial characters of directories: ";
37		copy(begin(), end(), ostream_iterator<string>(cerr, " "));
38		cerr << endl;
39		}
40		}
41
42
43

+1

-16

command/command.h less more

37	37
38	38	private:
39	39	void concatArgs();
40		// inline static void catArg(char const *arg, std::string &dest);
41
42		bool determineAction();
43
44		// inline static void add(char ch, std::vector<std::string> &cmd);
	40	void determineAction();
45	41	};
46	42
47	43	inline size_t Command::parent() const

54	50	return d_action;
55	51	}
56	52
57		//void Command::catArg(char const *arg, std::string &dest)
58		//{
59		// dest += arg;
60		// dest += '/';
61		//}
62
63		//void Command::add(char ch, std::vector<std::string> &cmd)
64		//{
65		// cmd.push_back(std::string(1, ch));
66		//}
67
68	53	inline std::string const &Command::accumulate() const
69	54	{
70	55	return d_arguments;

+1

-0

command/command.ih less more

5	5
6	6	#include <bobcat/argconfig>
7	7	#include <bobcat/string>
	8	#include <bobcat/mstream>
8	9
9	10	using namespace std;
10	11	using namespace FBB;

+45

-0

command/command1.cc less more

	0	#include "command.ih"
	1
	2	Command::Command()
	3	:
	4	d_action(FROM_HOME),
	5	d_parent(0)
	6	{
	7	concatArgs();
	8
	9	determineAction();
	10
	11	String::split(this, d_arguments, s_separators);
	12
	13	// When are the elements of the first argument changed into initial chars
	14	// of directory elements?
	15	// 1. if there is only one command line argument
	16	// 2. if the first argument is not to be interpreted as a name by itself
	17	// 3. if there's only one argument
	18	// Can't 2 and 3 be combined to: size() == 1 ?
	19	// if (!subSpecs && size() && ArgConfig::instance().nArgs() == 1)
	20
	21	if (size() == 1)
	22	{
	23	for_each(
	24	front().begin() + 1, front().end(),
	25	[&](char ch)
	26	{
	27	this->push_back(string(1, ch));
	28	}
	29	);
	30	front().resize(1);
	31	}
	32
	33	if (ArgConfig::instance().option('V'))
	34	{
	35	cerr << "Parent nr: " << d_parent << "\n"
	36	"Action: " << s_action[d_action] << "\n"
	37	"Initial characters of directories: ";
	38	copy(begin(), end(), ostream_iterator<string>(cerr, " "));
	39	cerr << endl;
	40	}
	41	}
	42
	43
	44

+0

-13

~~command/commanddata.cc~~ less more

0		#include "command.ih"
1
2		char const *Command::s_action[] =
3		{
4		"FROM_CONFIG",
5		"FROM_HOME",
6		"FROM_ROOT",
7		"FROM_CWD",
8		"FROM_PARENT"
9		};
10
11		// separating parts of directory names:
12		char const Command::s_separators[] = "/_"; ⏎

+2

-0

command/concatargs.cc less more

10	10	(d_arguments += arg) += '/';
11	11	}
12	12	);
	13
	14	imsg << "Arguments: `" << d_arguments << '\'' << endl;
13	15	}

+13

-0

command/data.cc less more

	0	#include "command.ih"
	1
	2	char const *Command::s_action[] =
	3	{
	4	"FROM_CONFIG",
	5	"FROM_HOME",
	6	"FROM_ROOT",
	7	"FROM_CWD",
	8	"FROM_PARENT"
	9	};
	10
	11	// separating parts of directory names:
	12	char const Command::s_separators[] = "/";

+16

-19

command/determineaction.cc less more

0	0	#include "command.ih"
1	1
2		bool Command::determineAction()
	2	void Command::determineAction()
3	3	{
4	4	switch (int ch = d_arguments[0]) // Interpret the first character
5	5	{

16	16	break; // breaks remove the 1st char from args
17	17
18	18	// start from a parent
19		case '1':
20		case '2':
21		case '3':
22		case '4':
23		case '5':
24		case '6':
25		case '7':
26		case '8':
27		case '9':
	19	case '1' ... '9':
28	20	d_parent = ch - '0';
29	21	d_action = FROM_PARENT;
30	22	break;
31	23
32		// other characters: 1st letter of directory
	24	// other characters: 1st char. of directory
33	25	default:
34		{
35		bool firstIsSeparator = (ch == '_');
36		if (firstIsSeparator)
37		d_arguments.erase(0, 1); // remove the 1st char
	26	// {
	27	// bool firstIsSeparator = (ch == '_');
	28	// if (firstIsSeparator)
	29	// d_arguments.erase(0, 1); // remove the 1st char
38	30	d_action = FROM_CONFIG;
39		return firstIsSeparator;
40		}
	31	return;
	32	// return firstIsSeparator;
	33	// }
41	34	}
42	35
43		d_arguments.erase(0, 1); // remove the 1st (location) character
44		return false;
	36	do
	37	d_arguments.erase(0, 1); // remove the 1st (location) character
	38	while (d_arguments.front() == '/'); // and a possible initial / sep.
	39
	40	imsg << "Removed the location character: `" <<
	41	d_arguments << '\'' << endl;
45	42	}

+15

-12

documentation/man/xd.yo less more

88	88	tt(xd 2lb) will offer the alterative tt(/usr/local/bin): two steps up, then
89	89	look for directories starting with tt(l) and therein directories starting with
90	90	tt(b).
91		it() Separators (space, forward slash and underscore (tt( ), / and _)):
	91	it() Separators (space, and the forward slash (tt( ), and /)):
92	92	sometimes it is clear that there are many alternatives and the intention is to
93		reduce that number. By using a separator subsequently nested directories must
94		start with the characters between the separators. E.g., tt(xd u l bi) will not
95		produce the alternative tt(/usr/lib/base-config) anymore, since
	93	reduce that number. By using separators subsequently nested directories must
	94	start with the characters between the separators. E.g., tt(xd u l bi) never
	95	produces the alternative tt(/usr/lib/base-config) anymore, since
96	96	tt(base-config) does not start with tt(bi). In this case only
97		tt(/usr/local/bin) is produced. Separators may be mixed (tt(xd u/l bi) is
98		identical to tt(xd u l bi)). Since the tt(/) can also be used as a
99		root-directory specification, a conflict is implied by a command like tt(xd /u
100		l bi). This conflict is solved by given the initial character a higher
101		precedence than the separator. Using the underscore (_) separator in this case
102		is another way to solve the conflict (which in practice hardly ever occurs).
103		)
104
	97	tt(/usr/local/bin) is produced. When used as initial character in a pattern
	98	the forward slash always indicates the root-directory.
	99	COMMENT(
	100	Separators may be mixed (tt(xd u/l bi) is identical to tt(xd u l
	101	bi)). Since the tt(/) can also be used as a root-directory specification,
	102	a conflict is implied by a command like tt(xd /u l bi). This conflict is
	103	solved by given the initial character a higher precedence than the
	104	separator. Using the underscore (_) separator in this case is another way
	105	to solve the conflict (which in practice hardly ever occurs).
	106	END)
	107	)
105	108	If there's only one solution, bf(Xd) writes that directory to its standard
106	109	output stream. If there are multiple solutions, then a list of at most 62
107	110	alternatives (10 for the numbers 0..9, 26 for the letters a..z and 26 for the

+3

-0

history/data.cc less more

	0	#include "history.ih"
	1
	2	char History::s_defaultHistory[] = ".xd.his"; // in $HOME

+0

-3

~~history/historydata.cc~~ less more

0		#include "history.ih"
1
2		char History::s_defaultHistory[] = ".xd.his"; // in $HOME

+5

-12

icmconf less more

0	0	#include "INSTALL.im"
1		#define MAIN "xd.cc"
	1	#define MAIN "main.cc"
2	2	#define ADD_LIBRARIES "bobcat"
3	3	#define ADD_LIBRARY_PATHS ""
4	4	#define REFRESH
5	5	#define LIBRARY "modules"
6	6	#define SHAREDREQ ""
	7	#define IH ".ih"
	8	#define PRECOMP "-x c++-header"
7	9	//#define CLS
8	10	//#define USE_ALL "a"
9	11	#define SOURCES "*.cc"
10		#define SCANNER_DIR ""
11		#define SCANGEN ""
12		#define SCANFLAGS ""
13		#define SCANSPEC ""
14		#define SCANOUT ""
15		#define PARSER_DIR ""
16		#define PARSGEN ""
17		#define PARSFLAGS ""
18		#define PARSSPEC ""
19		#define PARSFILES ""
20		#define PARSOUT ""
21	12	#define USE_ECHO ON
22	13	#define TMP_DIR "tmp"
23	14	#define OBJ_EXT ".o"
24	15	#define USE_VERSION
	16
	17	#define DEFCOM "program"

+40

-0

main.cc less more

	0	/* xd.cc
	1
	2	A C++ main()-frame generated by cpp.im for xd.cc
	3	*/
	4
	5	#include "main.ih" // program header file
	6
	7	int main(int argc, char **argv)
	8	try
	9	{
	10	arguments(argc, argv);
	11
	12	Alternatives alternatives;
	13	alternatives.viable(); // select viable alternatives
	14	alternatives.order(); // history alternatives first or last
	15
	16	Arbiter arbiter(alternatives);
	17
	18	arbiter.select(); // make the selection
	19
	20	return arbiter.decided() ? 0 : 1; // return 0 to the OS if the arbiter
	21	// did do its work
	22	}
	23	catch(exception const &err) // handle exceptions
	24	{
	25	cerr << err.what() << endl;
	26	cout << ".\n"; // to prevent a directory change
	27	return 1;
	28	}
	29	catch(int x)
	30	{
	31	if (x == 0)
	32	cerr << "No Solutions\n";
	33
	34	if (ArgConfig::instance().option("hv"))
	35	return 0;
	36
	37	cout << ".\n";
	38	return x;
	39	}

+23

-0

main.ih less more

	0	#include <iostream>
	1	#include <string>
	2	#include <cstring>
	3	#include <exception>
	4
	5	#include <bobcat/argconfig>
	6	#include <bobcat/mstream>
	7
	8	#include "alternatives/alternatives.h"
	9	#include "arbiter/arbiter.h"
	10
	11	namespace Icmbuild
	12	{
	13	extern char version[];
	14	extern char year[];
	15	extern char author[];
	16	};
	17
	18	void arguments(int argc, char **argv);
	19	void usage(std::string const &progname);
	20
	21	using namespace std;
	22	using namespace FBB;

+1

-1

usage.cc less more

0	0	// usage.cc
1	1
2		#include "xd.ih"
	2	#include "main.ih"
3	3
4	4	void usage(std::string const &progname)
5	5	{

+1

-1

version.cc less more

0	0	// version.cc
1	1
2		#include "xd.ih"
	2	#include "main.ih"
3	3
4	4	#include "VERSION"
5	5

+0

-40

~~xd.cc~~ less more

0		/* xd.cc
1
2		A C++ main()-frame generated by cpp.im for xd.cc
3		*/
4
5		#include "xd.ih" // program header file
6
7		int main(int argc, char **argv)
8		try
9		{
10		arguments(argc, argv);
11
12		Alternatives alternatives;
13		alternatives.viable(); // select viable alternatives
14		alternatives.order(); // history alternatives first or last
15
16		Arbiter arbiter(alternatives);
17
18		arbiter.select(); // make the selection
19
20		return arbiter.decided() ? 0 : 1; // return 0 to the OS if the arbiter
21		// did do its work
22		}
23		catch(exception const &err) // handle exceptions
24		{
25		cerr << err.what() << endl;
26		cout << ".\n"; // to prevent a directory change
27		return 1;
28		}
29		catch(int x)
30		{
31		if (x == 0)
32		cerr << "No Solutions\n";
33
34		if (ArgConfig::instance().option("hv"))
35		return 0;
36
37		cout << ".\n";
38		return x;
39		}

+0

-23

~~xd.ih~~ less more

0		#include <iostream>
1		#include <string>
2		#include <cstring>
3		#include <exception>
4
5		#include <bobcat/argconfig>
6		#include <bobcat/mstream>
7
8		#include "alternatives/alternatives.h"
9		#include "arbiter/arbiter.h"
10
11		namespace Icmbuild
12		{
13		extern char version[];
14		extern char year[];
15		extern char author[];
16		};
17
18		void arguments(int argc, char **argv);
19		void usage(std::string const &progname);
20
21		using namespace std;
22		using namespace FBB;

+39

-39

xd.xref less more

0	0	oxref by Frank B. Brokken (f.b.brokken@rug.nl)
1		oxref V1.00.02 2012-2015
2
3		CREATED Fri, 02 Oct 2015 11:31:29 +0000
	1	oxref V1.00.06 2012-2015
	2
	3	CREATED Wed, 05 Oct 2016 12:51:59 +0000
4	4	CROSS REFERENCE FOR: -fxs tmp/libmodules.a
5	5	----------------------------------------------------------------------
6	6

22	22	Used By:
23	23	usage.cc: usage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)
24	24
25		checkCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int*) const
26		Full name: Alternatives::checkCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int*) const
	25	checkCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long*) const
	26	Full name: Alternatives::checkCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long*) const
27	27	Source: checkcase.cc
28	28	Used By:
29		globpattern.cc: Alternatives::globPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int*, Alternatives::GlobContext&)
	29	globpattern.cc: Alternatives::globPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long*, Alternatives::GlobContext&)
30	30
31	31	Command()
32	32	Full name: Command::Command()
33		Source: command.cc
34		Used By:
35		alternatives.cc: Alternatives::Alternatives()
	33	Source: command1.cc
	34	Used By:
	35	alternatives1.cc: Alternatives::Alternatives()
36	36
37	37	compareTimes(History::HistoryInfo const&, History::HistoryInfo const&)
38	38	Full name: History::compareTimes(History::HistoryInfo const&, History::HistoryInfo const&)

44	44	Full name: Command::concatArgs()
45	45	Source: concatargs.cc
46	46	Used By:
47		command.cc: Command::Command()
	47	command1.cc: Command::Command()
48	48
49	49	configFile()
50	50	Full name: Alternatives::configFile()
51	51	Source: configfile.cc
52	52	Used By:
53		alternatives.cc: Alternatives::Alternatives()
	53	alternatives1.cc: Alternatives::Alternatives()
54	54
55	55	cxx11]()
56	56	Full name: Alternatives::getHome[abi:cxx11]()
57	57	Source: gethome.cc
58	58	Used By:
59		alternatives.cc: Alternatives::Alternatives()
	59	alternatives1.cc: Alternatives::Alternatives()
60	60
61	61	cxx11]()
62	62	Full name: Alternatives::determineInitialDirectory[abi:cxx11]()

68	68	Full name: Command::determineAction()
69	69	Source: determineaction.cc
70	70	Used By:
71		command.cc: Command::Command()
	71	command1.cc: Command::Command()
72	72
73	73	generalizedGlob(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, Alternatives::GlobContext&)
74	74	Full name: Alternatives::generalizedGlob(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, Alternatives::GlobContext&)

93	93	Source: globfilter.cc
94	94	Used By:
95	95	glob.cc: Alternatives::glob(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, Alternatives::GlobContext&)
96		globpattern.cc: Alternatives::globPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int*, Alternatives::GlobContext&)
	96	globpattern.cc: Alternatives::globPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long*, Alternatives::GlobContext&)
97	97
98	98	globFrom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)
99	99	Full name: Alternatives::globFrom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

106	106	Source: globhead.cc
107	107	Used By:
108	108	generalizedglob.cc: Alternatives::generalizedGlob(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, Alternatives::GlobContext&)
109		globpattern.cc: Alternatives::globPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int*, Alternatives::GlobContext&)
110
111		globPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int*, Alternatives::GlobContext&)
112		Full name: Alternatives::globPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int*, Alternatives::GlobContext&)
	109	globpattern.cc: Alternatives::globPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long*, Alternatives::GlobContext&)
	110
	111	globPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long*, Alternatives::GlobContext&)
	112	Full name: Alternatives::globPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned long*, Alternatives::GlobContext&)
113	113	Source: globpattern.cc
114	114	Used By:
115	115	globhead.cc: Alternatives::globHead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, Alternatives::GlobContext&)

118	118	Full name: History::History(FBB::ArgConfig&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)
119	119	Source: history1.cc
120	120	Used By:
121		alternatives.cc: Alternatives::Alternatives()
	121	alternatives1.cc: Alternatives::Alternatives()
122	122
123	123	load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)
124	124	Full name: History::load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)

132	132	Used By:
133	133	globfilter.cc: Alternatives::globFilter(char const*, Alternatives::GlobContext&)
134	134
135		maybeInsert(History::HistoryInfo const&, std::vector<History::HistoryInfo, std::allocator<History::HistoryInfo> >&, unsigned int)
136		Full name: History::maybeInsert(History::HistoryInfo const&, std::vector<History::HistoryInfo, std::allocator<History::HistoryInfo> >&, unsigned int)
	135	maybeInsert(History::HistoryInfo const&, std::vector<History::HistoryInfo, std::allocator<History::HistoryInfo> >&, unsigned long)
	136	Full name: History::maybeInsert(History::HistoryInfo const&, std::vector<History::HistoryInfo, std::allocator<History::HistoryInfo> >&, unsigned long)
137	137	Source: maybeinsert.cc
138	138	Used By:
139	139	load.cc: History::load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)

146	146
147	147	s_action
148	148	Full name: Command::s_action
149		Source: commanddata.cc
150		Used By:
151		command.cc: Command::Command()
	149	Source: data.cc
	150	Used By:
	151	command1.cc: Command::Command()
152	152
153	153	s_defaultConfig
154	154	Full name: Alternatives::s_defaultConfig
155		Source: alternativesdata.cc
	155	Source: data.cc
156	156	Used By:
157	157	configfile.cc: Alternatives::configFile()
158	158
159	159	s_defaultHistory
160	160	Full name: History::s_defaultHistory
161		Source: historydata.cc
	161	Source: data.cc
162	162	Used By:
163	163	load.cc: History::load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)
164	164
165	165	s_dirs
166	166	Full name: Alternatives::s_dirs
167		Source: alternativesdata.cc
	167	Source: data.cc
168	168	Used By:
169	169	viable.cc: Alternatives::viable()
170	170
171	171	s_dirsEnd
172	172	Full name: Alternatives::s_dirsEnd
173		Source: alternativesdata.cc
	173	Source: data.cc
174	174	Used By:
175	175	viable.cc: Alternatives::viable()
176	176
177	177	s_separators
178	178	Full name: Command::s_separators
179		Source: commanddata.cc
180		Used By:
181		command.cc: Command::Command()
	179	Source: data.cc
	180	Used By:
	181	command1.cc: Command::Command()
182	182
183	183	s_startAt
184	184	Full name: Alternatives::s_startAt
185		Source: alternativesdata.cc
	185	Source: data.cc
186	186	Used By:
187	187	viable.cc: Alternatives::viable()
188	188
189	189	s_startAtEnd
190	190	Full name: Alternatives::s_startAtEnd
191		Source: alternativesdata.cc
	191	Source: data.cc
192	192	Used By:
193	193	viable.cc: Alternatives::viable()
194	194
195	195	s_triState
196	196	Full name: Alternatives::s_triState
197		Source: alternativesdata.cc
	197	Source: data.cc
198	198	Used By:
199	199	viable.cc: Alternatives::viable()
200	200
201	201	s_triStateEnd
202	202	Full name: Alternatives::s_triStateEnd
203		Source: alternativesdata.cc
	203	Source: data.cc
204	204	Used By:
205	205	viable.cc: Alternatives::viable()
206	206

216	216	Used By:
217	217	showalternatives.cc: Arbiter::showAlternatives() const
218	218
219		set(char const, char const const, char const const*, unsigned int)
220		Full name: Alternatives::set(char const, char const const, char const const*, unsigned int)
	219	set(char const, char const const, char const const*, unsigned long)
	220	Full name: Alternatives::set(char const, char const const, char const const*, unsigned long)
221	221	Source: set2.cc
222	222	Used By:
223	223	viable.cc: Alternatives::viable()

234	234	Used By:
235	235	select.cc: Arbiter::select()
236	236
237		show(unsigned int, char, char, unsigned int) const
238		Full name: Arbiter::show(unsigned int, char, char, unsigned int) const
	237	show(unsigned long, char, char, unsigned long) const
	238	Full name: Arbiter::show(unsigned long, char, char, unsigned long) const
239	239	Source: show.cc
240	240	Used By:
241	241	showalternatives.cc: Arbiter::showAlternatives() const