static Cmdret conf_variable(List *args, Cmdarg *ca)
{
log_msg("CONFIG", "conf_variable");
log_err("CONFIG", "%s", ca->cmdline->line);
/* statement needs valid name */
Token *lhs = tok_arg(args, 1);
char *key = list_arg(args, 1, VAR_STRING);
if (!lhs || !key)
return NORET;
/* find where '=' delimits statement */
int delm = -1;
for (int i = 0; i < utarray_len(args->items); i++) {
char *op = list_arg(args, i, VAR_STRING);
if (op && !strcmp(op, "=")) {
delm = i+1;
break;
}
}
if (delm == -1 || delm >= utarray_len(args->items))
return NORET;
char *expr = cmdline_line_from(ca->cmdline, delm);
fn_var var = {
.key = strdup(key),
.var = strdup(expr),
};
/* when delm isn't 3 the key should be expanded */
if (delm != 3) {
char *pvar = opt_var(key, cmd_callstack());
if (!pvar)
goto cleanup;
char *newexpr = repl_elem(pvar, expr, args, 2, delm - 1);
if (!newexpr)
goto cleanup;
SWAP_ALLOC_PTR(var.var, newexpr);
}
fn_func *blk = cmd_callstack();
if (!ca->flags)
blk = NULL;
set_var(&var, blk);
return NORET;
cleanup:
free(var.key);
free(var.var);
return NORET;
}
static void ed_stage_confirm(Ed *ed)
{
log_msg("ED", "ed_stage_confirm");
int max = 0;
for (int i = 0; i < ed->src.argc; i++)
max = MAX(max, strlen(ed->src.argv[i]));
char buf[PATH_MAX];
for (int i = 0; i < ed->dest.argc; i++) {
char **src = &ed->src.argv[i];
char **dest = &ed->dest.argv[i];
if (!strcmp(*src, *dest)) {
free(*dest);
*dest = NULL;
continue;
}
sprintf(buf, "%-*s %s", max, *src, *dest);
SWAP_ALLOC_PTR(*dest, strdup(buf));
}
ed_start_term(ed, &ed->dest);
}
void filter_build(Filter *fil, const char *line)
{
log_msg("FILTER", "build");
if (fil->pat)
regex_pat_delete(fil->pat);
fil->pat = regex_pat_new(line);
SWAP_ALLOC_PTR(fil->line, strdup(line));
Model *m = fil->hndl->model;
model_clear_filter(m);
int max = model_count(m);
int count = 0;
for (int i = max; i > 0; i--) {
char *str = model_str_line(m, i-1);
if (!regex_match(fil->pat, str)) {
model_filter_line(m, i-1);
count++;
}
}
buf_signal_filter(fil->hndl->buf, count);
}
static Token* cmdline_parse(Cmdline *cmdline, Token *word, UT_array *parent)
{
char ch;
bool seek;
Cmdstr cmd = {.ed = 0};
if (word)
cmd.st = word->start;
QUEUE *stack = &cmd.stack;
QUEUE_INIT(stack);
cmd.args = list_new(cmdline);
stack_push(stack, cmd.args);
Token *headref = stack_head(stack);
utarray_new(cmd.chlds, &chld_icd);
check_flags(cmdline, &cmd);
int idx = 0;
while ((word = (Token*)utarray_next(cmdline->tokens, word))) {
char *str = token_val(word, VAR_STRING);
if (word->quoted) {
push(*word, stack, word->start);
pop(stack, cmdline, &idx);
continue;
}
switch(ch = str[0]) {
case '(':
cmdline->lvl++;
word = cmdline_parse(cmdline, word, cmd.chlds);
((Cmdstr*)utarray_back(cmd.chlds))->idx = idx - 1;
if (!word)
goto breakout;
break;
case ')':
if (cmdline->lvl < 1)
break;
cmdline->lvl--;
cmd.ed = word->start;
goto breakout;
case '[':
push(list_new(cmdline), stack, word->start);
stack_head(stack)->start = word->start;
break;
case ']':
if (!valid_arry(cmdline, stack, headref))
break;
stack_head(stack)->end = word->end;
push_arry_container(cmdline, headref, word);
pop(stack, cmdline, &idx);
break;
case '|':
if (cmdline->lvl < 1) {
cmd.bar = true;
cmd.ed = word->start;
goto breakout;
}
/*FALLTHROUGH*/
case '.':
case ':':
case ',':
break;
case '%':
case '$':
word = valid_var(cmdline, word, ch);
case '!':
if (valid_exec(cmdline, &cmd, word))
break;
/*FALLTHROUGH*/
default:
seek = seek_ahead(cmdline, stack, word);
push(*word, stack, word->start);
if (!seek)
pop(stack, cmdline, &idx);
}
}
breakout:
while (!QUEUE_EMPTY(stack))
stack_pop(stack);
utarray_push_back(parent, &cmd);
return word;
}
void cmdline_build_tokens(Cmdline *cmdline, char *line)
{
log_msg("CMDSTR", "cmdline_build_tokens");
SWAP_ALLOC_PTR(cmdline->line, strdup(line));
Token *word = NULL;
while ((word = (Token*)utarray_next(cmdline->tokens, word)))
free(word->var.vval.v_string);
utarray_clear(cmdline->tokens);
cmdline_tokenize(cmdline);
}
