mirror of
https://github.com/Zygo/bees.git
synced 2025-05-17 21:35:45 +02:00
89 lines
2.4 KiB
C++
89 lines
2.4 KiB
C++
#include "tests.h"
|
|
|
|
#include "crucible/interp.h"
|
|
|
|
using namespace crucible;
|
|
using namespace std;
|
|
|
|
/***********************************************************************
|
|
|
|
How this should work:
|
|
|
|
Interpreter reads an arg list:
|
|
|
|
argv[0] --method0args --method1arg arg1 --method1arg=arg1 -- args...
|
|
|
|
argv[0] should look up a shared_ptr<Command> which creates an object of
|
|
type shared_ptr<Process>. This object is used to receive args by
|
|
method calls or one at a time.
|
|
|
|
<Command> and <Process> can be the same object, or not.
|
|
|
|
Process p methods:
|
|
|
|
p->spawn(Interp*) -> Process
|
|
p->exec(ArgList) -> Process / Result
|
|
p->method (from ArgParser<>)
|
|
p->finish() -> void (destroys object without early destruction warnings...?)
|
|
p->~Process() -> complains loudly if finish() not called first...?
|
|
|
|
Result might be a pair of Process, string. Or just string.
|
|
|
|
ArgParser should be more like GetOpt:
|
|
|
|
build a dictionary and an arg list from arguments
|
|
Process methods should interrogate ArgParser
|
|
ArgParser might have a table of boolean and string option names so it can reject invalid options
|
|
but if it had that, we could also pass in Process and have it call methods on it
|
|
...but that is a _lot_ of pointer-hiding when we could KISS
|
|
...but if we had that solved, argparser tables look like lists of method names
|
|
ArgParser<T> has a table of names and methods on object of type T
|
|
ArgParser hides everything behind void* and hands off to a compiled implementation to do callbacks
|
|
|
|
Extreme simplification: arguments are themselves executable
|
|
|
|
so '--method_foo arg' really means construct MethodFoo(arg) and cast to shared_ptr<ProcArg>
|
|
then Process->invokeSomething(ProcArg)
|
|
too extreme, use argparser instead
|
|
|
|
***********************************************************************/
|
|
|
|
void
|
|
test_arg_parser()
|
|
{
|
|
ArgParser ap;
|
|
ArgList al( { "abc", "--def", "ghi" } );
|
|
ap.parse(NULL, al);
|
|
}
|
|
|
|
struct Thing {
|
|
int m_i;
|
|
double m_d;
|
|
string m_s;
|
|
|
|
void set_i(int i) { cerr << "i = " << i << endl; m_i = i; }
|
|
void set_d(double d) { cerr << "d = " << d << endl; m_d = d; }
|
|
void set_s(string s) { cerr << "s = " << s << endl; m_s = s; }
|
|
};
|
|
|
|
template <typename F, typename T, typename A>
|
|
void
|
|
assign(T& t, F f, A a)
|
|
{
|
|
cerr << __PRETTY_FUNCTION__ << " - a = " << a << endl;
|
|
(t.*f)(a);
|
|
}
|
|
|
|
int
|
|
main(int, char**)
|
|
{
|
|
RUN_A_TEST(test_arg_parser());
|
|
|
|
Thing p;
|
|
assign(p, &Thing::set_i, 5);
|
|
|
|
cerr << "p.m_i = " << p.m_i << endl;
|
|
|
|
exit(EXIT_SUCCESS);
|
|
}
|