67 #include "../include/osl/extensions/pluto_unroll.h" 
   68 #include "../include/osl/macros.h" 
   89   int j, first = 1, number=1;
 
   92   for (j = 0; j < level; j++)
 
   95   if (pluto_unroll != NULL)
 
   96     fprintf(file, 
"+-- osl_pluto_unroll_t\n");
 
   98     fprintf(file, 
"+-- NULL pluto_unroll\n");
 
  100   while (pluto_unroll != NULL) {
 
  104       for (j = 0; j < level; j++)
 
  105         fprintf(file, 
"|\t");
 
  107       fprintf(file, 
"|   osl_pluto_unroll_t (node %d)\n", number);
 
  113     for (j = 0; j <= level+1; j++)
 
  114       fprintf(file, 
"|\t");
 
  118     for (j = 0; j <= level; j++)
 
  119       fprintf(file, 
"|\t");
 
  120     fprintf(file, 
"+--iterator: %s\n", pluto_unroll->
iter);
 
  123     for (j = 0; j <= level; j++)
 
  124       fprintf(file, 
"|\t");
 
  125     fprintf(file, 
"+--jam: %i\n", pluto_unroll->
jam);
 
  128     for (j = 0; j <= level; j++)
 
  129       fprintf(file, 
"|\t");
 
  130     fprintf(file, 
"+--factor: %i\n", pluto_unroll->
factor);
 
  132     pluto_unroll = pluto_unroll->
next;
 
  135     if (pluto_unroll != NULL) {
 
  136       for (j = 0; j <= level; j++)
 
  137         fprintf(file, 
"|\t");
 
  138       fprintf(file, 
"V\n");
 
  143   for (j = 0; j <= level; j++)
 
  144     fprintf(file, 
"|\t");
 
  174   char buffer[OSL_MAX_STRING] = { 0 };
 
  176   strcat(buffer, 
"# Pluto unroll\n");
 
  177   if (pluto_unroll != NULL) {
 
  178     strcat(buffer, 
"1\n");
 
  180     strcat(buffer, 
"0\n");
 
  183   while (pluto_unroll != NULL)
 
  185     strcat(buffer, 
"# Iterator name\n");
 
  186     sprintf(buffer + strlen(buffer), 
"%s\n", pluto_unroll->
iter);
 
  188     strcat(buffer, 
"# Jam\n");
 
  189     sprintf(buffer + strlen(buffer), 
"%i\n", pluto_unroll->
jam);
 
  191     strcat(buffer, 
"# Factor\n");
 
  192     sprintf(buffer + strlen(buffer), 
"%i\n", pluto_unroll->
factor);
 
  194     pluto_unroll = pluto_unroll->
next;
 
  196     strcat(buffer, 
"# Next\n");
 
  197     if (pluto_unroll != NULL) {
 
  198       strcat(buffer, 
"1\n");
 
  200       strcat(buffer, 
"0\n");
 
  204   OSL_realloc(
string, 
char*, (strlen(buffer) + 1) * 
sizeof(
char));
 
  205   strcpy(
string, buffer);
 
  271   pluto_unroll->
iter   = NULL;
 
  272   pluto_unroll->
jam    = 
false;
 
  274   pluto_unroll->
next   = NULL;
 
  288   if (pluto_unroll != NULL) {
 
  291     free(pluto_unroll->
iter);
 
  292     free(pluto_unroll); pluto_unroll = NULL;
 
  311                            char const * 
const iterator_name,
 
  312                            bool const jam, 
int const factor) {
 
  313   if (pluto_unroll != NULL) {
 
  315     if (iterator_name != NULL) {
 
  316       OSL_realloc(pluto_unroll->
iter,
 
  317                   char*, (strlen(iterator_name) + 1) * 
sizeof(
char));
 
  318       strcpy(pluto_unroll->
iter, iterator_name);
 
  321     pluto_unroll->
jam = jam;
 
  323     pluto_unroll->
factor = factor;
 
  325     OSL_warning(
"osl_pluto_unroll_fill can not fill NULL osl_pluto_unroll_p");
 
  344   while (pluto_unroll != NULL)
 
  350     pluto_unroll = pluto_unroll->
next;
 
  373   if (a == b) { 
return 1; }
 
  375   if (a == NULL && b != NULL) { 
return 0; }
 
  376   if (a != NULL && b == NULL) { 
return 0; }
 
  380     if (a->
iter == NULL && b->
iter != NULL) { 
return 0; }
 
  381     if (a->
iter != NULL && b->
iter == NULL) { 
return 0; }
 
  382     if (a->
iter != NULL) {
 
  383       if (strcmp(a->
iter, b->
iter) != 0) { 
return 0; }
 
  387     if (a->
jam != b->
jam) { 
return 0; }
 
  391     if (a->
next == b->
next) { 
return 1; }
 
  392     if (a->
next == NULL && b->
next != NULL) { 
return 0; }
 
  393     if (a->
next != NULL && b->
next == NULL) { 
return 0; }
 
  412   OSL_strdup(interface->URI, OSL_URI_PLUTO_UNROLL);
 
osl_pluto_unroll_p osl_pluto_unroll_malloc()
void *(* osl_clone_f)(void *)
void osl_pluto_unroll_free(osl_pluto_unroll_p pluto_unroll)
osl_pluto_unroll_p osl_pluto_unroll_clone(osl_pluto_unroll_p pluto_unroll)
osl_interface_p osl_interface_malloc()
void osl_pluto_unroll_fill(osl_pluto_unroll_p pluto_unroll, char const *const iterator_name, bool const jam, int const factor)
void *(* osl_sread_f)(char **)
unsigned int factor
unroll factor 
void(* osl_idump_f)(FILE *, void *, int)
bool jam
true if jam, false otherwise 
void osl_pluto_unroll_dump(FILE *file, osl_pluto_unroll_p pluto_unroll)
char * iter
\0 terminated iterator name 
osl_pluto_unroll_p osl_pluto_unroll_sread(char **input)
int osl_util_read_int(FILE *file, char **str)
char *(* osl_sprint_f)(void *)
struct osl_pluto_unroll * next
next { iter, jam, factor } 
osl_interface_p osl_pluto_unroll_interface()
int(* osl_equal_f)(void *, void *)
void osl_pluto_unroll_idump(FILE *file, osl_pluto_unroll_p pluto_unroll, int level)
char * osl_pluto_unroll_sprint(osl_pluto_unroll_p pluto_unroll)
int osl_pluto_unroll_equal(osl_pluto_unroll_p a, osl_pluto_unroll_p b)
char * osl_util_read_line(FILE *file, char **str)
void(* osl_free_f)(void *)