Exemple #1
0
/*
 *	check_equation_result()
 *
 *	Check the result returned by solve_equations().
 *
 *	@matrix: the matrix
 *	@ret: the results
 *	@mx: the number of columns of the matrix
 *	@my: the number of rows of the matrix
 */
bool check_equation_result(fact **matrix, exp *ret, int mx, int my) {
	fact *ptr_equ, **ptr_matrix;
	exp *rpptr, step;
	/*  Check results  */
	for (ptr_matrix = matrix; ptr_matrix < matrix + my; ptr_matrix++) {
		/*  Calculate the result of the equation  */
		step = expression_create(0, 1);
		for (ptr_equ = *ptr_matrix, rpptr = ret; ptr_equ < (*ptr_matrix) + mx - 1; ptr_equ++, rpptr++)
			if (!expression_double_operation(&step, fraction_plus, *rpptr, fraction_multiplination, *ptr_equ)) {
				free_expression(&step);
				return(false);
			}

		if (!simplify_expression_node(&step)) {
			free_expression(&step);
			return(false);
		}

		/*  Compare it with the constant of the equation  */
		if (!(step.count == 0 && fraction_compare(step.cst, *((*ptr_matrix) + mx - 1)) == 0)) {
			free_expression(&step);
			return(false);
		}
		free_expression(&step);
	}
	return(true);
}
Exemple #2
0
static int evaluate_binary_expression(struct expression *in,
				      struct expression *out, char **error)
{
	int result = STATUS_ERR;
	assert(in->type == EXPR_BINARY);
	assert(in->value.binary);
	out->type = EXPR_INTEGER;

	struct expression *lhs = NULL;
	struct expression *rhs = NULL;
	if (evaluate(in->value.binary->lhs, &lhs, error))
		goto error_out;
	if (evaluate(in->value.binary->rhs, &rhs, error))
		goto error_out;
	if (strcmp("|", in->value.binary->op) == 0) {
		if (lhs->type != EXPR_INTEGER) {
			asprintf(error, "left hand side of | not an integer");
		} else if (rhs->type != EXPR_INTEGER) {
			asprintf(error, "right hand side of | not an integer");
		} else {
			out->value.num = lhs->value.num | rhs->value.num;
			result = STATUS_OK;
		}
	} else {
		asprintf(error, "bad binary operator '%s'",
			 in->value.binary->op);
	}
error_out:
	free_expression(rhs);
	free_expression(lhs);
	return result;
}
Exemple #3
0
void
free_bool_expression(bool_expression *expr)
{
  free_expression(expr->left);
  if (expr->op) free(expr->op);
  if (expr->right) free_expression(expr->right);
  free(expr);
}
Exemple #4
0
void
free_expression(expression *expr)
{
  if (expr->op == 0) {
    free_value((value*)expr->left);
  } else {
    free_expression((expression*) expr->left);
    free_expression(expr->right);
  }
  free(expr);
}
Exemple #5
0
/* 
 * free memory allocated by a rule 
 */
