static void
expression_free(expression *expression)
{
if (expression) {
expression_free(expression->left);
expression_free(expression->right);
free(expression->value);
free(expression);
}
}
bool debug_view_expression::recompute()
{
bool changed = m_dirty;
// if dirty, re-evaluate
if (m_dirty)
{
// parse the new expression
parsed_expression *expr;
EXPRERR exprerr = expression_parse(m_string, m_context, &debug_expression_callbacks, &m_machine, &expr);
// if it worked, update the expression
if (exprerr == EXPRERR_NONE)
{
if (m_parsed != NULL)
expression_free(m_parsed);
m_parsed = expr;
}
}
// if we have a parsed expression, evalute it
if (m_parsed != NULL)
{
UINT64 oldresult = m_result;
// recompute the value of the expression
expression_execute(m_parsed, &m_result);
if (m_result != oldresult)
changed = true;
}
// expression no longer dirty by definition
m_dirty = false;
return changed;
}
static expression *
get_expression(const char *selector)
{
freesasa_yyscan_t scanner;
YY_BUFFER_STATE state;
int err;
expression *expression = NULL;
if (freesasa_yylex_init(&scanner)) {
fail_msg("lexer failed");
} else {
state = freesasa_yy_scan_string(selector, scanner);
err = freesasa_yyparse(&expression, scanner);
if (err) {
if (err == 1) fail_msg("parser failed");
if (err == 2) mem_fail();
expression_free(expression);
expression = NULL;
}
freesasa_yy_delete_buffer(state, scanner);
freesasa_yylex_destroy(scanner);
}
return expression;
}
int
main (int argc, char **argv)
{
// faire en sorte qu'interactive_mode = 0 lorsque le shell est distant
if (interactive_mode)
{
using_history();
}
else
{
// mode distant
}
while (1){
if (my_yyparse () == 0) { /* L'analyse a abouti */
afficher_expr(ExpressionAnalysee);
status = evaluer_expr(ExpressionAnalysee);
//printf("Salut %s",ExpressionAnalysee->type);
fflush(stdout);
expression_free(ExpressionAnalysee);
}
else {
/* L'analyse de la ligne de commande a donn� une erreur */
}
}
return 0;
}
expression *
freesasa_selection_operation(expression_type type,
expression *left,
expression *right)
{
expression *e = expression_new();
if (e == NULL) {
expression_free(left);
expression_free(right);
} else {
e->type = type;
e->left = left;
e->right = right;
}
return e;
}
/*
* Libération de la mémoire occupée par une expression
*/
void
expression_free(Expression *e)
{
if (e == NULL)
return;
expression_free(e->gauche);
expression_free(e->droite);
if (e->arguments != NULL)
{
for (int i = 0; e->arguments[i] != NULL; i++)
free(e->arguments[i]);
free(e->arguments);
}
free(e);
}
expression *
freesasa_selection_atom(expression_type type,
const char* val)
{
expression *e = expression_new();
int i, n;
char *buf;
assert(val);
if (e != NULL) {
if (type == E_NEGNUM) {
n = strlen(val)+2;
buf = malloc(n);
if (buf == NULL) {
mem_fail();
expression_free(e);
return NULL;
}
sprintf(buf, "-%s", val);
e->type = E_NUMBER;
e->value = strdup(buf);
free(buf);
} else {
e->type = type;
e->value = strdup(val);
}
if (e->value == NULL) {
mem_fail();
expression_free(e);
return NULL;
}
for (i = 0; i < strlen(e->value); ++i)
e->value[i] = toupper(e->value[i]);
}
return e;
}
void instruction_free (instruction * i)
{
switch (i->type)
{
case INSTR_CALL:
free (i->content.call.identifier);
expression_list_free (i->content.call.arguments);
break;
case INSTR_FOR:
free (i->content.loop.identifier);
expression_free (i->content.loop.left_boundary);
expression_free (i->content.loop.right_boundary);
instruction_list_free (i->content.loop.body);
break;
case INSTR_IF:
case INSTR_IF_ELSE:
expression_free (i->content.branch.condition);
instruction_list_free (i->content.branch.true_body);
if (i->content.branch.has_else)
instruction_list_free (i->content.branch.false_body);
break;
case INSTR_ADVANCE:
break;
case INSTR_FINISH:
case INSTR_ASYNC:
case INSTR_CLOCKED_FINISH:
case INSTR_CLOCKED_ASYNC:
instruction_list_free (i->content.block);
break;
default:
break;
}
free (i->annotation.level);
free (i->annotation.boundaries);
expression_free (i->annotation.date);
free (i);
}
expression *
freesasa_selection_create(expression *selection,
const char* id)
{
expression *e = expression_new();
assert(id);
if (e == NULL) expression_free(selection);
else {
e->type = E_SELECTION;
e->left = selection;
e->value = strdup(id);
if (e->value == NULL) {
mem_fail();
expression_free(e);
e = NULL;
}
}
return e;
}
expression *
freesasa_selection_selector(expression_type type,
expression *list)
{
expression *e = expression_new();
if (e == NULL) {
expression_free(list);
} else {
e->type = type;
e->left = list;
}
return e;
}
int
main (int argc, char **argv)
{
if(argc == 2)
interactive_mode = 0;
// faire en sorte qu'interactive_mode = 0 lorsque le shell est distant
if (interactive_mode)
{
using_history();
}
else
{
// mode distant
}
while (1){
if (my_yyparse () == 0) { /* L'analyse a abouti */
// afficher_expr(ExpressionAnalysee);
//printf("\n%s\n", ExpressionAnalysee->arguments[0]);
evaluer_expr(ExpressionAnalysee);
//echo(LongueurListe(ExpressionAnalysee->arguments), ExpressionAnalysee->arguments);
// printf("\n%s\n", choices[4]);
fflush(stdout);
expression_free(ExpressionAnalysee);
}
else {
/* L'analyse de la ligne de commande a donné une erreur */
}
}
wait(NULL);
return 0;
}
void instruction_list_compute_dates (instruction_list * list,
const expression * e, const char * identifier)
{
/* Count the advances. */
expression * advance_count = _count_advances (list);
/* Compute the dates for the current level. */
for (instruction_list * current = list; current != NULL;
current = current->next)
{
expression * date;
if (identifier == NULL)
{
/* No identifier? Not in a for loop. */
date = expression_alloc ();
date->type = EXPR_NUMBER;
date->content.number = 0;
}
else
{
expression * id_expr = expression_alloc ();
expression * factor = expression_copy (advance_count);
id_expr->type = EXPR_ID;
id_expr->content.identifier = strdup (identifier);
date = expression_mult (id_expr, factor);
}
if (e != NULL)
{
expression * upper_level = expression_copy (e);
date = expression_add (date, upper_level);
}
current->element->annotation.date = date;
}
/* Add the advances. */
expression * advances = expression_alloc ();
advances->type = EXPR_NUMBER;
advances->content.number = 0;
for (instruction_list * current = list; current != NULL;
current = current->next)
{
instruction * i = current->element;
instruction_type t = i->type;
i->annotation.date = expression_add (i->annotation.date,
expression_copy (advances));
if (t == INSTR_ADVANCE)
{
if (advances->type == EXPR_NUMBER)
advances->content.number++;
else
{
expression * right = expression_alloc ();
right->type = EXPR_NUMBER;
right->content.number = 1;
advances = expression_add (advances, right);
}
}
else if (t == INSTR_FOR)
{
expression * left = expression_copy
(current->element->content.loop.left_boundary);
expression * right = expression_copy
(current->element->content.loop.right_boundary);
expression * bounds = expression_sub
(right, left);
expression * for_block_advances = _count_advances
(current->element->content.loop.body);
expression * for_advances =
expression_mult (bounds, for_block_advances);
advances = expression_add (advances, for_advances);
}
}
/* Compute the dates for the inner levels. */
for (instruction_list * current = list; current != NULL;
current = current->next)
{
instruction * i = current->element;
instruction_type t = i->type;
if (t != INSTR_CALL && t != INSTR_ADVANCE && t != INSTR_UNKNOWN)
{
if (t == INSTR_FOR)
{
expression * date = expression_sub
(expression_copy (i->annotation.date),
expression_copy (i->content.loop.left_boundary));
instruction_list_compute_dates (i->content.loop.body,
date, i->content.loop.identifier);
expression_free (date);
}
else if (t == INSTR_IF)
instruction_list_compute_dates (i->content.branch.true_body,
i->annotation.date, identifier);
else if (t == INSTR_IF_ELSE)
{
instruction_list_compute_dates (i->content.branch.true_body,
i->annotation.date, identifier);
instruction_list_compute_dates (i->content.branch.false_body,
i->annotation.date, identifier);
}
else
instruction_list_compute_dates (i->content.block,
i->annotation.date, NULL);
}
}
expression_free (advance_count);
expression_free (advances);
}
debug_view_expression::~debug_view_expression()
{
// free our parsed expression
if (m_parsed != NULL)
expression_free(m_parsed);
}
static int
select_area_impl(const char *command,
char *name,
double *area,
const freesasa_structure *structure,
const freesasa_result *result)
{
struct selection *selection = NULL;
struct expression *expression = NULL;
const int maxlen = FREESASA_MAX_SELECTION_NAME;
double sasa = 0;
int err = 0, warn = 0, n_atoms = 0, j, len;
assert(name); assert(area);
assert(command); assert(structure); assert(result);
assert(freesasa_structure_n(structure) == result->n_atoms);
*area = 0;
name[0] = '\0';
expression = get_expression(command);
selection = selection_new(result->n_atoms);
if (selection == NULL) {
return fail_msg("");
}
if (expression != NULL && selection != NULL) {
switch (select_atoms(selection, expression, structure)) {
case FREESASA_FAIL:
err = 1;
break;
case FREESASA_WARN:
warn = 1; /* proceed with calculation, print warning later */
case FREESASA_SUCCESS: {
for (j = 0; j < selection->size; ++j) {
++n_atoms;
sasa += selection->atom[j]*result->sasa[j];
}
*area = sasa;
len = strlen(selection->name);
if (len > maxlen) {
strncpy(name,selection->name,maxlen);
name[maxlen] = '\0';
}
else {
strncpy(name,selection->name,len);
name[len] = '\0';
}
break;
}
default:
assert(0);
}
} else {
err = 1;
}
selection_free(selection);
expression_free(expression);
if (err)
return fail_msg("problems parsing expression '%s'",command);
if (warn)
return freesasa_warn("in %s(): There were warnings",__func__);
return n_atoms;
}
