void run_char_rnn(int argc, char **argv)
{
if(argc < 4){
fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]);
return;
}
char *filename = find_char_arg(argc, argv, "-file", "data/shakespeare.txt");
char *seed = find_char_arg(argc, argv, "-seed", "\n\n");
int len = find_int_arg(argc, argv, "-len", 1000);
float temp = find_float_arg(argc, argv, "-temp", .7);
int rseed = find_int_arg(argc, argv, "-srand", time(0));
int clear = find_arg(argc, argv, "-clear");
int tokenized = find_arg(argc, argv, "-tokenized");
char *tokens = find_char_arg(argc, argv, "-tokens", 0);
char *cfg = argv[3];
char *weights = (argc > 4) ? argv[4] : 0;
if(0==strcmp(argv[2], "train")) train_char_rnn(cfg, weights, filename, clear, tokenized);
else if(0==strcmp(argv[2], "valid")) valid_char_rnn(cfg, weights, seed);
else if(0==strcmp(argv[2], "validtactic")) valid_tactic_rnn(cfg, weights, seed);
else if(0==strcmp(argv[2], "vec")) vec_char_rnn(cfg, weights, seed);
else if(0==strcmp(argv[2], "generate")) test_char_rnn(cfg, weights, len, seed, temp, rseed, tokens);
else if(0==strcmp(argv[2], "generatetactic")) test_tactic_rnn(cfg, weights, len, temp, rseed, tokens);
}
main(int argc, char *argv[]) {
int x;
char optarray[256];
//char outarray[256][256];
char *argument;
char *argument2;
argus *arglist;
argument = calloc(256,1);
argument2 = calloc(256,1);
//memset(argument,0,256);
//memset(argument2,0,256);
memset(optarray,0,sizeof(optarray)); /* This is important! */
arglist = calloc(1,sizeof(arglist));
/* myopt takes an array of letters with :'s following if it*/
/* requires a parameter */
/* vvvvvvvvvvvvvvvvvvvvvvvvv*/
strcpy(optarray,"k:f:x:pac:w:");
printf("%s\n",optarray);
myopt(optarray,argc,argv,arglist);
/* Lets make find_arg find the parameter for an option letter */
/* that we specify on the command line.*/
/* ie "./clo -w x -x Stuff" will stick Stuff in argument2 */
argument = find_arg(arglist,'w');
/* Is this the best way to check for required options? */
if (argument == NULL) {
printf("w not found\n");
exit(0);
}
printf("argument = %s\n",argument);
argument2 = find_arg(arglist,argument[0]);
printf("argument2 = %s\n",argument2);
return 0;
}
int standard_args(int argc, char **argv)
{
if (find_arg("--version", argc, argv) > 0 ||
find_arg("-version", argc, argv) > 0) return version();
if (find_arg("--formats", argc, argv) > 0 ||
find_arg("-formats", argc, argv) > 0) return formats();
if (find_arg("--types", argc, argv) > 0 ||
find_arg("-types", argc, argv) > 0) return types();
return -1;
}
int main(int argc, char **argv)
{
//test_resize("data/bad.jpg");
//test_box();
//test_convolutional_layer();
if(argc < 2){
fprintf(stderr, "usage: %s <function>\n", argv[0]);
return 0;
}
gpu_index = find_int_arg(argc, argv, "-i", 0);
if(find_arg(argc, argv, "-nogpu")) gpu_index = -1;
#ifndef GPU
gpu_index = -1;
#else
if(gpu_index >= 0){
cudaSetDevice(gpu_index);
}
#endif
if(0==strcmp(argv[1], "imagenet")){
run_imagenet(argc, argv);
} else if (0 == strcmp(argv[1], "detection")){
run_detection(argc, argv);
} else if (0 == strcmp(argv[1], "writing")){
run_writing(argc, argv);
} else if (0 == strcmp(argv[1], "test")){
test_resize(argv[2]);
} else if (0 == strcmp(argv[1], "captcha")){
run_captcha(argc, argv);
} else if (0 == strcmp(argv[1], "nightmare")){
run_nightmare(argc, argv);
} else if (0 == strcmp(argv[1], "change")){
change_rate(argv[2], atof(argv[3]), (argc > 4) ? atof(argv[4]) : 0);
} else if (0 == strcmp(argv[1], "rgbgr")){
rgbgr_net(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "partial")){
partial(argv[2], argv[3], argv[4], atoi(argv[5]));
} else if (0 == strcmp(argv[1], "visualize")){
visualize(argv[2], (argc > 3) ? argv[3] : 0);
} else if (0 == strcmp(argv[1], "imtest")){
test_resize(argv[2]);
} else {
fprintf(stderr, "Not an option: %s\n", argv[1]);
}
return 0;
}
int main(int argc, char **argv)
{
char *outtyp;
char *outcomp;
int forcehead;
int n, err;
if (argc < 2) return help(argc, argv);
ignore_arg("-itype", 2, &argc, argv);
ignore_arg("-iside", 2, &argc, argv);
ignore_arg("-icomp", 2, &argc, argv);
ignore_arg("-otype", 2, &argc, argv);
ignore_arg("-oside", 2, &argc, argv);
ignore_arg("-ocomp", 2, &argc, argv);
outtyp = check_type("-type", &argc, argv);
outcomp = check_type("-comp", &argc, argv);
forcehead = check_forcehead("-side", &argc, argv);
retries = check_retry("-retry", &argc, argv);
format = check_format("-format", &argc, argv);
if (find_arg("--help", argc, argv) > 0) return help(argc, argv);
if (find_arg("--version", argc, argv) > 0) return version();
if ((n = find_arg("--pcdos", argc, argv) > 0))
{
md = FORCE_PCDOS;
excise_arg(n, &argc, argv);
}
if ((n = find_arg("-pcdos", argc, argv) > 0))
{
md = FORCE_PCDOS;
excise_arg(n, &argc, argv);
}
if ((n = find_arg("--apricot", argc, argv) > 0))
{
md = FORCE_APRICOT;
excise_arg(n, &argc, argv);
}
if ((n = find_arg("-apricot", argc, argv) > 0))
{
md = FORCE_APRICOT;
excise_arg(n, &argc, argv);
}
args_complete(&argc, argv);
err = 0;
for (n = 1; n < argc; n++)
{
if (do_swapboot(argc, argv[n], outtyp, outcomp, forcehead))
++err;
}
return err;
}
int ignore_arg(char *arg, int count, int *argc, char **argv)
{
int n = find_arg(arg, *argc, argv);
if (n < 0) return 0;
fprintf(stderr, "Warning: option '");
while (count)
{
fprintf(stderr, "%s ", argv[n]);
excise_arg(n, argc, argv);
--count;
if (n >= *argc) break;
}
fprintf(stderr, "\b' ignored.\n");
return 1;
}
void run_tag(int argc, char **argv) {
if (argc < 4) {
fprintf(stderr,
"usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n",
argv[0], argv[1]);
return;
}
int clear = find_arg(argc, argv, "-clear");
char *cfg = argv[3];
char *weights = (argc > 4) ? argv[4] : 0;
char *filename = (argc > 5) ? argv[5] : 0;
if (0 == strcmp(argv[2], "train"))
train_tag(cfg, weights, clear);
else if (0 == strcmp(argv[2], "test"))
test_tag(cfg, weights, filename);
}
bool dot_bvfs_clear_cache_cmd(UAContext *ua, const char *cmd)
{
if (!open_client_db(ua, true)) {
return 1;
}
int pos = find_arg(ua, "yes");
if (pos != -1) {
Bvfs fs(ua->jcr, ua->db);
fs.clear_cache();
ua->info_msg("OK\n");
} else {
ua->error_msg("Can't find 'yes' argument\n");
}
return true;
}
void run_regressor(int argc, char **argv) {
if (argc < 4) {
fprintf(stderr,
"usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n",
argv[0], argv[1]);
return;
}
char *gpu_list = find_char_arg(argc, argv, "-gpus", 0);
int *gpus = 0;
int gpu = 0;
int ngpus = 0;
if (gpu_list) {
printf("%s\n", gpu_list);
int len = strlen(gpu_list);
ngpus = 1;
int i;
for (i = 0; i < len; ++i) {
if (gpu_list[i] == ',')
++ngpus;
}
gpus = calloc(ngpus, sizeof(int));
for (i = 0; i < ngpus; ++i) {
gpus[i] = atoi(gpu_list);
gpu_list = strchr(gpu_list, ',') + 1;
}
} else {
gpu = gpu_index;
gpus = &gpu;
ngpus = 1;
}
int cam_index = find_int_arg(argc, argv, "-c", 0);
int clear = find_arg(argc, argv, "-clear");
char *data = argv[3];
char *cfg = argv[4];
char *weights = (argc > 5) ? argv[5] : 0;
char *filename = (argc > 6) ? argv[6] : 0;
if (0 == strcmp(argv[2], "test"))
predict_regressor(data, cfg, weights);
else if (0 == strcmp(argv[2], "train"))
train_regressor(data, cfg, weights, gpus, ngpus, clear);
else if (0 == strcmp(argv[2], "demo"))
demo_regressor(data, cfg, weights, cam_index, filename);
}
unsigned check_retry(char *arg, int *argc, char **argv)
{
int n = find_arg(arg, *argc, argv);
unsigned nr;
if (n < 0) return 1;
/* Remove the "-retryy" */
excise_arg(n, argc, argv);
if (n >= *argc || atoi(argv[n]) == 0)
{
fprintf(stderr, "Syntax error: use '%s nnn' where nnn is nonzero\n", arg);
exit(1);
}
nr = atoi(argv[n]);
excise_arg(n, argc, argv);
return nr;
}
int check_forcehead(char *arg, int *argc, char **argv)
{
int n = find_arg(arg, *argc, argv);
int fh;
if (n < 0) return -1;
/* Remove the "-head" */
excise_arg(n, argc, argv);
if (n >= *argc || argv[n][0] < '0' || argv[n][0] > '1')
{
fprintf(stderr, "Syntax error: use '%s 0' or '%s 1'\n", arg, arg);
exit(1);
}
fh = argv[n][0] - '0';
excise_arg(n, argc, argv);
return fh;
}
void run_go(int argc, char **argv)
{
//boards_go();
if(argc < 4){
fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]);
return;
}
char *cfg = argv[3];
char *weights = (argc > 4) ? argv[4] : 0;
char *c2 = (argc > 5) ? argv[5] : 0;
char *w2 = (argc > 6) ? argv[6] : 0;
int multi = find_arg(argc, argv, "-multi");
if(0==strcmp(argv[2], "train")) train_go(cfg, weights);
else if(0==strcmp(argv[2], "valid")) valid_go(cfg, weights, multi);
else if(0==strcmp(argv[2], "self")) self_go(cfg, weights, c2, w2, multi);
else if(0==strcmp(argv[2], "test")) test_go(cfg, weights, multi);
else if(0==strcmp(argv[2], "engine")) engine_go(cfg, weights, multi);
}
char *check_type(char *arg, int *argc, char **argv)
{
int n = find_arg(arg, *argc, argv);
char *v;
if (n < 0) return NULL;
/* Remove the "-type" */
excise_arg(n, argc, argv);
if (n >= *argc)
{
fprintf(stderr, "Syntax error: use '%s <type>'\n", arg);
exit(1);
}
v = argv[n];
/* Remove the argument */
excise_arg(n, argc, argv);
if (!strcmpi(v, "auto")) return NULL;
return v;
}
char *check_comment(char *arg, int *argc, char **argv)
{
int n = find_arg(arg, *argc, argv);
char *v;
if (n < 0) return NULL;
/* Remove the "-comment" */
excise_arg(n, argc, argv);
if (n >= *argc)
{
return get_comment_stdin();
}
v = argv[n];
excise_arg(n, argc, argv);
if (v[0] == '@')
{
if (v[1] == '-') return get_comment_stdin();
return get_comment(v + 1);
}
return v;
}
static WCHAR *
merge_environment(WCHAR *old, WCHAR *add)
{
WCHAR **a_arg = env_to_arg(add);
WCHAR **c_arg = env_to_arg(old);
WCHAR *ret;
int i, j;
for(i = 0; c_arg[i] != NULL; ++i)
;
for(j = 0; a_arg[j] != NULL; ++j)
;
c_arg = erts_realloc(ERTS_ALC_T_TMP,
c_arg, (i+j+1) * sizeof(WCHAR *));
for(j = 0; a_arg[j] != NULL; ++j){
WCHAR **tmp;
WCHAR *current = a_arg[j];
WCHAR *eq_p = wcschr(current,L'=');
int unset = (eq_p!=NULL && eq_p[1]==L'\0');
if ((tmp = find_arg(c_arg, current)) != NULL) {
if (!unset) {
*tmp = current;
} else {
*tmp = c_arg[--i];
c_arg[i] = NULL;
}
} else if (!unset) {
c_arg[i++] = current;
c_arg[i] = NULL;
}
}
ret = arg_to_env(c_arg);
erts_free(ERTS_ALC_T_TMP, c_arg);
erts_free(ERTS_ALC_T_TMP, a_arg);
return ret;
}
int def(cons_t *next)
{
int count;
cons_t *now = NULL;
now = next->cdr;
count = get_func(now->cvalue);
if (g_fa[count].key == NULL) {
g_fa[count].key = (char*)malloc(strlen(now->cvalue) + 1);
strcpy(g_fa[count].key, now->cvalue);
}
next = now;
now = now->cdr;
g_fa[count].exp = now->cdr;
find_func(now->cdr, next->cvalue, count);
next = now->car;
find_arg(now->cdr, next);
now->cdr = NULL;
printf("define %s\n",g_fa[count].key);
return 0;
}
String* SessionRep::find_name() {
String name;
if (find_arg(String("-name"), name)) {
return new String(name);
}
const char* res_name = getenv("RESOURCE_NAME");
if (res_name != nil) {
return new String(res_name);
}
if (argc_ > 0) {
String s(argv_[0]);
int slash = s.rindex('/');
if (slash >= 0) {
s = s.right(slash + 1);
}
return new String(s);
}
return new String("noname");
}
static char*
merge_environment(char *old, char *add)
{
char **a_arg = env_to_arg(add);
char **c_arg = env_to_arg(old);
char *ret;
int i, j;
for(i = 0; c_arg[i] != NULL; ++i)
;
for(j = 0; a_arg[j] != NULL; ++j)
;
c_arg = erts_realloc(ERTS_ALC_T_TMP,
c_arg, (i+j+1) * sizeof(char *));
for(j = 0; a_arg[j] != NULL; ++j){
char **tmp;
char *current = a_arg[j];
if ((tmp = find_arg(c_arg, current)) != NULL) {
if (current[strlen(current)-1] != '=') {
*tmp = current;
} else {
*tmp = c_arg[--i];
c_arg[i] = NULL;
}
} else if (current[strlen(current)-1] != '=') {
c_arg[i++] = current;
c_arg[i] = NULL;
}
}
ret = arg_to_env(c_arg);
erts_free(ERTS_ALC_T_TMP, c_arg);
erts_free(ERTS_ALC_T_TMP, a_arg);
return ret;
}
void run_lsd(int argc, char **argv)
{
if(argc < 4){
fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]);
return;
}
int clear = find_arg(argc, argv, "-clear");
char *cfg = argv[3];
char *weights = (argc > 4) ? argv[4] : 0;
char *filename = (argc > 5) ? argv[5] : 0;
char *acfg = argv[5];
char *aweights = (argc > 6) ? argv[6] : 0;
if(0==strcmp(argv[2], "train")) train_lsd(cfg, weights, clear);
else if(0==strcmp(argv[2], "train2")) train_lsd2(cfg, weights, acfg, aweights, clear);
else if(0==strcmp(argv[2], "traincolor")) train_colorizer(cfg, weights, acfg, aweights, clear);
else if(0==strcmp(argv[2], "train3")) train_lsd3(argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], clear);
else if(0==strcmp(argv[2], "test")) test_lsd(cfg, weights, filename);
/*
else if(0==strcmp(argv[2], "valid")) validate_lsd(cfg, weights);
*/
}
static bool ask_for_fileregex(UAContext *ua, RESTORE_CTX *rx)
{
if (find_arg(ua, NT_("all")) >= 0) { /* if user enters all on command line */
return true; /* select everything */
}
ua->send_msg(_("\n\nFor one or more of the JobIds selected, no files were found,\n"
"so file selection is not possible.\n"
"Most likely your retention policy pruned the files.\n"));
if (get_yesno(ua, _("\nDo you want to restore all the files? (yes|no): "))) {
if (ua->pint32_val == 1)
return true;
while (get_cmd(ua, _("\nRegexp matching files to restore? (empty to abort): "))) {
if (ua->cmd[0] == '\0') {
break;
} else {
regex_t *fileregex_re = NULL;
int rc;
char errmsg[500] = "";
fileregex_re = (regex_t *)bmalloc(sizeof(regex_t));
rc = regcomp(fileregex_re, ua->cmd, REG_EXTENDED|REG_NOSUB);
if (rc != 0) {
regerror(rc, fileregex_re, errmsg, sizeof(errmsg));
}
regfree(fileregex_re);
free(fileregex_re);
if (*errmsg) {
ua->send_msg(_("Regex compile error: %s\n"), errmsg);
} else {
rx->bsr->fileregex = bstrdup(ua->cmd);
return true;
}
}
}
}
return false;
}
/*
* Confirm a retention period
*/
bool confirm_retention(UAContext *ua, utime_t *ret, const char *msg)
{
bool retval;
char ed1[100];
int yes_in_arg;
yes_in_arg = find_arg(ua, NT_("yes"));
for ( ;; ) {
ua->info_msg(_("The current %s retention period is: %s\n"),
msg, edit_utime(*ret, ed1, sizeof(ed1)));
if (yes_in_arg != -1) {
return true;
}
if (!get_cmd(ua, _("Continue? (yes/mod/no): "))) {
return false;
}
if (bstrcasecmp(ua->cmd, _("mod"))) {
if (!get_cmd(ua, _("Enter new retention period: "))) {
return false;
}
if (!duration_to_utime(ua->cmd, ret)) {
ua->error_msg(_("Invalid period.\n"));
continue;
}
continue;
}
if (is_yesno(ua->cmd, &retval)) {
return retval;
}
}
return true;
}
t_env *ft_parse_env(char **env)
{
int i;
t_env *ret;
char *tmp;
char *tmp2;
i = 0;
ret = init_list_no_env(env);
while (env[i] != NULL)
{
ret = parse_line(ret, env[i]);
i++;
}
if (isset_arg(ret, "SHLVL"))
{
tmp = find_arg(ret, "SHLVL");
tmp2 = ft_itoa_base(ft_atoi(tmp) + 1, 10);
change_arg(ret, "SHLVL", tmp2);
free(tmp);
free(tmp2);
}
return (ret);
}
void run_detector(int argc, char **argv)
{
char *prefix = find_char_arg(argc, argv, "-prefix", 0);
float thresh = find_float_arg(argc, argv, "-thresh", .24);
float hier_thresh = find_float_arg(argc, argv, "-hier", .5);
int cam_index = find_int_arg(argc, argv, "-c", 0);
int frame_skip = find_int_arg(argc, argv, "-s", 0);
if(argc < 4){
fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]);
return;
}
char *gpu_list = find_char_arg(argc, argv, "-gpus", 0);
char *outfile = find_char_arg(argc, argv, "-out", 0);
int *gpus = 0;
int gpu = 0;
int ngpus = 0;
if(gpu_list){
printf("%s\n", gpu_list);
int len = strlen(gpu_list);
ngpus = 1;
int i;
for(i = 0; i < len; ++i){
if (gpu_list[i] == ',') ++ngpus;
}
gpus = calloc(ngpus, sizeof(int));
for(i = 0; i < ngpus; ++i){
gpus[i] = atoi(gpu_list);
gpu_list = strchr(gpu_list, ',')+1;
}
} else {
gpu = gpu_index;
gpus = &gpu;
ngpus = 1;
}
int clear = find_arg(argc, argv, "-clear");
char *datacfg = argv[3];
char *cfg = argv[4];
char *weights = (argc > 5) ? argv[5] : 0;
char *filename = (argc > 6) ? argv[6]: 0;
if(0==strcmp(argv[2], "test")) test_detector(datacfg, cfg, weights, filename, thresh, hier_thresh);
else if(0==strcmp(argv[2], "train")) train_detector(datacfg, cfg, weights, gpus, ngpus, clear);
else if(0==strcmp(argv[2], "valid")) validate_detector(datacfg, cfg, weights, outfile);
else if(0==strcmp(argv[2], "recall")) validate_detector_recall(cfg, weights);
else if(0==strcmp(argv[2], "demo")) {
list *options = read_data_cfg(datacfg);
int classes = option_find_int(options, "classes", 20);
char *name_list = option_find_str(options, "names", "data/names.list");
char **names = get_labels(name_list);
demo(cfg, weights, thresh, cam_index, filename, names, classes, frame_skip, prefix, hier_thresh);
}
else if(0==strcmp(argv[2], "stream")){
list *options = read_data_cfg(datacfg);
int classes = option_find_int(options, "classes", 20);
char *name_list = option_find_str(options, "names", "data/names.list");
char **names = get_labels(name_list);
gpu_index = find_int_arg(argc, argv, "-i", 0);
char *ip_addr = find_char_arg(argc, argv, "-addr", "127.0.0.1");
int port = find_int_arg(argc, argv, "-port", 5571);
stream(gpu_index, cfg, weights, ip_addr, port, names, classes, hier_thresh, thresh);
}
}
void MethodIG::parse_docs()
{
auto b = comments.ptr();
auto e = comments.ptre();
charstr doc;
charstr* paramdoc = 0;
for(; b!=e; ++b)
{
token line = *b;
line.trim();
line.skip_char('/');
line.trim();
if(!line) {
if(paramdoc)
*paramdoc << "\n\n";
else if(doc)
doc << "\n\n";
continue;
}
if(line.first_char() != '@') {
charstr& target = paramdoc ? *paramdoc : doc;
if(!target.is_empty())
target << ' ';
//target.append_escaped(line);
target << line;
}
else {
//close previous string
if(paramdoc)
paramdoc = 0;
else if(doc)
docs.add()->swap(doc);
token paramline = line;
if(paramline.consume("@param ")) {
token param = paramline.cut_left_group(token::TK_whitespace());
Arg* a = find_arg(param);
if(a) {
paramdoc = &a->doc;
if(!paramdoc->is_empty())
*paramdoc << '\n';
//paramdoc->append_escaped(paramline);
*paramdoc << paramline;
}
else {
//doc.append_escaped(line);
doc << line;
}
}
else if(paramline.consume("@return ")) {
if(ret.doc)
ret.doc << '\n';
//ret.doc.append_escaped(paramline);
ret.doc << paramline;
}
else {
//doc.append_escaped(line);
doc << line;
}
}
}
if(doc)
docs.add()->swap(doc);
}
/*
* do the prompt/input/process loop
*
* If xflg is true, the function will not go interactive, but returns.
* If commandline != NULL, this command is processed first.
*
* Return: 0: on success
*/
int process_input(int xflag, char *commandline)
{
/* Dimensionate parsedline that no sprintf() can overflow the buffer
*/
char parsedline[MAX_INTERNAL_COMMAND_SIZE + sizeof(errorlevel) * 8]
, *readline;
/* Return the maximum pointer into parsedline to add 'numbytes' bytes */
#define parsedMax(numbytes) \
(parsedline + MAX_INTERNAL_COMMAND_SIZE - 1 - (numbytes))
char *evar;
char *tp;
char *ip;
char *cp;
char forvar;
int echothisline;
int tracethisline;
do
{
interactive_command = 0; /* not directly entered by user */
echothisline = tracethisline = 0;
if(commandline) {
ip = commandline;
readline = commandline = NULL;
} else {
if ((readline = malloc(MAX_INTERNAL_COMMAND_SIZE + 1)) == NULL)
{
error_out_of_memory();
return 1;
}
if (NULL == (ip = readbatchline(&echothisline, readline,
MAX_INTERNAL_COMMAND_SIZE)))
{ /* if no batch input then... */
if (xflag /* must not go interactive */
|| (fdattr(0) & 0x84) == 0x84 /* input is NUL device */
|| feof(stdin)) /* no further input */
{
free(readline);
break;
}
/* Go Interactive */
interactive_command = 1; /* directly entered by user */
readcommand(ip = readline, MAX_INTERNAL_COMMAND_SIZE);
tracemode = 0; /* reset trace mode */
}
}
/*
* The question mark '?' has a double meaning:
* C:\> ?
* ==> Display short help
*
* C:\> ? command arguments
* ==> enable tracemode for just this line
*/
if(*(ip = trim(ip)) == '?') {
ip = trim(ip + 1);
if(!*ip) { /* is short help command */
#ifdef INCLUDE_CMD_QUESTION
showcmds(ip);
#endif
free(readline);
continue;
}
/* this-line-tracemode */
echothisline = 0;
tracethisline = 1;
}
/* The FOR hack
If the line matches /^\s*for\s+\%[a-z]\s/, the FOR hack
becomes active, because FOR requires the sequence "%<ch>"
in its input.
When the percent (%) expansion is made later on, any
sequence "%<ch>" is retained.
*/
cp = ip;
if(matchtok(cp, "for") && *cp == '%' && isalpha(cp[1])
&& isspace(cp[2])) /* activate FOR hack */
forvar = toupper(cp[1]);
else forvar = 0;
cp = parsedline;
while (*ip)
{
/* Assume that at least one character is added, place the
test here to simplify the switch() statement */
if(cp >= parsedMax(1)) {
cp = NULL; /* error condition */
break;
}
if (*ip == '%')
{
switch (*++ip)
{
case '\0': /* FOR hack forvar == 0 if no FOR is active */
*cp++ = '%';
break;
case '%':
*cp++ = *ip++;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (NULL != (tp = find_arg(*ip - '0')))
{
if(cp >= parsedMax(strlen(tp))) {
cp = NULL;
goto intBufOver;
}
cp = stpcpy(cp, tp);
ip++;
}
else
*cp++ = '%';
/* Let the digit be copied in the cycle */
break;
case '?':
/* overflow check: parsedline has that many character
"on reserve" */
cp += sprintf(cp, "%u", errorlevel);
ip++;
break;
default:
if(forvar == toupper(*ip)) { /* FOR hack */
*cp++ = '%'; /* let the var be copied in next cycle */
break;
}
if ((tp = strchr(ip, '%')) != NULL)
{
*tp = '\0';
if ((evar = getEnv(ip)) != NULL) {
if(cp >= parsedMax(strlen(evar))) {
cp = NULL;
goto intBufOver;
}
cp = stpcpy(cp, evar);
}
ip = tp + 1;
}
break;
}
continue;
}
if (iscntrl(*ip))
*cp = ' ';
else
*cp++ = *ip++;
}
intBufOver:
free(readline);
if(!cp) { /* internal buffer overflow */
error_line_too_long();
continue;
}
*cp = '\0'; /* terminate copied string */
if (echothisline) /* Echo batch file line */
{
printprompt();
puts(parsedline);
}
if (*parsedline)
{
if(tracethisline)
++tracemode;
parsecommandline(parsedline);
if(tracethisline)
--tracemode;
if (echothisline || echo)
putchar('\n');
}
}
while (!canexit || !exitflag);
return 0;
}
int main ( int argc, char *argv[] )
{
TIMINGS_START ();
cmd_set_arguments ( argc, argv );
// Version
if ( find_arg ( "-v" ) >= 0 || find_arg ( "-version" ) >= 0 ) {
#ifdef GIT_VERSION
fprintf ( stdout, "Version: "GIT_VERSION "\n" );
#else
fprintf ( stdout, "Version: "VERSION "\n" );
#endif
exit ( EXIT_SUCCESS );
}
// Detect if we are in dmenu mode.
// This has two possible causes.
// 1 the user specifies it on the command-line.
if ( find_arg ( "-dmenu" ) >= 0 ) {
dmenu_mode = TRUE;
}
// 2 the binary that executed is called dmenu (e.g. symlink to rofi)
else{
// Get the base name of the executable called.
char *base_name = g_path_get_basename ( argv[0] );
const char * const dmenu_str = "dmenu";
dmenu_mode = ( strcmp ( base_name, dmenu_str ) == 0 );
// Free the basename for dmenu detection.
g_free ( base_name );
}
TICK ();
// Get the path to the cache dir.
cache_dir = g_get_user_cache_dir ();
// Create pid file path.
const char *path = g_get_user_runtime_dir ();
if ( path ) {
pidfile = g_build_filename ( path, "rofi.pid", NULL );
}
config_parser_add_option ( xrm_String, "pid", (void * *) &pidfile, "Pidfile location" );
if ( find_arg ( "-config" ) < 0 ) {
const char *cpath = g_get_user_config_dir ();
if ( cpath ) {
config_path = g_build_filename ( cpath, "rofi", "config", NULL );
}
}
else {
char *c = NULL;
find_arg_str ( "-config", &c );
config_path = rofi_expand_path ( c );
}
TICK ();
// Register cleanup function.
atexit ( cleanup );
TICK ();
// Get DISPLAY, first env, then argument.
char *display_str = getenv ( "DISPLAY" );
find_arg_str ( "-display", &display_str );
if ( setlocale ( LC_ALL, "" ) == NULL ) {
fprintf ( stderr, "Failed to set locale.\n" );
return EXIT_FAILURE;
}
xcb->connection = xcb_connect ( display_str, &xcb->screen_nbr );
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Failed to open display: %s", display_str );
return EXIT_FAILURE;
}
TICK_N ( "Open Display" );
xcb->screen = xcb_aux_get_screen ( xcb->connection, xcb->screen_nbr );
xcb_intern_atom_cookie_t *ac = xcb_ewmh_init_atoms ( xcb->connection, &xcb->ewmh );
xcb_generic_error_t *errors = NULL;
xcb_ewmh_init_atoms_replies ( &xcb->ewmh, ac, &errors );
if ( errors ) {
fprintf ( stderr, "Failed to create EWMH atoms\n" );
free ( errors );
}
if ( xkb_x11_setup_xkb_extension ( xcb->connection, XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION,
XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS, NULL, NULL, &xkb.first_event, NULL ) < 0 ) {
fprintf ( stderr, "cannot setup XKB extension!\n" );
return EXIT_FAILURE;
}
xkb.context = xkb_context_new ( XKB_CONTEXT_NO_FLAGS );
if ( xkb.context == NULL ) {
fprintf ( stderr, "cannot create XKB context!\n" );
return EXIT_FAILURE;
}
xkb.xcb_connection = xcb->connection;
xkb.device_id = xkb_x11_get_core_keyboard_device_id ( xcb->connection );
enum
{
required_events =
( XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY |
XCB_XKB_EVENT_TYPE_MAP_NOTIFY |
XCB_XKB_EVENT_TYPE_STATE_NOTIFY ),
required_nkn_details =
( XCB_XKB_NKN_DETAIL_KEYCODES ),
required_map_parts =
( XCB_XKB_MAP_PART_KEY_TYPES |
XCB_XKB_MAP_PART_KEY_SYMS |
XCB_XKB_MAP_PART_MODIFIER_MAP |
XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
XCB_XKB_MAP_PART_KEY_ACTIONS |
XCB_XKB_MAP_PART_VIRTUAL_MODS |
XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP ),
required_state_details =
( XCB_XKB_STATE_PART_MODIFIER_BASE |
XCB_XKB_STATE_PART_MODIFIER_LATCH |
XCB_XKB_STATE_PART_MODIFIER_LOCK |
XCB_XKB_STATE_PART_GROUP_BASE |
XCB_XKB_STATE_PART_GROUP_LATCH |
XCB_XKB_STATE_PART_GROUP_LOCK ),
};
static const xcb_xkb_select_events_details_t details = {
.affectNewKeyboard = required_nkn_details,
.newKeyboardDetails = required_nkn_details,
.affectState = required_state_details,
.stateDetails = required_state_details,
};
xcb_xkb_select_events ( xcb->connection, xkb.device_id, required_events, /* affectWhich */
0, /* clear */
required_events, /* selectAll */
required_map_parts, /* affectMap */
required_map_parts, /* map */
&details );
xkb.keymap = xkb_x11_keymap_new_from_device ( xkb.context, xcb->connection, xkb.device_id, XKB_KEYMAP_COMPILE_NO_FLAGS );
if ( xkb.keymap == NULL ) {
fprintf ( stderr, "Failed to get Keymap for current keyboard device.\n" );
return EXIT_FAILURE;
}
xkb.state = xkb_x11_state_new_from_device ( xkb.keymap, xcb->connection, xkb.device_id );
if ( xkb.state == NULL ) {
fprintf ( stderr, "Failed to get state object for current keyboard device.\n" );
return EXIT_FAILURE;
}
xkb.compose.table = xkb_compose_table_new_from_locale ( xkb.context, setlocale ( LC_CTYPE, NULL ), 0 );
if ( xkb.compose.table != NULL ) {
xkb.compose.state = xkb_compose_state_new ( xkb.compose.table, 0 );
}
else {
fprintf ( stderr, "Failed to get keyboard compose table. Trying to limp on.\n" );
}
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Connection has error\n" );
exit ( EXIT_FAILURE );
}
x11_setup ( &xkb );
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Connection has error\n" );
exit ( EXIT_FAILURE );
}
const xcb_query_extension_reply_t *er = xcb_get_extension_data ( xcb->connection, &xcb_xinerama_id );
if ( er ) {
if ( er->present ) {
xcb_xinerama_is_active_cookie_t is_active_req = xcb_xinerama_is_active ( xcb->connection );
xcb_xinerama_is_active_reply_t *is_active = xcb_xinerama_is_active_reply ( xcb->connection, is_active_req, NULL );
xcb->has_xinerama = is_active->state;
free ( is_active );
}
}
main_loop = g_main_loop_new ( NULL, FALSE );
TICK_N ( "Setup mainloop" );
// startup not.
xcb->sndisplay = sn_xcb_display_new ( xcb->connection, error_trap_push, error_trap_pop );
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Connection has error\n" );
exit ( EXIT_FAILURE );
}
if ( xcb->sndisplay != NULL ) {
xcb->sncontext = sn_launchee_context_new_from_environment ( xcb->sndisplay, xcb->screen_nbr );
}
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Connection has error\n" );
exit ( EXIT_FAILURE );
}
TICK_N ( "Startup Notification" );
// Initialize Xresources subsystem.
config_parse_xresource_init ();
TICK_N ( "Initialize Xresources system" );
// Setup keybinding
setup_abe ();
TICK_N ( "Setup abe" );
if ( find_arg ( "-no-config" ) < 0 ) {
load_configuration ( );
}
if ( !dmenu_mode ) {
// setup_modi
setup_modi ();
}
if ( find_arg ( "-no-config" ) < 0 ) {
// Reload for dynamic part.
load_configuration_dynamic ( );
}
// Dump.
// catch help request
if ( find_arg ( "-h" ) >= 0 || find_arg ( "-help" ) >= 0 || find_arg ( "--help" ) >= 0 ) {
help ( argc, argv );
exit ( EXIT_SUCCESS );
}
if ( find_arg ( "-dump-xresources" ) >= 0 ) {
config_parse_xresource_dump ();
exit ( EXIT_SUCCESS );
}
if ( find_arg ( "-dump-xresources-theme" ) >= 0 ) {
config_parse_xresources_theme_dump ();
exit ( EXIT_SUCCESS );
}
main_loop_source = g_water_xcb_source_new_for_connection ( NULL, xcb->connection, main_loop_x11_event_handler, NULL, NULL );
TICK_N ( "X11 Setup " );
rofi_view_workers_initialize ();
// Setup signal handling sources.
// SIGINT
g_unix_signal_add ( SIGINT, main_loop_signal_handler_int, NULL );
g_idle_add ( startup, NULL );
// Start mainloop.
g_main_loop_run ( main_loop );
return return_code;
}
static gboolean startup ( G_GNUC_UNUSED gpointer data )
{
TICK_N ( "Startup" );
// flags to run immediately and exit
char *sname = NULL;
char *msg = NULL;
//
// Sanity check
if ( config_sanity_check ( ) ) {
return G_SOURCE_REMOVE;
}
TICK_N ( "Config sanity check" );
// Parse the keybindings.
if ( !parse_keys_abe () ) {
// Error dialog
return G_SOURCE_REMOVE;
}
TICK_N ( "Parse ABE" );
// Dmenu mode.
if ( dmenu_mode == TRUE ) {
// force off sidebar mode:
config.sidebar_mode = FALSE;
int retv = run_dmenu ();
if ( retv ) {
rofi_set_return_code ( EXIT_SUCCESS );
// Directly exit.
g_main_loop_quit ( main_loop );
}
}
else if ( find_arg_str ( "-e", &( msg ) ) ) {
int markup = FALSE;
if ( find_arg ( "-markup" ) >= 0 ) {
markup = TRUE;
}
if ( !show_error_message ( msg, markup ) ) {
g_main_loop_quit ( main_loop );
}
}
else if ( find_arg_str ( "-show", &sname ) == TRUE ) {
int index = switcher_get ( sname );
if ( index < 0 ) {
// Add it to the list
index = add_mode ( sname );
// Complain
if ( index >= 0 ) {
fprintf ( stdout, "Mode %s not enabled. Please add it to the list of enabled modi: %s\n",
sname, config.modi );
fprintf ( stdout, "Adding mode: %s\n", sname );
}
// Run it anyway if found.
}
if ( index >= 0 ) {
run_switcher ( index );
}
else {
fprintf ( stderr, "The %s switcher has not been enabled\n", sname );
return G_SOURCE_REMOVE;
}
}
else{
// Daemon mode
fprintf ( stderr, "Rofi daemon mode is now removed.\n" );
fprintf ( stderr, "Please use your window manager binding functionality or xbindkeys to replace it.\n" );
g_main_loop_quit ( main_loop );
}
return G_SOURCE_REMOVE;
}
void CmdLineOptions::parse(int argc, char **argv, StringList &left_overs) {
std::unique_lock<std::mutex> l(mutex_);
left_overs.clear();
auto get_nice_program_name = [argv]() -> std::string {
std::string result = std::string(argv[0]);
// Remove everything but the command's name.
size_t const pos = result.find_last_of("/");
if (pos != result.npos) {
if (pos + 1 < result.size()) {
result = result.substr(pos);
}
}
return result;
};
programName_ = get_nice_program_name();
StringList listOfOptionsWithNoValue;
for (int i(1); i < argc; ++i) {
int const next = (i + 1) < argc ? i + 1 : -1;
std::string arg(argv[i]);
{
SwitchOptList::iterator it = find_switch(arg);
if (it != switchOptionList_.end()) {
it->set(!it->get_default());
continue;
}
}
{
ArgOptList::iterator it = find_arg(arg);
if (it != argOptionList_.end()) {
if (next != -1) {
it->set(argv[next]);
++i;
continue;
} else {
listOfOptionsWithNoValue.push_back(arg);
continue;
}
}
}
// not an option :/
left_overs.push_back(arg);
}
// check for the help switch.
if (get_switch(HELP_SWITCH_NAME)) {
print_usage(stdStream_);
exit(EXIT_SUCCESS);
}
StringList listOfMissingRequiredOptions;
StringList listOfInvalidOptions;
for (StringOption const &option : argOptionList_) {
if (!option.is_set() && option.is_required()) {
listOfMissingRequiredOptions.push_back(option.name());
} else {
// Validate the argument
ValidatorFunctionMap::const_iterator it = validatorFunctionMap_.find(
option.name());
if (it != validatorFunctionMap_.end()) {
ValidatorFunctionList const &list(it->second);
for (ValidatorFunction const &validator : list) {
if (!validator(option.name(), option.get())) {
listOfInvalidOptions.push_back(option.name());
}
}
}
}
}
parserResultHandler_(left_overs, listOfMissingRequiredOptions,
listOfOptionsWithNoValue, listOfInvalidOptions);
}
bool CmdLineOptions::is_arg(std::string const &name) const {
ArgOptList::const_iterator it = find_arg(name);
return it != argOptionList_.end();
}
/*
* Restore files
*/
bool restore_cmd(UAContext *ua, const char *cmd)
{
RESTORE_CTX rx; /* restore context */
POOL_MEM buf;
JOBRES *job;
int i;
JCR *jcr = ua->jcr;
char *escaped_bsr_name = NULL;
char *escaped_where_name = NULL;
char *strip_prefix, *add_prefix, *add_suffix, *regexp;
strip_prefix = add_prefix = add_suffix = regexp = NULL;
memset(&rx, 0, sizeof(rx));
rx.path = get_pool_memory(PM_FNAME);
rx.fname = get_pool_memory(PM_FNAME);
rx.JobIds = get_pool_memory(PM_FNAME);
rx.JobIds[0] = 0;
rx.BaseJobIds = get_pool_memory(PM_FNAME);
rx.query = get_pool_memory(PM_FNAME);
rx.bsr = new_bsr();
i = find_arg_with_value(ua, "comment");
if (i >= 0) {
rx.comment = ua->argv[i];
if (!is_comment_legal(ua, rx.comment)) {
goto bail_out;
}
}
i = find_arg_with_value(ua, "backupformat");
if (i >= 0) {
rx.backup_format = ua->argv[i];
}
i = find_arg_with_value(ua, "where");
if (i >= 0) {
rx.where = ua->argv[i];
}
i = find_arg_with_value(ua, "replace");
if (i >= 0) {
rx.replace = ua->argv[i];
}
i = find_arg_with_value(ua, "pluginoptions");
if (i >= 0) {
rx.plugin_options = ua->argv[i];
}
i = find_arg_with_value(ua, "strip_prefix");
if (i >= 0) {
strip_prefix = ua->argv[i];
}
i = find_arg_with_value(ua, "add_prefix");
if (i >= 0) {
add_prefix = ua->argv[i];
}
i = find_arg_with_value(ua, "add_suffix");
if (i >= 0) {
add_suffix = ua->argv[i];
}
i = find_arg_with_value(ua, "regexwhere");
if (i >= 0) {
rx.RegexWhere = ua->argv[i];
}
if (strip_prefix || add_suffix || add_prefix) {
int len = bregexp_get_build_where_size(strip_prefix, add_prefix, add_suffix);
regexp = (char *)bmalloc(len * sizeof(char));
bregexp_build_where(regexp, len, strip_prefix, add_prefix, add_suffix);
rx.RegexWhere = regexp;
}
/* TODO: add acl for regexwhere ? */
if (rx.RegexWhere) {
if (!acl_access_ok(ua, Where_ACL, rx.RegexWhere, true)) {
ua->error_msg(_("\"RegexWhere\" specification not authorized.\n"));
goto bail_out;
}
}
if (rx.where) {
if (!acl_access_ok(ua, Where_ACL, rx.where, true)) {
ua->error_msg(_("\"where\" specification not authorized.\n"));
goto bail_out;
}
}
if (!open_client_db(ua, true)) {
goto bail_out;
}
/* Ensure there is at least one Restore Job */
LockRes();
foreach_res(job, R_JOB) {
if (job->JobType == JT_RESTORE) {
if (!rx.restore_job) {
rx.restore_job = job;
}
rx.restore_jobs++;
}
}
UnlockRes();
if (!rx.restore_jobs) {
ua->error_msg(_(
"No Restore Job Resource found in bareos-dir.conf.\n"
"You must create at least one before running this command.\n"));
goto bail_out;
}
/*
* Request user to select JobIds or files by various different methods
* last 20 jobs, where File saved, most recent backup, ...
* In the end, a list of files are pumped into
* add_findex()
*/
switch (user_select_jobids_or_files(ua, &rx)) {
case 0: /* error */
goto bail_out;
case 1: /* selected by jobid */
get_and_display_basejobs(ua, &rx);
if (!build_directory_tree(ua, &rx)) {
ua->send_msg(_("Restore not done.\n"));
goto bail_out;
}
break;
case 2: /* selected by filename, no tree needed */
break;
}
if (rx.bsr->JobId) {
char ed1[50];
if (!complete_bsr(ua, rx.bsr)) { /* find Vol, SessId, SessTime from JobIds */
ua->error_msg(_("Unable to construct a valid BSR. Cannot continue.\n"));
goto bail_out;
}
if (!(rx.selected_files = write_bsr_file(ua, rx))) {
ua->warning_msg(_("No files selected to be restored.\n"));
goto bail_out;
}
display_bsr_info(ua, rx); /* display vols needed, etc */
if (rx.selected_files==1) {
ua->info_msg(_("\n1 file selected to be restored.\n\n"));
} else {
ua->info_msg(_("\n%s files selected to be restored.\n\n"),
edit_uint64_with_commas(rx.selected_files, ed1));
}
} else {
ua->warning_msg(_("No files selected to be restored.\n"));
goto bail_out;
}
if (rx.restore_jobs == 1) {
job = rx.restore_job;
} else {
job = get_restore_job(ua);
}
if (!job) {
goto bail_out;
}
if (!get_client_name(ua, &rx)) {
goto bail_out;
}
if (!rx.ClientName) {
ua->error_msg(_("No Client resource found!\n"));
goto bail_out;
}
if (!get_restore_client_name(ua, rx)) {
goto bail_out;
}
escaped_bsr_name = escape_filename(jcr->RestoreBootstrap);
Mmsg(ua->cmd,
"run job=\"%s\" client=\"%s\" restoreclient=\"%s\" storage=\"%s\""
" bootstrap=\"%s\" files=%u catalog=\"%s\"",
job->name(), rx.ClientName, rx.RestoreClientName,
rx.store?rx.store->name():"",
escaped_bsr_name ? escaped_bsr_name : jcr->RestoreBootstrap,
rx.selected_files, ua->catalog->name());
/*
* Build run command
*/
if (rx.backup_format) {
Mmsg(buf, " backupformat=%s", rx.backup_format);
pm_strcat(ua->cmd, buf);
}
pm_strcpy(buf, "");
if (rx.RegexWhere) {
escaped_where_name = escape_filename(rx.RegexWhere);
Mmsg(buf, " regexwhere=\"%s\"",
escaped_where_name ? escaped_where_name : rx.RegexWhere);
} else if (rx.where) {
escaped_where_name = escape_filename(rx.where);
Mmsg(buf," where=\"%s\"",
escaped_where_name ? escaped_where_name : rx.where);
}
pm_strcat(ua->cmd, buf);
if (rx.replace) {
Mmsg(buf, " replace=%s", rx.replace);
pm_strcat(ua->cmd, buf);
}
if (rx.plugin_options) {
Mmsg(buf, " pluginoptions=%s", rx.plugin_options);
pm_strcat(ua->cmd, buf);
}
if (rx.comment) {
Mmsg(buf, " comment=\"%s\"", rx.comment);
pm_strcat(ua->cmd, buf);
}
if (escaped_bsr_name != NULL) {
bfree(escaped_bsr_name);
}
if (escaped_where_name != NULL) {
bfree(escaped_where_name);
}
if (regexp) {
bfree(regexp);
}
if (find_arg(ua, NT_("yes")) > 0) {
pm_strcat(ua->cmd, " yes"); /* pass it on to the run command */
}
Dmsg1(200, "Submitting: %s\n", ua->cmd);
/*
* Transfer jobids to jcr to for picking up restore objects
*/
jcr->JobIds = rx.JobIds;
rx.JobIds = NULL;
parse_ua_args(ua);
run_cmd(ua, ua->cmd);
free_rx(&rx);
garbage_collect_memory(); /* release unused memory */
return true;
bail_out:
if (escaped_bsr_name != NULL) {
bfree(escaped_bsr_name);
}
if (escaped_where_name != NULL) {
bfree(escaped_where_name);
}
if (regexp) {
bfree(regexp);
}
free_rx(&rx);
garbage_collect_memory(); /* release unused memory */
return false;
}
