/**
* osl_strings_sprint function:
* this function prints the content of an osl_strings_t structure
* (*strings) into a string (returned) in the OpenScop textual format.
* \param[in] strings The strings structure which has to be printed.
* \return A string containing the OpenScop dump of the strings structure.
*/
char * osl_strings_sprint(osl_strings_p strings) {
size_t i;
int high_water_mark = OSL_MAX_STRING;
char * string = NULL;
char buffer[OSL_MAX_STRING];
OSL_malloc(string, char *, high_water_mark * sizeof(char));
string[0] = '\0';
if (strings != NULL) {
for (i = 0; i < osl_strings_size(strings); i++) {
sprintf(buffer, "%s", strings->string[i]);
osl_util_safe_strcat(&string, buffer, &high_water_mark);
if (i < osl_strings_size(strings) - 1)
osl_util_safe_strcat(&string, " ", &high_water_mark);
}
sprintf(buffer, "\n");
osl_util_safe_strcat(&string, buffer, &high_water_mark);
}
else {
sprintf(buffer, "# NULL strings\n");
osl_util_safe_strcat(&string, buffer, &high_water_mark);
}
return string;
}
/**
* @brief Fusion two osl_body into a third one.
* The two osl_body must have the same iterators or the program will fail.
*
* @param body1 The first osl_body.
* @param body2 The second osl_body.
*
* @return An osl_body with the same iteratar as the parameters, but with
* their "code" fusionned.
*/
struct osl_body * substrate_osl_body_fusion(
struct osl_body * body1,
struct osl_body * body2)
{
struct osl_body * res = NULL;
size_t body1_size = 0, body2_size = 0;
body1_size = osl_strings_size(body1->iterators);
body2_size = osl_strings_size(body2->iterators);
res = osl_body_malloc();
if((osl_strings_equal(body1->iterators, body2->iterators)) || (body1_size==0) || (body2_size==0))
{
res->iterators = osl_strings_clone(body1->iterators);
substrate_osl_strings_concat(
&res->expression,
body1->expression,
body2->expression);
}
else
{
//TODO Maybe fuse when iterators don't match ? (I'm not really sure).
OSL_error("Can't fusion body");
}
return res;
}
/**
* osl_body_print_scoplib function:
* this function prints the content of an osl_body_t structure
* (*body) into a file (file, possibly stdout) in the SCoPLib format.
* \param[in] file File where informations are printed.
* \param[in] body The body whose information has to be printed.
*/
void osl_body_print_scoplib(FILE * file, osl_body_p body) {
int nb_iterators;
if (body != NULL) {
nb_iterators = osl_strings_size(body->iterators);
if (nb_iterators > 0) {
fprintf(file, "# List of original iterators\n");
osl_strings_print(file, body->iterators);
} else {
fprintf(file, "fakeiter\n");
}
fprintf(file, "# Statement body expression\n");
osl_strings_print(file, body->expression);
}
else {
fprintf(file, "# NULL statement body\n");
}
}
/**
* osl_strings_idump function:
* this function displays an array of strings into a file (file, possibly
* stdout) in a way that trends to be understandable. It includes an
* indentation level (level) in order to work with others
* idump functions.
* \param[in] file The file where the information has to be printed.
* \param[in] strings The array of strings that has to be printed.
* \param[in] level Number of spaces before printing, for each line.
*/
void osl_strings_idump(FILE * file, osl_strings_p strings, int level) {
int i, nb_strings;
for (i = 0; i < level; i++)
fprintf(file, "|\t");
if (strings != NULL) {
nb_strings = osl_strings_size(strings);
fprintf(file, "+-- osl_strings_t:");
for (i = 0; i < nb_strings; i++)
fprintf(file, " %s", strings->string[i]);
fprintf(file, "\n");
}
else
fprintf(file, "+-- NULL strings\n");
// A blank line.
for (i = 0; i <= level; i++)
fprintf(file, "|\t");
fprintf(file, "\n");
}
/**
* osl_body_sprint function:
* this function prints the content of an osl_body_t structure
* (*body) into a string (returned) in the OpenScop textual format.
* \param[in] body The body structure which has to be printed.
* \return A string containing the OpenScop dump of the body structure.
*/
char * osl_body_sprint(osl_body_p body) {
int nb_iterators;
int high_water_mark = OSL_MAX_STRING;
char * string = NULL;
char buffer[OSL_MAX_STRING];
char * iterators, * expression;
OSL_malloc(string, char *, high_water_mark * sizeof(char));
string[0] = '\0';
if (body != NULL) {
nb_iterators = osl_strings_size(body->iterators);
sprintf(buffer, "# Number of original iterators\n%d\n", nb_iterators);
osl_util_safe_strcat(&string, buffer, &high_water_mark);
if (nb_iterators > 0) {
sprintf(buffer, "# List of original iterators\n");
osl_util_safe_strcat(&string, buffer, &high_water_mark);
iterators = osl_strings_sprint(body->iterators);
osl_util_safe_strcat(&string, iterators, &high_water_mark);
free(iterators);
}
sprintf(buffer, "# Statement body expression\n");
osl_util_safe_strcat(&string, buffer, &high_water_mark);
expression = osl_strings_sprint(body->expression);
osl_util_safe_strcat(&string, expression, &high_water_mark);
free(expression);
}
else {
sprintf(buffer, "# NULL body\n");
osl_util_safe_strcat(&string, buffer, &high_water_mark);
}
return string;
}
/**
* osl_scop_pread function ("precision read"):
* this function reads a list of scop structures from a file (possibly stdin)
* complying to the OpenScop textual format and returns a pointer to this
* scop list. If some relation properties (number of input/output/local
* dimensions and number of parameters) are undefined, it will define them
* according to the available information.
* \param[in] file The file where the scop has to be read.
* \param[in] registry The list of known interfaces (others are ignored).
* \param[in] precision The precision of the relation elements.
* \return A pointer to the scop structure that has been read.
*/
osl_scop_p osl_scop_pread(FILE * file, osl_interface_p registry,
int precision) {
osl_scop_p list = NULL, current = NULL, scop;
osl_statement_p stmt = NULL;
osl_statement_p prev = NULL;
osl_strings_p language;
int nb_statements;
char * tmp;
int first = 1;
int i;
if (file == NULL)
return NULL;
while(1) {
//
// I. START TAG
//
tmp = osl_util_read_uptotag(file, OSL_TAG_START_SCOP);
if (tmp == NULL) {
OSL_debug("no more scop in the file");
break;
}
else {
free(tmp);
}
scop = osl_scop_malloc();
scop->registry = osl_interface_clone(registry);
//
// II. CONTEXT PART
//
// Read the language.
language = osl_strings_read(file);
if (osl_strings_size(language) == 0)
OSL_error("no language (backend) specified");
if (osl_strings_size(language) > 1)
OSL_warning("uninterpreted information (after language)");
if (language != NULL) {
scop->language = strdup(language->string[0]);
osl_strings_free(language);
}
// Read the context domain.
scop->context = osl_relation_pread(file, precision);
// Read the parameters.
if (osl_util_read_int(file, NULL) > 0)
scop->parameters = osl_generic_read_one(file, scop->registry);
//
// III. STATEMENT PART
//
// Read the number of statements.
nb_statements = osl_util_read_int(file, NULL);
for (i = 0; i < nb_statements; i++) {
// Read each statement.
stmt = osl_statement_pread(file, scop->registry, precision);
if (scop->statement == NULL)
scop->statement = stmt;
else
prev->next = stmt;
prev = stmt;
}
//
// IV. EXTENSION PART (TO THE END TAG)
//
// Read up the end tag (if any), and store extensions.
scop->extension = osl_generic_read(file, scop->registry);
// Add the new scop to the list.
if (first) {
list = scop;
first = 0;
}
else {
current->next = scop;
}
current = scop;
}
if (!osl_scop_integrity_check(list))
OSL_warning("scop integrity check failed");
return list;
}