char *
eval_arglist(const char args[], const char **stop_ptr)
{
size_t len = 0;
char *eval_result = NULL;
assert(args[0] != '\0');
while(args[0] != '\0')
{
char *free_this = NULL;
const char *tmp_result = NULL;
var_t result = var_false();
const ParsingErrors parsing_error = parse(args, &result);
if(parsing_error == PE_INVALID_EXPRESSION && is_prev_token_whitespace())
{
result = get_parsing_result();
tmp_result = free_this = var_to_string(result);
args = get_last_parsed_char();
}
else if(parsing_error == PE_NO_ERROR)
{
tmp_result = free_this = var_to_string(result);
args = get_last_position();
}
if(tmp_result == NULL)
{
var_free(result);
break;
}
if(!is_null_or_empty(eval_result))
{
eval_result = extend_string(eval_result, " ", &len);
}
eval_result = extend_string(eval_result, tmp_result, &len);
var_free(result);
free(free_this);
args = skip_whitespace(args);
}
if(args[0] == '\0')
{
return eval_result;
}
else
{
free(eval_result);
*stop_ptr = args;
return NULL;
}
}
bool polarite_unique(vector<Clause *>& clauses, vector<Literal>& literals, Literal &paris){
vector<bool> var_true(literals.size(), false); //Liste des variables qui apparaissent avec la polarité positive.
vector<bool> var_false(literals.size(), false); //Liste des variables qui apparaissent avec la polarité négative.
for(Clause* clause : clauses){
vector<int> vars = clause->getVariables();
for(int var : vars){
if(!literals[abs(var)].isFixed()){
if(var>0)
var_true[abs(var)] = true;
else
var_false[abs(var)] = true;
}
}
}
/** On vérifie si des variables ne sont vuent qu'avec une seule polaritée. **/
bool change = false;
for(unsigned int i = 1;i<var_true.size();i++){
if(var_true[i] && !var_false[i]){
paris.addDeduct(i);
Literal &lit = literals[i];
lit.setValue(true);
lit.setFixed(true);
change = true;
}
else if(!var_true[i] && var_false[i]){
paris.addDeduct(i);
Literal &lit = literals[i];
lit.setValue(false);
lit.setFixed(true);
change = true;
}
}
return change;
}
/* Checks whether executable exists at absolute path orin directories listed in
* $PATH when path isn't absolute. Checks for various executable extensions on
* Windows. Returns boolean value describing result of the check. */
static var_t
executable_builtin(const call_info_t *call_info)
{
int exists;
char *str_val;
str_val = var_to_string(call_info->argv[0]);
if(is_path_absolute(str_val))
{
exists = executable_exists(str_val);
}
else
{
exists = (find_cmd_in_path(str_val, 0UL, NULL) == 0);
}
free(str_val);
return exists ? var_true() : var_false();
}
/* Evaluates logical AND operation. All operands are evaluated lazily from left
* to right. Returns zero on success, otherwise non-zero is returned. */
static int
eval_and_op(int nops, expr_t ops[], var_t *result)
{
int val;
int i;
if(nops == 0)
{
*result = var_false();
return 0;
}
if(eval_expr(&ops[0]) != 0)
{
return 1;
}
if(nops == 1)
{
*result = var_clone(ops[0].value);
return 0;
}
/* Conversion to integer so that strings are converted into numbers instead of
* checked to be empty. */
val = var_to_integer(ops[0].value);
for(i = 1; i < nops && val; ++i)
{
if(eval_expr(&ops[i]) != 0)
{
return 1;
}
val &= var_to_integer(ops[i].value);
}
*result = var_from_bool(val);
return 0;
}
/* Allows examining internal parameters from scripts to e.g. figure out
* environment in which application is running. */
static var_t
has_builtin(const call_info_t *call_info)
{
var_t result;
char *const str_val = var_to_string(call_info->argv[0]);
if(strcmp(str_val, "unix") == 0)
{
result = var_from_bool(get_env_type() == ET_UNIX);
}
else if(strcmp(str_val, "win") == 0)
{
result = var_from_bool(get_env_type() == ET_WIN);
}
else
{
result = var_false();
}
free(str_val);
return result;
}
/* Expands macros in the *format string advancing the pointer as it goes. The
* opt represents conditional expression state, should be zero for non-recursive
* calls. Returns newly allocated string, which should be freed by the
* caller. */
static LineWithAttrs
parse_view_macros(view_t *view, const char **format, const char macros[],
int opt)
{
const dir_entry_t *const curr = get_current_entry(view);
LineWithAttrs result = { .line = strdup(""), .attrs = strdup("") };
char c;
int nexpansions = 0;
int has_expander = 0;
if(curr == NULL)
{
return result;
}
while((c = **format) != '\0')
{
size_t width = 0;
int left_align = 0;
char buf[PATH_MAX + 1];
const char *const next = ++*format;
int skip, ok;
if(c != '%' ||
(!char_is_one_of(macros, *next) && !isdigit(*next) &&
(*next != '=' || has_expander)))
{
if(strappendch(&result.line, &result.line_len, c) != 0)
{
break;
}
continue;
}
if(*next == '=')
{
(void)sync_attrs(&result, 0);
if(strappend(&result.line, &result.line_len, "%=") != 0 ||
strappendch(&result.attrs, &result.attrs_len, '=') != 0)
{
break;
}
++*format;
has_expander = 1;
continue;
}
if(*next == '-')
{
left_align = 1;
++*format;
}
while(isdigit(**format))
{
width = width*10 + *(*format)++ - '0';
}
c = *(*format)++;
skip = 0;
ok = 1;
buf[0] = '\0';
switch(c)
{
case 'a':
friendly_size_notation(get_free_space(curr_view->curr_dir), sizeof(buf),
buf);
break;
case 't':
format_entry_name(curr, NF_FULL, sizeof(buf), buf);
break;
case 'T':
if(curr->type == FT_LINK)
{
char full_path[PATH_MAX + 1];
char link_path[PATH_MAX + 1]; //add by sim1
get_full_path_of(curr, sizeof(full_path), full_path);
//mod by sim1 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
if(get_link_target(full_path, link_path, sizeof(link_path)) != 0)
{
copy_str(buf, sizeof(buf), "Failed to resolve link");
}
else
{
snprintf(buf, sizeof(buf), " -> %s", link_path);
}
//mod by sim1 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
}
break;
case 'f':
get_short_path_of(view, curr, NF_FULL, 0, sizeof(buf), buf);
break;
case 'A':
#ifndef _WIN32
get_perm_string(buf, sizeof(buf), curr->mode);
#else
copy_str(buf, sizeof(buf), attr_str_long(curr->attrs));
#endif
break;
case 'u':
get_uid_string(curr, 0, sizeof(buf), buf);
break;
case 'g':
get_gid_string(curr, 0, sizeof(buf), buf);
break;
case 's':
friendly_size_notation(fentry_get_size(view, curr), sizeof(buf), buf);
break;
//add by sim1 ************************************************
case 'r':
{
char path[PATH_MAX] = {0};
get_full_path_at(view, view->list_pos, sizeof(path), path);
(void)get_rating_string(buf, sizeof(buf), path);
}
break;
case 'n':
{
int nitems = !fentry_is_dir(curr) ? 0 : (int)fentry_get_nitems(view, curr);
snprintf(buf, sizeof(buf), "%d", nitems);
}
break;
//add by sim1 ************************************************
case 'E':
{
uint64_t size = 0U;
typedef int (*iter_f)(view_t *view, dir_entry_t **entry);
/* No current element for visual mode, since it can contain truly
* empty selection when cursor is on ../ directory. */
iter_f iter = vle_mode_is(VISUAL_MODE) ? &iter_selected_entries
: &iter_selection_or_current;
dir_entry_t *entry = NULL;
while(iter(view, &entry))
{
size += fentry_get_size(view, entry);
}
friendly_size_notation(size, sizeof(buf), buf);
}
break;
case 'd':
{
struct tm *tm_ptr = localtime(&curr->mtime);
strftime(buf, sizeof(buf), cfg.time_format, tm_ptr);
}
break;
case '-':
case 'x':
skip = expand_num(buf, sizeof(buf), view->filtered);
break;
case 'l':
skip = expand_num(buf, sizeof(buf), view->list_pos + 1);
break;
case 'L':
skip = expand_num(buf, sizeof(buf), view->list_rows + view->filtered);
break;
case 'S':
skip = expand_num(buf, sizeof(buf), view->list_rows);
break;
case '%':
copy_str(buf, sizeof(buf), "%");
break;
case 'z':
copy_str(buf, sizeof(buf), get_tip());
break;
case 'D':
if(curr_stats.number_of_windows == 1)
{
view_t *const other = (view == curr_view) ? other_view : curr_view;
//mod by sim1
//copy_str(buf, sizeof(buf), replace_home_part(other->curr_dir));
snprintf(buf, sizeof(buf), " ‖ %s", replace_home_part(other->curr_dir));
}
break;
case '[':
{
LineWithAttrs opt = parse_view_macros(view, format, macros, 1);
copy_str(buf, sizeof(buf), opt.line);
free(opt.line);
char *attrs = opt.attrs;
if(sync_attrs(&result, 0) && opt.attrs_len > 0U)
{
if(*attrs != ' ')
{
result.attrs[result.attrs_len - 1U] = *attrs;
}
++attrs;
}
strappend(&result.attrs, &result.attrs_len, attrs);
free(opt.attrs);
break;
}
case ']':
if(opt)
{
if(nexpansions == 0)
{
replace_string(&result.line, "");
replace_string(&result.attrs, "");
result.line_len = 0U;
result.attrs_len = 0U;
}
if(sync_attrs(&result, 0))
{
result.attrs[--result.attrs_len] = '\0';
}
return result;
}
LOG_INFO_MSG("Unmatched %%]");
ok = 0;
break;
case '{':
{
/* Try to find matching closing bracket
* TODO: implement the way to escape it, so that the expr may contain
* closing brackets */
const char *e = strchr(*format, '}');
char *expr = NULL, *resstr = NULL;
var_t res = var_false();
ParsingErrors parsing_error;
/* If there's no matching closing bracket, just add the opening one
* literally */
if(e == NULL)
{
ok = 0;
break;
}
/* Create a NULL-terminated copy of the given expr.
* TODO: we could temporarily use buf for that, to avoid extra
* allocation, but explicitly named variable reads better. */
expr = calloc(e - (*format) + 1 /* NUL-term */, 1);
memcpy(expr, *format, e - (*format));
/* Try to parse expr, and convert the res to string if succeed. */
parsing_error = parse(expr, 0, &res);
if(parsing_error == PE_NO_ERROR)
{
resstr = var_to_str(res);
}
if(resstr != NULL)
{
copy_str(buf, sizeof(buf), resstr);
}
else
{
copy_str(buf, sizeof(buf), "<Invalid expr>");
}
var_free(res);
free(resstr);
free(expr);
*format = e + 1 /* closing bracket */;
}
break;
case '*':
if(width > 9)
{
snprintf(buf, sizeof(buf), "%%%d*", (int)width);
width = 0;
break;
}
(void)sync_attrs(&result, 1);
result.attrs[result.attrs_len - 1] = '0' + width;
width = 0;
break;
default:
LOG_INFO_MSG("Unexpected %%-sequence: %%%c", c);
ok = 0;
break;
}
if(char_is_one_of("tTAugsEd", c) && fentry_is_fake(curr))
{
buf[0] = '\0';
}
if(!ok)
{
*format = next;
if(strappendch(&result.line, &result.line_len, '%') != 0)
{
break;
}
continue;
}
check_expanded_str(buf, skip, &nexpansions);
stralign(buf, width, ' ', left_align);
if(strappend(&result.line, &result.line_len, buf) != 0)
{
break;
}
}
/* Unmatched %[. */
if(opt)
{
(void)strprepend(&result.line, &result.line_len, "%[");
}
if(sync_attrs(&result, 0))
{
result.attrs[--result.attrs_len] = '\0';
}
return result;
}
/* Makes sure that result->attrs has at least as many elements as result->line
* contains characters + extra_width. Returns non-zero if result->attrs has
* extra characters compared to result->line. */
static int
sync_attrs(LineWithAttrs *result, int extra_width)
{
const size_t nchars = utf8_strsw(result->line) + extra_width;
if(result->attrs_len < nchars)
{
char *const new_attrs = format_str("%s%*s", result->attrs,
(int)(nchars - result->attrs_len), "");
free(result->attrs);
result->attrs = new_attrs;
result->attrs_len = nchars;
}
return (result->attrs_len > nchars);
}
/* Prints number into the buffer. Returns non-zero if numeric value is
* "empty" (zero). */
static int
expand_num(char buf[], size_t buf_len, int val)
{
snprintf(buf, buf_len, "%d", val);
return (val == 0);
}