void free_rule(rule *r) 
{
	if (!r) return;
		
	if (r->left) free_expression(r->left);
	if (r->left_exceptions) free_expression(r->left_exceptions);
	if (r->right) free_expression(r->right);
	if (r->right_exceptions) free_expression(r->right_exceptions);

	if (r->next) free_rule(r->next);
	pkg_free(r);
}
Exemple #6
0
void free_instruction(struct instruction *i)
{
  switch (i->kind)
  {
    case assignment:
      free_expression(i->instr.assignment->e1);
      free_expression(i->instr.assignment->e2);
      free(i->instr.assignment);
      break;
    case switchcase:
      free_caseblocklist(i->instr.switchcase->caseblocklist);
      free_instructions(i->instr.switchcase->otherwiseblock);
      free_expression(i->instr.switchcase->cond);
      free(i->instr.switchcase);
      break;
    case dowhile:
      free_expression(i->instr.dowhile->cond);
      free_instructions(i->instr.dowhile->instructions);
      free(i->instr.dowhile);
      break;
    case whiledo:
      free_expression(i->instr.whiledo->cond);
      free_instructions(i->instr.whiledo->instructions);
      free(i->instr.whiledo);
      break;
    case forloop:
      free_expression(i->instr.forloop->assignment->e1);
      free_expression(i->instr.forloop->assignment->e2);
      free(i->instr.forloop->assignment);
      free_instructions(i->instr.forloop->instructions);
      free_expression(i->instr.forloop->upto);
      free(i->instr.forloop);
      break;
    case funcall:
      free_args(i->instr.funcall->args);
      free(i->instr.funcall->fun_ident);
      free(i->instr.funcall);
      break;
    case ifthenelse:
      free_expression(i->instr.ifthenelse->cond);
      free_instructions(i->instr.ifthenelse->instructions);
      free_instructions(i->instr.ifthenelse->elseblock);
      free(i->instr.ifthenelse);
      break;
    case returnstmt:
      free_expression(i->instr.returnstmt->expr);
      free(i->instr.returnstmt);
      break;
  }
  free(i);
}
Exemple #7
0
int add_column(screen_t* const s, char* header, char* format, char* desc,
               char* expr)
{
  int col_width, err=0;
  int n = s->num_columns;

  expression* e = parser_expression(expr);

  if (e == NULL || e->type == ERROR) {
    free_expression(e);
    error_printf("Invalid expression in column '%s', screen '%s': column ignored\n",
                 header, s->name);
    return -1;
  }

  check_counters_used(e, s, &err);
  if( err > 0 ) {
    free_expression(e);
    return -1;
  }

  if (n == s->num_alloc_columns) {
    s->columns = realloc(s->columns, sizeof(column_t) * (n + alloc_chunk));
    s->num_alloc_columns += alloc_chunk;
  }
  init_column(&s->columns[n]);
  s->columns[n].expression = e;
  s->columns[n].header = strdup(header);
  s->columns[n].format = strdup(format);

  col_width = strlen(header);
  /* setup an empty field with proper width */
  s->columns[n].empty_field = malloc(col_width + 1);
  memset(s->columns[n].empty_field, ' ', col_width - 1);
  s->columns[n].empty_field[col_width - 1] = '-';
  s->columns[n].empty_field[col_width] = '\0';

  /* setup an error field with proper width */
  s->columns[n].error_field = malloc(col_width + 1);
  memset(s->columns[n].error_field, ' ', col_width - 1);
  s->columns[n].error_field[col_width - 1] = '?';
  s->columns[n].error_field[col_width] = '\0';

  if (desc)
    s->columns[n].description = strdup(desc);
  else
    s->columns[n].description = strdup("(unknown)");

  s->num_columns++;
  return n;
}
Exemple #8
0
void free_expression(expression *expr)
{
  expression *c;

  if (NULL == expr)
    return;

  free_qname(expr->qn);
  free(expr->str);
  free(expr->ident);
  free(expr->orig);

  free_expression(expr->r.test);
  free_expression(expr->r.left);
  free_expression(expr->r.right);

  free_expression(expr->r.name_avt);
  free_expression(expr->r.value_avt);
  free_expression(expr->r.namespace_avt);

  for (c = expr->r.children; c; c = c->next)
    free_expression(c);
  for (c = expr->r.attributes; c; c = c->next)
    free_expression(c);

  free(expr);
}
Exemple #9
0
static void
test_reduce_different_currency() {
  Expression *two_franc = franc( 2 );
  Expression *one_dollar = dollar( 1 );

  add_rate( CHF, USD, 2 );
  Money *result = reduce( two_franc, USD );
  assert_true( equal( result, money_from( one_dollar ) ) );

  free_expression( two_franc );
  free_expression( one_dollar );
  free_money( result );
  delete_all_rates();
}
Exemple #10
0
static void
test_plus_returns_sum() {
  Expression *five = dollar( 5 );
  Expression *addend_five = dollar( 5 );

  Expression *result = plus( five, addend_five );
  Sum *sum = ( Sum * ) result->value;
  assert_true( equal( money_from( five ), money_from( sum->augend ) ) );
  assert_true( equal( money_from( addend_five ), money_from( sum->addend ) ) );

  free_expression( five );
  free_expression( addend_five );
  free_expression( result );
  delete_all_rates();
}
Exemple #11
0
static void
test_multiply_dollar_5x2() {
  Expression *five = dollar( 5 );
  Expression *product = multiply( five, 2 );
  Expression *ten = dollar( 10 );
  Money *reduced =  reduce( product, USD );

  assert_true( equal( reduced, money_from( ten ) ) );

  free_expression( five );
  free_expression( product );
  free_expression( ten );
  free_money( reduced );
  delete_all_rates();
}
Exemple #12
0
static void
test_multiply_dollar_5x3x3() {
  Expression *five = dollar( 5 );
  Expression *product1 = multiply( five, 3 );
  Expression *product2 = multiply( product1, 3 );
  Expression *fortyfive = dollar( 45 );
  Money *reduced = reduce( product2, USD );

  assert_true( equal( reduced, money_from( fortyfive ) ) );

  free_expression( five );
  free_expression( product1 );
  free_expression( product2 );
  free_expression( fortyfive );
  free_money( reduced );
  delete_all_rates();
}
Exemple #13
0
static void
test_equal() {
  Expression *five_dollar1 = dollar( 5 );
  Expression *five_dollar2 = dollar( 5 );
  Expression *six_dollar = dollar( 6 );
  Expression *five_franc = franc( 5 );

  assert_true( equal( money_from( five_dollar1 ), money_from( five_dollar2 ) ) );
  assert_false( equal( money_from( five_dollar1 ), money_from( six_dollar ) ) );
  assert_false( equal( money_from( five_dollar1 ), money_from( five_franc ) ) );

  free_expression( five_dollar1 );
  free_expression( five_dollar2 );
  free_expression( six_dollar );
  free_expression( five_franc );
  delete_all_rates();
}
Exemple #14
0
void expr_put(struct expression *expr)
{
	assert(expr->refcount > 0);

	expr->refcount--;
	if (expr->refcount == 0)
		free_expression(expr);
}
Exemple #15
0
/* 
 * free memory allocated by an expression 
 */
