expressions.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "linear.h"
#include "genC.h"
#include "misc.h"
#include "ri.h"
#include "properties.h"
#include "ri-util.h"
#include "workspace-util.h"

Include dependency graph for expressions.c:

Go to the source code of this file.

Functions
expression	string_to_expression (const char *s, entity module)
	Functions using simultaneously pipsdbm, which is based on strings, and ri-util, which contains basic methods for the objects of the internal representation. More...
list	string_to_expressions (const char *str, const char *seed, entity module)
	split a string using seed as separator and call string_to_expression on each chunk More...

Function Documentation

string_to_expression()

expression string_to_expression	(	const char *	s,
		entity	module
	)

Functions using simultaneously pipsdbm, which is based on strings, and ri-util, which contains basic methods for the objects of the internal representation.

expressions.c

try to parse s in the context of module module only simple expressions are found

try to find simple expression

unary operators

inary operators

Parameters

module

odule

Definition at line 50 of file expressions.c.

{
    entity e = string_to_entity(s,module);
    if(entity_undefined_p(e)) {
        /* try to find simple expression */
        /* unary operators */
        for(const char *iter = s ; *iter ; iter++) {
            if(isspace(*iter)) continue;
            if(*iter=='-') {
                expression etmp = string_to_expression(iter+1, module);
                if(!expression_undefined_p(etmp)) {
                    return MakeUnaryCall(entity_intrinsic(UNARY_MINUS_OPERATOR_NAME),
                            etmp);
                }
            }
        }
        
        /*binary operators*/
        static const char* seeds[] = {   PLUS_OPERATOR_NAME, MINUS_OPERATOR_NAME,MULTIPLY_OPERATOR_NAME, DIVIDE_OPERATOR_NAME};
        for(int i=0; i < (int) (sizeof(seeds)/sizeof(seeds[0])); i++) {
            char *where = strchr(s,seeds[i][0]);
            if(where) {
                char * head = strdup(s);
                char * tail = head + (where -s) +1 ;
                head[where-s]='\0';
                expression e0 = string_to_expression(head,module);
                expression e1 = string_to_expression(tail,module);
                free(head);
                if(!expression_undefined_p(e0) &&!expression_undefined_p(e1)) {
                    return MakeBinaryCall(
                            entity_intrinsic(seeds[i]),
                            e0,
                            e1
                            );
                }
                else {
                    free_expression(e0);
                    free_expression(e1);
                }
            }
        }
        return expression_undefined;
    }
    else
        return entity_to_expression(e);
}

References DIVIDE_OPERATOR_NAME, entity_intrinsic(), entity_to_expression(), entity_undefined_p, expression_undefined, expression_undefined_p, free(), free_expression(), int, MakeBinaryCall(), MakeUnaryCall(), MINUS_OPERATOR_NAME, module, MULTIPLY_OPERATOR_NAME, PLUS_OPERATOR_NAME, strdup(), string_to_entity(), and UNARY_MINUS_OPERATOR_NAME.

Referenced by loop_expansion(), loop_expansion_init(), maxima_simplify(), and string_to_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

string_to_expressions()

list string_to_expressions	(	const char *	str,
		const char *	seed,
		entity	module
	)

split a string using seed as separator and call string_to_expression on each chunk

Parameters

str	tr
seed	eed
module	odule

Definition at line 98 of file expressions.c.

                                                                               {
    list strings = strsplit(str,seed);
    list expressions = NIL;
    FOREACH(STRING,s,strings) {
        expression expr = string_to_expression(s,module);
        if(!expression_undefined_p(expr)) {
            expressions = CONS(EXPRESSION,
                    expr,
                    expressions);
        }
    }
    gen_map(free,strings);
    gen_free_list(strings);
    return gen_nreverse(expressions);
}

References CONS, EXPRESSION, expression_undefined_p, FOREACH, free(), gen_free_list(), gen_map(), gen_nreverse(), module, NIL, STRING, string_to_expression(), and strsplit().

Referenced by symbolic_tiling().

Here is the call graph for this function:

Here is the caller graph for this function: