223 lines
4.9 KiB
C
223 lines
4.9 KiB
C
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <errno.h>
|
|
#include <getopt.h>
|
|
|
|
#include <debug.h>
|
|
|
|
#include <memory/smalloc.h>
|
|
|
|
#include <gc/defines/GARBAGE_COLLECTION_MINIMUM.h>
|
|
#include <gc/defines/GARBAGE_COLLECTION_RUN_EVERY.h>
|
|
#include <gc/defines/GARBAGE_COLLECTION_PROCESS_LIMIT.h>
|
|
|
|
#include "struct.h"
|
|
#include "process.h"
|
|
|
|
struct cmdln_flags* process_cmdln_flags(
|
|
int argc,
|
|
char* const* argv)
|
|
{
|
|
ENTER;
|
|
|
|
struct gc_flags gc_flags = {
|
|
.minimum = GARBAGE_COLLECTION_MINIMUM,
|
|
.run_every = GARBAGE_COLLECTION_RUN_EVERY,
|
|
.process_limit = GARBAGE_COLLECTION_PROCESS_LIMIT,
|
|
.dotout = false,
|
|
};
|
|
|
|
bool verbose = false;
|
|
|
|
bool macro_expansion_dotout = false;
|
|
|
|
bool evaluation_dotout = false;
|
|
|
|
static const struct option long_options[] = {
|
|
{"garbage-collection-minimum", required_argument, 0, 1},
|
|
{"garbage-collection-run-every", required_argument, 0, 2},
|
|
{"garbage-collection-process-limit", required_argument, 0, 3},
|
|
{"garbage-collection-dotout", required_argument, 0, 4},
|
|
|
|
{"macro-expansion-dotout", required_argument, 0, 5},
|
|
|
|
{"evaluation-dotout", required_argument, 0, 6},
|
|
|
|
{"verbose", no_argument, 0, 'v'},
|
|
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
for (int c; (c = getopt_long(argc, argv, ""
|
|
"\1\2\3\4\5\6"
|
|
"v"
|
|
"", long_options, NULL)) >= 0; )
|
|
{
|
|
switch (c)
|
|
{
|
|
size_t parse_size(const char* opt)
|
|
{
|
|
ENTER;
|
|
|
|
dpvs(opt);
|
|
|
|
errno = 0;
|
|
|
|
char* m;
|
|
|
|
unsigned long val = strtoul(opt, &m, 10);
|
|
|
|
if (errno)
|
|
{
|
|
TODO;
|
|
}
|
|
|
|
switch (*m)
|
|
{
|
|
case 'B':
|
|
break;
|
|
|
|
case 'K':
|
|
TODO;
|
|
break;
|
|
|
|
case 'M':
|
|
TODO;
|
|
break;
|
|
|
|
case 'G':
|
|
TODO;
|
|
break;
|
|
|
|
default:
|
|
TODO;
|
|
break;
|
|
}
|
|
|
|
dpvlu(val);
|
|
|
|
EXIT;
|
|
return val;
|
|
}
|
|
|
|
case 1: // --garbage-collection-minimum
|
|
{
|
|
size_t size = parse_size(optarg);
|
|
|
|
gc_flags.minimum = size;
|
|
|
|
dpvlu(gc_flags.minimum);
|
|
|
|
break;
|
|
}
|
|
|
|
case 2: // --garbage-collection-run-every
|
|
{
|
|
size_t size = parse_size(optarg);
|
|
|
|
gc_flags.run_every = size;
|
|
|
|
dpvlu(gc_flags.run_every);
|
|
|
|
break;
|
|
}
|
|
|
|
case 3: // --garbage-collection-process-limit
|
|
{
|
|
size_t size = parse_size(optarg);
|
|
|
|
gc_flags.process_limit = size;
|
|
|
|
dpvlu(gc_flags.process_limit);
|
|
|
|
break;
|
|
}
|
|
|
|
case 4: // --garbage-collection-dotout
|
|
{
|
|
gc_flags.dotout = true;
|
|
|
|
dpvb(gc_flags.dotout);
|
|
|
|
break;
|
|
}
|
|
|
|
case 5: // --macro-expansion-dotout
|
|
{
|
|
macro_expansion_dotout = true;
|
|
|
|
dpvb(macro_expansion_dotout);
|
|
|
|
break;
|
|
}
|
|
|
|
case 6: // --evaluation-dotout
|
|
{
|
|
evaluation_dotout = true;
|
|
|
|
dpvb(evaluation_dotout);
|
|
|
|
break;
|
|
}
|
|
|
|
case 'v':
|
|
{
|
|
verbose = true;
|
|
|
|
dpvb(verbose);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
TODO;
|
|
exit(1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (gc_flags.process_limit < gc_flags.run_every)
|
|
{
|
|
TODO;
|
|
}
|
|
|
|
struct cmdln_flags* flags = smalloc(sizeof(*flags));
|
|
|
|
flags->gc_flags = gc_flags;
|
|
|
|
flags->macro_expansion_dotout = macro_expansion_dotout;
|
|
|
|
flags->evaluation_dotout = evaluation_dotout;
|
|
|
|
flags->verbose = verbose;
|
|
|
|
flags->input_file = argv[optind++];
|
|
|
|
flags->argv = &argv[optind++];
|
|
|
|
if (!flags->input_file)
|
|
{
|
|
TODO;
|
|
}
|
|
|
|
EXIT;
|
|
return flags;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|