void free_expression(expression *e) 
{
	if (!e) return;

	if (e->next) free_expression(e->next);
	regfree(e->reg_value);
	pkg_free(e);
}
Exemple #16
0
static void
test_simple_addition() {
  Expression *five = dollar( 5 );
  Expression *addend_five = dollar( 5 );
  Expression *ten = dollar( 10 );

  Expression *sum = plus( five, addend_five );
  Money *reduced = reduce( sum, USD );
  assert_true( equal( money_from( ten ), reduced ) );

  free_expression( five );
  free_expression( addend_five );
  free_expression( sum );
  free_money( reduced );
  free_expression( ten );
  delete_all_rates();
}
Exemple #17
0
static void
test_reduce_sum() {
  Expression *three_usd = dollar( 3 );
  Expression *four_usd = dollar( 4 );
  Expression *seven_usd = dollar( 7 );

  Expression *exp = plus( three_usd, four_usd );
  Money *result = reduce( exp , USD );
  assert_true( equal( result , money_from( seven_usd ) ) );

  free_expression( three_usd );
  free_expression( four_usd );
  free_expression( seven_usd );
  free_expression( exp );
  free_money( result );
  delete_all_rates();
}
Exemple #18
0
static void
test_mixed_addition() {
  Expression *five_bucks = dollar( 5 );
  Expression *ten_francs = franc( 10 );
  Expression *ten_usd = dollar( 10 );

  add_rate( CHF, USD, 2 );
  Expression *exp = plus( five_bucks, ten_francs );
  Money *result = reduce( exp, USD );
  assert_true( equal( money_from( ten_usd ), result ) );

  free_expression( five_bucks );
  free_expression( ten_francs );
  free_expression( ten_usd );
  free_expression( exp );
  free_money( result );
  delete_all_rates();
}
Exemple #19
0
void free_expression_list(struct expression_list *list)
{
	while (list != NULL) {
		free_expression(list->expression);
		struct expression_list *dead = list;
		list = list->next;
		free(dead);
	}
}
Exemple #20
0
void free_args(arglist_t args)
{
  for (unsigned i = 0; i < args.size; ++i)
  {
    free_expression(args.data[i]->e);
    free(args.data[i]);
  }
  list_free(args);
}
int
parse_expression(tk_expr_t **expr_p, const char *buf, size_t size, int debug) {
    void *ybuf;
    ybuf = yy_scan_bytes(buf, size);
    if(!ybuf) {
        assert(ybuf);
        return -1;
    }

    if(expr_p) *expr_p = 0;

    tk_expr_t *expr = 0;

    int ret = yyparse((void *)&expr);

    yy_delete_buffer(ybuf);

    if(ret == 0) {
        assert(expr);
        if(expr->type == EXPR_DATA) {
            /* Trivial expression found, should exactly match input. */
            assert(expr->u.data.size == size);
            assert(memcmp(expr->u.data.data, buf, size) == 0);
            if(expr_p)
                *expr_p = expr;
            else
                free_expression(expr);
            return 0; /* No expression found */
        } else {
            if(expr_p)
                *expr_p = expr;
            else
                free_expression(expr);
            return 1;
        }
    } else {
        char tmp[PRINTABLE_DATA_SUGGESTED_BUFFER_SIZE(size)];
        DEBUG("Failed to parse \"%s\"\n",
              printable_data(tmp, sizeof(tmp), buf, size, 1));
        free_expression(expr);
        return -1;
    }
}
Exemple #22
0
/*
 * parse a complex expression list like a, b, c EXCEPT d, e
 * return 0 on success, -1 on error
 * parsed expressions are returned in **e, and exceptions are returned in **e_exceptions
 */
