93   for (j = 0; j < level; j++)
 
   96   if (irregular != NULL)
 
   97     fprintf(file, 
"+-- osl_irregular_t\n");
 
   99     fprintf(file, 
"+-- NULL irregular\n");
 
  101   if (irregular != NULL) {
 
  103     for(j = 0; j <= level; j++)
 
  104       fprintf(file, 
"|\t");
 
  110       fprintf(file, 
"statement%d's predicats : ", i);
 
  112         fprintf(file, 
"%d ", irregular->
predicates[i][j]);
 
  118       fprintf(file, 
"predicat%d's\niterators : ", i);
 
  120         fprintf(file, 
"%s ", irregular->
iterators[i][j]);
 
  121       fprintf(file, 
"\ncontrol body: %s\n", irregular->
body[i]);
 
  125         i < irregular->nb_control + irregular->
nb_exit; i++) {
 
  126       fprintf(file, 
"predicat%d's\niterators : ", i);
 
  128         fprintf(file, 
"%s ", irregular->
iterators[i][j]);
 
  129       fprintf(file, 
"\nexit body: %s\n", irregular->
body[i]);
 
  134   for (j = 0; j <= level; j++)
 
  135     fprintf(file, 
"|\t");
 
  160   int high_water_mark = OSL_MAX_STRING,i,j;
 
  161   char * 
string = NULL;
 
  164   if (irregular != NULL) {
 
  165     OSL_malloc(
string, 
char *, high_water_mark * 
sizeof(
char));
 
  166     OSL_malloc(buffer, 
char *, OSL_MAX_STRING * 
sizeof(
char));
 
  170     sprintf(buffer, OSL_TAG_IRREGULAR_START);
 
  176       sprintf(buffer, 
"%s%d ", buffer, irregular->
nb_predicates[i]);
 
  178         sprintf(buffer, 
"%s%d ", buffer, irregular->
predicates[i][j]);
 
  180       sprintf(buffer, 
"%s\n", buffer);
 
  184     sprintf(buffer, 
"%s%d\n", buffer, irregular->
nb_control);
 
  185     sprintf(buffer, 
"%s%d\n", buffer, irregular->
nb_exit);
 
  187       sprintf(buffer, 
"%s%d ", buffer, irregular->
nb_iterators[i]);
 
  189         sprintf(buffer, 
"%s%s ", buffer, irregular->
iterators[i][j]);
 
  190       sprintf(buffer, 
"%s\n%s\n", buffer, irregular->
body[i]);
 
  193     for(i=0; i<irregular->
nb_exit; i++) {
 
  194       sprintf(buffer, 
"%s%d ", buffer, irregular->
nb_iterators[
 
  197         sprintf(buffer, 
"%s%s ", buffer, irregular->
iterators[
 
  199       sprintf(buffer, 
"%s\n%s\n", buffer, irregular->
body[
 
  206     sprintf(buffer, OSL_TAG_IRREGULAR_STOP
"\n");
 
  210     OSL_realloc(
string, 
char *, (strlen(
string) + 1) * 
sizeof(
char));
 
  238   content = *extensions_fixme;
 
  240   if (content == NULL) {
 
  241     OSL_debug(
"no irregular optional tag");
 
  245   if (strlen(content) > OSL_MAX_STRING)
 
  246     OSL_error(
"irregular too long");
 
  251   tok = strtok(content,
" \n");
 
  261     tok = strtok(NULL,
" \n");
 
  266       tok = strtok(NULL, 
" \n");
 
  272   tok = strtok(NULL, 
" \n");
 
  274   tok = strtok(NULL, 
" \n");
 
  275   irregular->
nb_exit = atoi(tok);
 
  279   OSL_malloc(irregular->
iterators, 
char ***,
 
  280                   sizeof(
char **) * nb_predicates);
 
  281   OSL_malloc(irregular->
nb_iterators, 
int *, 
sizeof(
int) * nb_predicates);
 
  282   OSL_malloc(irregular->
body, 
char **, 
sizeof(
char *) * nb_predicates);
 
  284   for(i = 0; i < nb_predicates; i++) {
 
  286     tok = strtok(NULL, 
" \n");
 
  288     OSL_malloc(irregular->
iterators[i], 
char **,
 
  293       OSL_strdup(irregular->
iterators[i][j], strtok(NULL, 
" \n"));
 
  295     OSL_strdup(irregular->
body[i], strtok(NULL, 
"\n"));
 
  327   irregular->
body = NULL;
 
  340   int i, j, nb_predicates;
 
  342   if (irregular != NULL) {
 
  350     for(i = 0; i < nb_predicates; i++) {
 
  360     if(irregular->
body != NULL)
 
  385   if (irregular == NULL)
 
  393     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  399     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  408       fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  421     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  427     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  430   copy->
body = (
char **)
malloc(
sizeof(
char*)*nb_predicates);
 
  431   if (copy->
body == NULL)
 
  433     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  436   for(i=0; i<nb_predicates; i++)
 
  442       fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  469   if (((c1 == NULL) && (c2 != NULL)) || ((c1 != NULL) && (c2 == NULL)))
 
  477   while(
bool == 0 && i < c1->nb_statements)
 
  486   while(
bool == 0 && i < c1->nb_control + c1->
nb_exit)
 
  489     bool += strcmp(c1->
body[i],c2->
body[i]);
 
  491     while(
bool == 0 && j < c1->nb_iterators[i])
 
  519   result->
body = (
char**)
malloc(
sizeof(
char*)*nb_predicates);
 
  522       result->
body == NULL)
 
  524     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  531     OSL_strdup(result->
body[i], irregular->
body[i]); 
 
  536       fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  546     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  549   for(i=0; i<nb_iterators; i++)
 
  554   for(i=result->
nb_control; i<nb_predicates; i++)
 
  557     OSL_strdup(result->
body[i], irregular->
body[i-1]); 
 
  562       fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  573     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  581       fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  608   result->
body = (
char**)
malloc(
sizeof(
char*)*nb_predicates);
 
  611       result->
body == NULL)
 
  613     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  617   for(i=0; i<nb_predicates - 1; i++)
 
  620     OSL_strdup(result->
body[i], irregular->
body[i]); 
 
  625       fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  632   result->
iterators[nb_predicates-1] = (
char**)
malloc(
sizeof(
char*)*nb_iterators);
 
  633   if (result->
iterators[nb_predicates-1] == NULL)
 
  635     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  639   for(i=0; i<nb_iterators; i++)
 
  640     OSL_strdup(result->
iterators[nb_predicates-1][i], iterators[i]);
 
  642   OSL_strdup(result->
body[nb_predicates-1], body);
 
  648     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  656       fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  670                                                int nb_add_predicates)
 
  682   result->
body = (
char**)
malloc(
sizeof(
char*)*nb_predicates);
 
  685       result->
body == NULL)
 
  687     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  691   for(i=0; i<nb_predicates; i++)
 
  694     OSL_strdup(result->
body[i], irregular->
body[i]); 
 
  699       fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  711     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  719       fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  730     fprintf(stderr, 
"[OpenScop] Error: memory overflow.\n");
 
  733   for(i=0; i<nb_add_predicates; i++)
 
  752   OSL_strdup(interface->URI, OSL_URI_IRREGULAR);
 
void *(* osl_clone_f)(void *)
osl_interface_p osl_irregular_interface()
osl_interface_p osl_interface_malloc()
int osl_irregular_equal(osl_irregular_p c1, osl_irregular_p c2)
void *(* osl_sread_f)(char **)
void osl_irregular_free(osl_irregular_p irregular)
char * osl_irregular_sprint(osl_irregular_p irregular)
void osl_util_safe_strcat(char **dst, char *src, int *hwm)
osl_irregular_p osl_irregular_malloc()
void(* osl_idump_f)(FILE *, void *, int)
char *(* osl_sprint_f)(void *)
osl_irregular_p osl_irregular_sread(char **extensions_fixme)
void osl_irregular_idump(FILE *file, osl_irregular_p irregular, int level)
int(* osl_equal_f)(void *, void *)
osl_irregular_p osl_irregular_add_control(osl_irregular_p irregular, char **iterators, int nb_iterators, char *body)
void osl_irregular_dump(FILE *file, osl_irregular_p irregular)
osl_irregular_p osl_irregular_clone(osl_irregular_p irregular)
osl_irregular_p osl_irregular_add_exit(osl_irregular_p irregular, char **iterators, int nb_iterators, char *body)
osl_irregular_p osl_irregular_add_predicates(osl_irregular_p irregular, int *predicates, int nb_add_predicates)
void(* osl_free_f)(void *)