/**
* -i?lname test.
*/
bool eval_lname(const struct expr *expr, struct eval_state *state) {
struct BFTW *ftwbuf = state->ftwbuf;
if (ftwbuf->typeflag != BFTW_LNK) {
return false;
}
const struct stat *statbuf = fill_statbuf(state);
if (!statbuf) {
return false;
}
size_t size = statbuf->st_size + 1;
char *name = malloc(size);
if (!name) {
eval_error(state);
return false;
}
ssize_t ret = readlinkat(ftwbuf->at_fd, ftwbuf->at_path, name, size);
if (ret < 0) {
eval_error(state);
return false;
} else if (ret >= size) {
return false;
}
name[ret] = '\0';
bool match = fnmatch(expr->sdata, name, expr->idata) == 0;
free(name);
return match;
}
static int
eval_match_comp(N_tag tag, bool_node *lhs, bool_node *rhs)
{
int sts;
char *res;
char *str= get_strvalue(lhs);
char *pat = get_strvalue(rhs);
if (rhs->tag != N_pat) {
eval_error("match");
}
res = re_comp(pat);
if (res != NULL) {
/* should have been checked at lex stage */
/* => internal error */
eval_error(res);
}
sts = re_exec(str);
if (sts < 0) {
eval_error("re_exec");
}
switch(tag) {
case N_match: return sts;
case N_nmatch: return !sts;
default:
eval_error("match comparison");
}/*switch*/
}
double nonlinear_constraint::eval_error(box const & b) const {
// Construct iv from box b
if (get_var_array().size() > 0) {
ibex::IntervalVector iv(get_var_array().size());
for (int i = 0; i < get_var_array().size(); i++) {
iv[i] = b[get_var_array()[i].name];
DREAL_LOG_DEBUG << get_var_array()[i].name << " = " << iv[i];
}
return eval_error(iv);
} else {
ibex::IntervalVector iv(1);
return eval_error(iv);
}
}
/**
* -i?name test.
*/
bool eval_name(const struct expr *expr, struct eval_state *state) {
struct BFTW *ftwbuf = state->ftwbuf;
const char *name = ftwbuf->path + ftwbuf->nameoff;
char *copy = NULL;
if (ftwbuf->depth == 0) {
// Any trailing slashes are not part of the name. This can only
// happen for the root path.
const char *slash = strchr(name, '/');
if (slash == name) {
// The name of "/" (or "//", etc.) is "/"
name = "/";
} else if (slash) {
copy = strdup(name);
if (!copy) {
eval_error(state);
return false;
}
copy[slash - name] = '\0';
name = copy;
}
}
bool ret = fnmatch(expr->sdata, name, expr->idata) == 0;
free(copy);
return ret;
}
/**
* Perform a stat() call if necessary.
*/
static const struct stat *fill_statbuf(struct eval_state *state) {
struct BFTW *ftwbuf = state->ftwbuf;
if (!ftwbuf->statbuf) {
if (fstatat(ftwbuf->at_fd, ftwbuf->at_path, &state->statbuf, ftwbuf->at_flags) == 0) {
ftwbuf->statbuf = &state->statbuf;
} else {
eval_error(state);
}
}
return ftwbuf->statbuf;
}
static int
eval_str_comp(N_tag tag, bool_node *lhs, bool_node *rhs)
{
char *x = get_strvalue(lhs);
char *y = get_strvalue(rhs);
switch(tag) {
case N_seq: return (strcmp(x,y)==0?1:0);
case N_sneq: return (strcmp(x,y)==0?0:1);
default:
eval_error("string comparison");
}/*switch*/
}
/**
* -empty test.
*/
bool eval_empty(const struct expr *expr, struct eval_state *state) {
bool ret = false;
struct BFTW *ftwbuf = state->ftwbuf;
if (ftwbuf->typeflag == BFTW_DIR) {
int dfd = openat(ftwbuf->at_fd, ftwbuf->at_path, O_DIRECTORY);
if (dfd < 0) {
eval_error(state);
goto done;
}
DIR *dir = fdopendir(dfd);
if (!dir) {
eval_error(state);
close(dfd);
goto done;
}
ret = true;
struct dirent *de;
while ((de = readdir(dir)) != NULL) {
if (strcmp(de->d_name, ".") != 0 && strcmp(de->d_name, "..") != 0) {
ret = false;
break;
}
}
closedir(dir);
} else {
const struct stat *statbuf = fill_statbuf(state);
if (statbuf) {
ret = statbuf->st_size == 0;
}
}
done:
return ret;
}
int lookup_id(char name[MAX_NAME]) {
char *tmp, *tmp1;
int i = symbol_table_top;
while (i-- >= 0) {
tmp1 = strrchr(symbol_table[i].name, '_');
if (!strcmp(symbol_table[i].name, name) || (tmp1 && !strcmp(tmp1 + 1, name)))
return i;
}
tmp = (char *) malloc(sizeof(char) * 256);
strcpy(tmp, "undefined variable ");
strcat(tmp, name);
eval_error(ERR_UNACCEPTABLE, tmp);
return -1; // if not found
}
/**
* -delete action.
*/
bool eval_delete(const struct expr *expr, struct eval_state *state) {
struct BFTW *ftwbuf = state->ftwbuf;
int flag = 0;
if (ftwbuf->typeflag == BFTW_DIR) {
flag |= AT_REMOVEDIR;
}
if (unlinkat(ftwbuf->at_fd, ftwbuf->at_path, flag) != 0) {
eval_error(state);
return false;
}
return true;
}
static int
eval_num_comp(N_tag tag, bool_node *lhs, bool_node *rhs)
{
double x = get_numvalue(lhs);
double y = get_numvalue(rhs);
switch(tag) {
case N_lt: return (x < y);
case N_gt: return (x > y);
case N_le: return (x <= y);
case N_ge: return (x >= y);
case N_eq: return (x == y);
case N_neq: return (x != y);
default:
eval_error("number comparison");
}/*switch*/
}
static int
eval_comparison(bool_node *comp)
{
bool_node *lhs = comp->data.children.left;
bool_node *rhs = comp->data.children.right;
switch(comp->tag) {
case N_lt: case N_gt: case N_ge: case N_le:
case N_eq: case N_neq:
return eval_num_comp(comp->tag, lhs, rhs);
case N_seq: case N_sneq:
return eval_str_comp(comp->tag, lhs, rhs);
case N_match: case N_nmatch:
return eval_match_comp(comp->tag, lhs, rhs);
default:
eval_error("comparison");
}/*switch*/
}
/**
* -xtype test.
*/
bool eval_xtype(const struct expr *expr, struct eval_state *state) {
struct BFTW *ftwbuf = state->ftwbuf;
bool is_root = ftwbuf->depth == 0;
bool follow = state->cmdline->flags & (is_root ? BFTW_FOLLOW_ROOT : BFTW_FOLLOW_NONROOT);
bool is_link = ftwbuf->typeflag == BFTW_LNK;
if (follow == is_link) {
return eval_type(expr, state);
}
// -xtype does the opposite of everything else
int at_flags = follow ? AT_SYMLINK_NOFOLLOW : 0;
struct stat sb;
if (fstatat(ftwbuf->at_fd, ftwbuf->at_path, &sb, at_flags) != 0) {
if (!follow && errno == ENOENT) {
// Broken symlink
return eval_type(expr, state);
} else {
eval_error(state);
return false;
}
}
switch (expr->idata) {
case BFTW_BLK:
return S_ISBLK(sb.st_mode);
case BFTW_CHR:
return S_ISCHR(sb.st_mode);
case BFTW_DIR:
return S_ISDIR(sb.st_mode);
case BFTW_FIFO:
return S_ISFIFO(sb.st_mode);
case BFTW_LNK:
return S_ISLNK(sb.st_mode);
case BFTW_REG:
return S_ISREG(sb.st_mode);
case BFTW_SOCK:
return S_ISSOCK(sb.st_mode);
}
return false;
}
static double
get_numvalue(bool_node *n)
{
switch(n->tag) {
case N_number: return n->data.num_val;
case N_cpuburn: return the_vars->cpuburn;
case N_syscalls: return the_vars->preds.syscalls;
case N_ctxswitch: return the_vars->preds.ctxswitch;
case N_virtualsize: return the_vars->preds.virtualsize;
case N_residentsize: return the_vars->preds.residentsize;
case N_iodemand: return the_vars->preds.iodemand;
case N_iowait: return the_vars->preds.iowait;
case N_schedwait: return the_vars->preds.schedwait;
case N_gid: return the_vars->gid;
case N_uid: return the_vars->uid;
default:
eval_error("number value");
}
}
// Evaluator
SEXP Rcpp_eval__impl(SEXP expr_, SEXP env) {
RCPP_DEBUG( "Rcpp_eval( expr = <%p>, env = <%p> )", expr_, env )
Scoped<SEXP> expr = expr_ ;
reset_current_error() ;
Environment RCPP = Environment::Rcpp11_namespace();
static SEXP tryCatchSym = NULL, evalqSym, conditionMessageSym, errorRecorderSym, errorSym ;
if (!tryCatchSym) {
tryCatchSym = ::Rf_install("tryCatch");
evalqSym = ::Rf_install("evalq");
conditionMessageSym = ::Rf_install("conditionMessage");
errorRecorderSym = ::Rf_install(".rcpp_error_recorder");
errorSym = ::Rf_install("error");
}
RCPP_DEBUG( " [Rcpp_eval] RCPP = " )
Scoped<SEXP> call = Rf_lang3(
tryCatchSym,
Rf_lang3( evalqSym, expr, env ),
errorRecorderSym
) ;
SET_TAG( CDDR(call), errorSym ) ;
/* call the tryCatch call */
Scoped<SEXP> res = ::Rf_eval( call, RCPP );
if( error_occured() ) {
Scoped<SEXP> current_error = rcpp_get_current_error() ;
Scoped<SEXP> conditionMessageCall = ::Rf_lang2(conditionMessageSym, current_error) ;
Scoped<SEXP> condition_message = ::Rf_eval(conditionMessageCall, R_GlobalEnv) ;
std::string message(CHAR(::Rf_asChar(condition_message)));
throw eval_error(message) ;
}
return res ;
}
static char *
get_strvalue(bool_node *n)
{
switch(n->tag) {
case N_str:
case N_pat:
return n->data.str_val;
case N_gname:
if (the_vars->gname != NULL)
return the_vars->gname;
else
return get_gname_info(the_vars->gid);
case N_uname:
if (the_vars->uname != NULL)
return the_vars->uname;
else
return get_uname_info(the_vars->uid);
case N_fname: return the_vars->fname;
case N_psargs: return the_vars->psargs;
default:
eval_error("string value");
}/*switch*/
}
double HcurlOrthoHP::calc_error_n(int n, ...)
{
int i, j, k;
if (n != num) error("Wrong number of solutions.");
// obtain solutions and bilinear forms
va_list ap;
va_start(ap, n);
for (i = 0; i < n; i++) {
sln[i] = va_arg(ap, Solution*);
sln[i]->set_quad_2d(&g_quad_2d_std);
}
for (i = 0; i < n; i++) {
rsln[i] = va_arg(ap, Solution*);
rsln[i]->set_quad_2d(&g_quad_2d_std);
}
va_end(ap);
// prepare multi-mesh traversal and error arrays
AUTOLA_OR(Mesh*, meshes, 2*num);
AUTOLA_OR(Transformable*, tr, 2*num);
Traverse trav;
nact = 0;
for (i = 0; i < num; i++)
{
meshes[i] = sln[i]->get_mesh();
meshes[i+num] = rsln[i]->get_mesh();
tr[i] = sln[i];
tr[i+num] = rsln[i];
nact += sln[i]->get_mesh()->get_num_active_elements();
int max = meshes[i]->get_max_element_id();
if (errors[i] != NULL) delete [] errors[i];
errors[i] = new double[max];
memset(errors[i], 0, sizeof(double) * max);
}
double total_norm = 0.0;
AUTOLA_OR(double, norms, num);
memset(norms, 0, num*sizeof(double));
double total_error = 0.0;
if (esort != NULL) delete [] esort;
esort = new int2[nact];
Element** ee;
trav.begin(2*num, meshes, tr);
while ((ee = trav.get_next_state(NULL, NULL)) != NULL)
{
for (i = 0; i < num; i++)
{
RefMap* rmi = sln[i]->get_refmap();
RefMap* rrmi = rsln[i]->get_refmap();
for (j = 0; j < num; j++)
{
RefMap* rmj = sln[j]->get_refmap();
RefMap* rrmj = rsln[j]->get_refmap();
double e, t;
if (form[i][j] != NULL)
{
#ifndef COMPLEX
e = fabs(eval_error(form[i][j], ord[i][j], sln[i], sln[j], rsln[i], rsln[j], rmi, rmj, rrmi, rrmj));
t = fabs(eval_norm(form[i][j], ord[i][j], rsln[i], rsln[j], rrmi, rrmj));
#else
e = std::abs(eval_error(form[i][j], ord[i][j], sln[i], sln[j], rsln[i], rsln[j], rmi, rmj, rrmi, rrmj));
t = std::abs(eval_norm(form[i][j], ord[i][j], rsln[i], rsln[j], rrmi, rrmj));
#endif
norms[i] += t;
total_norm += t;
total_error += e;
errors[i][ee[i]->id] += e;
}
}
}
}
trav.finish();
Element* e;
k = 0;
for (i = 0; i < num; i++)
for_all_active_elements(e, meshes[i]) {
esort[k][0] = e->id;
esort[k++][1] = i;
errors[i][e->id] /= norms[i];
}