static int parse_expression(char *str, expression **e, expression **e_exceptions) 
{
	char 	*except, str2[LINE_LENGTH];
	int	i=0, l;

	if (!str || !e || !e_exceptions) return -1;

	except = strstr(str, " EXCEPT ");
	if (except) {
		/* exception found */
		l = except-str;
		if (l >= LINE_LENGTH) {
			/* error */
			LOG(L_ERR, "ERROR: parse_expression(): too long config line, increase LINE_LENGTH\n");
			goto error;
		}

		strncpy(str2, str, l);
		str2[l] = '\0';
		/* except+8 points to the exception */
		if (parse_expression_list(except+8, e_exceptions)) {
			/* error */
			goto error;
		}
	} else {
		/* no exception */
		l = strlen(str);
		if (l >= LINE_LENGTH) {
			/* error */
			LOG(L_ERR, "ERROR: parse_expression(): too long config line, increase LINE_LENGTH\n");
			goto error;
		}
		
		strncpy(str2, str, l);
		str2[l] = '\0';
		*e_exceptions = NULL;
	}
	
	while ((str2[i] == ' ') || (str2[i] == '\t')) i++;
	
	if (strncmp("ALL", str2+i, 3) == 0) {
		*e = NULL;
	} else {
		if (parse_expression_list(str2+i, e)) {
			/* error */
			if (*e_exceptions) free_expression(*e_exceptions);
			goto error;
		}
	}
	return 0;

error:
	*e = *e_exceptions = NULL;
	return -1;
}
Exemple #23
0
static void
test_multiple_addition() {
  Expression *five_bucks = dollar( 5 );
  Expression *ten_francs = franc( 10 );
  Expression *fifteen_bucks = dollar( 15 );

  add_rate( CHF, USD, 2 );
  Expression *exp1 = plus( five_bucks, ten_francs );
  Expression *exp2 = plus( exp1, five_bucks );
  Money *result = reduce( exp2, USD );
  assert_true( equal( money_from( fifteen_bucks ), result ) );

  free_expression( five_bucks );
  free_expression( ten_francs );
  free_expression( fifteen_bucks );
  free_expression( exp1 );
  free_expression( exp2 );
  free_money( result );
  delete_all_rates();
}
Exemple #24
0
void free_intlist(intlist_t dims)
{

  for (unsigned i = 0; i < dims.size; ++i)
  {
    if(dims.data[i] != NULL)
      free_expression(dims.data[i]);
  }
  list_free(dims);

}
void
free_expression(tk_expr_t *expr) {
    if(expr) {
        switch(expr->type) {
        case EXPR_DATA:
            free((void *)expr->u.data.data);
            break;
        case EXPR_MODULO:
            free_expression((void *)expr->u.modulo.expr);
            break;
        case EXPR_CONCAT:
            free_expression(expr->u.concat.expr[0]);
            free_expression(expr->u.concat.expr[1]);
            break;
        case EXPR_CONNECTION_PTR:
        case EXPR_CONNECTION_UID:
            break;
        }
    }
}
Exemple #26
0
struct expr *infix(struct expr *left, char *expect)
{
  exprlist_t args;
  int toktype = tok->type;
  char *ident;
  switch (toktype)
  {
    case PLUS: case MINUS: case STAR: case SLASH: case OR: case XOR:
    case LT: case LE: case GT: case GE: case NEQ: case EQ: case AND:
      return binopexpr(left, toktype, expression(lbp(toktype)));
    case LPAREN:
      if (left->exprtype != identtype)
        syntaxerror("calling non-callable expression");
      args = empty_exprlist();
      if (lookahead[0]->type != COMMA && lookahead[0]->type != RPAREN)
        list_push_back(args, expression(0));
      while (lookahead[0]->type == COMMA)
      {
        eat(COMMA);
        list_push_back(args, expression(0));
      }
      eat(RPAREN);
      ident = strdup(left->val.ident);
      left->type = NULL; // To prevent segfaults when freeing the expr
      free_expression(left);
      return funcallexpr(ident, args);
    case LSQBRACKET:
      args = empty_exprlist();
      list_push_back(args, expression(0));
      while (lookahead[0]->type == COMMA)
      {
        eat(COMMA);
        list_push_back(args, expression(0));
      }
      eat(RSQBRACKET);
      return arrayexpr(left, args);
    case DOT:
      eat(IDENTIFIER);
      char *ident = strdup(tok->val);
      return record_access(left, ident);
    case DEREF:
      return make_deref(left);
    default:
      syntaxerror("expected %s, not %s", expect, tok->val);
      next();
      switch (tok->type)
      {
        case ENDOFFILE: return expr_from_val(0);
        default: return infix(left, "expression");
      }
  }
}
Exemple #27
0
static void delete_column(column_t* t)
{
  if(t->expression)
    free_expression(t->expression);
  if(t->description)
    free(t->description);
  if(t->format)
    free(t->format);
  if (t->header)
    free(t->header);
  free(t->error_field);
  free(t->empty_field);
}
Exemple #28
0
/* Adding a new counter in counters list */
int add_counter(screen_t* const s, char* alias, char* config, char* type)
{
  uint64_t int_conf = 0;
  uint32_t int_type = 0;
  int err=0;
  int n;
  expression* expr = NULL;

  if (s->num_counters >=  MAX_EVENTS) {
    error_printf("Too many counters (max %d) in screen '%s', ignoring '%s'\n"
                 "(change MAX_EVENTS and recompile)\n",
                 MAX_EVENTS, s->name, alias);
    return -1;
  }

  int_type = get_counter_type(type, &err);

  if (err > 0) {
    /* error*/
    error_printf("Bad type '%s': ignoring counter '%s'\n", type, alias);
    return -1;
  }

  /* Parse the configuration */
  expr = parser_expression(config);

  err=0;
  int_conf = evaluate_counter_expression(expr, &err);

  free_expression(expr);

  if (err > 0) {
    /* error*/
    error_printf("Bad config '%s': ignoring counter '%s'\n", config, alias);
    return -1;
  }

  n = s->num_counters;
  /* check max available hw counter */
  if (n == s->num_alloc_counters) {
    s->counters = realloc(s->counters, sizeof(counter_t) * (n + alloc_chunk));
    s->num_alloc_counters += alloc_chunk;
  }
  /* initialisation */
  s->counters[n].used = 0;
  s->counters[n].type = int_type;
  s->counters[n].config = int_conf;
  s->counters[n].alias = strdup(alias);
  s->num_counters++;
  return n;
}
int	get_value_calculated(DC_ITEM *dc_item, AGENT_RESULT *result)
{
	const char	*__function_name = "get_value_calculated";
	expression_t	exp;
	int		ret;
	char		error[MAX_STRING_LEN];
	double		value;

	zabbix_log(LOG_LEVEL_DEBUG, "In %s() key:'%s' expression:'%s'", __function_name,
			dc_item->key_orig, dc_item->params);

	memset(&exp, 0, sizeof(exp));

	if (SUCCEED != (ret = calcitem_parse_expression(dc_item, &exp, error, sizeof(error))))
	{
		SET_MSG_RESULT(result, strdup(error));
		goto clean;
	}

	if (SUCCEED != (ret = calcitem_evaluate_expression(dc_item, &exp, error, sizeof(error))))
	{
		SET_MSG_RESULT(result, strdup(error));
		goto clean;
	}

	if (SUCCEED != evaluate(&value, exp.exp, error, sizeof(error)))
	{
		SET_MSG_RESULT(result, strdup(error));
		ret = NOTSUPPORTED;
		goto clean;
	}

	zabbix_log(LOG_LEVEL_DEBUG, "%s() value:" ZBX_FS_DBL, __function_name, value);

	if (ITEM_VALUE_TYPE_UINT64 == dc_item->value_type && 0 > value)
	{
		SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Received value [" ZBX_FS_DBL "]"
				" is not suitable for value type [%s].",
				value, zbx_item_value_type_string(dc_item->value_type)));
		ret = NOTSUPPORTED;
		goto clean;
	}

	SET_DBL_RESULT(result, value);
clean:
	free_expression(&exp);

	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));

	return ret;
}
/*
 * parse a complex expression list like a, b, c EXCEPT d, e
 * return 0 on success, -1 on error
 * parsed expressions are returned in **e, and exceptions are returned in **e_exceptions
 */
static int parse_expression(char *sv, expression **e, expression **e_exceptions)
{
	char *except, str2[LINE_LENGTH+1];
	int  i,j;

	if (!sv || !e || !e_exceptions) return -1;

	if(strlen(sv)>=LINE_LENGTH) {
		LM_ERR("expression string is too long (%s)\n", sv);
		return -1;
	}

	except = strstr(sv, " EXCEPT ");
	if (except) {
		/* exception found */
		strncpy(str2, sv, except-sv);
		str2[except-sv] = '\0';
		/* except+8 points to the exception */
		if (parse_expression_list(except+8, e_exceptions)) {
			/* error */
			*e = *e_exceptions = NULL;
			return -1;
		}
	} else {
		/* no exception */
		strcpy(str2, sv);
		*e_exceptions = NULL;
	}

	for( i=0; isspace((int)str2[i]) ; i++);
	for( j=strlen(str2)-1 ; isspace((int)str2[j]) ; str2[j--]=0);

	if (strcmp("ALL", str2+i) == 0) {
		*e = NULL;
	} else {
		if (parse_expression_list(str2+i, e)) {
			/* error */
			if (*e_exceptions) free_expression(*e_exceptions);
			*e = *e_exceptions = NULL;
			return -1;
		}
	}
	return 0;
}