OpenScop  0.9.0
irregular.c
Go to the documentation of this file.
1 
2  /*+-----------------------------------------------------------------**
3  ** OpenScop Library **
4  **-----------------------------------------------------------------**
5  ** extensions/irregular.c **
6  **-----------------------------------------------------------------**
7  ** First version: 07/12/2010 **
8  **-----------------------------------------------------------------**
9 
10 
11  *****************************************************************************
12  * OpenScop: Structures and formats for polyhedral tools to talk together *
13  *****************************************************************************
14  * ,___,,_,__,,__,,__,,__,,_,__,,_,__,,__,,___,_,__,,_,__, *
15  * / / / // // // // / / / // // / / // / /|,_, *
16  * / / / // // // // / / / // // / / // / / / /\ *
17  * |~~~|~|~~~|~~~|~~~|~~~|~|~~~|~|~~~|~~~|~~~|~|~~~|~|~~~|/_/ \ *
18  * | G |C| P | = | L | P |=| = |C| = | = | = |=| = |=| C |\ \ /\ *
19  * | R |l| o | = | e | l |=| = |a| = | = | = |=| = |=| L | \# \ /\ *
20  * | A |a| l | = | t | u |=| = |n| = | = | = |=| = |=| o | |\# \ \ *
21  * | P |n| l | = | s | t |=| = |d| = | = | = | | |=| o | | \# \ \ *
22  * | H | | y | | e | o | | = |l| | | = | | | | G | | \ \ \ *
23  * | I | | | | e | | | | | | | | | | | | | \ \ \ *
24  * | T | | | | | | | | | | | | | | | | | \ \ \ *
25  * | E | | | | | | | | | | | | | | | | | \ \ \ *
26  * | * |*| * | * | * | * |*| * |*| * | * | * |*| * |*| * | / \* \ \ *
27  * | O |p| e | n | S | c |o| p |-| L | i | b |r| a |r| y |/ \ \ / *
28  * '---'-'---'---'---'---'-'---'-'---'---'---'-'---'-'---' '--' *
29  * *
30  * Copyright (C) 2008 University Paris-Sud 11 and INRIA *
31  * *
32  * (3-clause BSD license) *
33  * Redistribution and use in source and binary forms, with or without *
34  * modification, are permitted provided that the following conditions *
35  * are met: *
36  * *
37  * 1. Redistributions of source code must retain the above copyright notice, *
38  * this list of conditions and the following disclaimer. *
39  * 2. Redistributions in binary form must reproduce the above copyright *
40  * notice, this list of conditions and the following disclaimer in the *
41  * documentation and/or other materials provided with the distribution. *
42  * 3. The name of the author may not be used to endorse or promote products *
43  * derived from this software without specific prior written permission. *
44  * *
45  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR *
46  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES *
47  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. *
48  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, *
49  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT *
50  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, *
51  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY *
52  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
53  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF *
54  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
55  * *
56  * OpenScop Library, a library to manipulate OpenScop formats and data *
57  * structures. Written by: *
58  * Cedric Bastoul <Cedric.Bastoul@u-psud.fr> and *
59  * Louis-Noel Pouchet <Louis-Noel.pouchet@inria.fr> *
60  * *
61  *****************************************************************************/
62 
63 #include <stdlib.h>
64 #include <stdio.h>
65 #include <string.h>
66 
67 #include <osl/macros.h>
68 #include <osl/util.h>
69 #include <osl/strings.h>
70 #include <osl/interface.h>
72 
73 
74 /*+***************************************************************************
75  * Structure display function *
76  *****************************************************************************/
77 
78 
89 void osl_irregular_idump(FILE * file, osl_irregular_p irregular, int level) {
90  int i,j;
91 
92  // Go to the right level.
93  for (j = 0; j < level; j++)
94  fprintf(file, "|\t");
95 
96  if (irregular != NULL)
97  fprintf(file, "+-- osl_irregular_t\n");
98  else
99  fprintf(file, "+-- NULL irregular\n");
100 
101  if (irregular != NULL) {
102  // Go to the right level.
103  for(j = 0; j <= level; j++)
104  fprintf(file, "|\t");
105 
106  // Display the irregular contents.
107 
108  // Print statements
109  for (i = 0; i < irregular->nb_statements; i++) {
110  fprintf(file, "statement%d's predicats : ", i);
111  for(j = 0; j < irregular->nb_predicates[i]; j++)
112  fprintf(file, "%d ", irregular->predicates[i][j]);
113  fprintf(file, "\n");
114  }
115  // Print predicats
116  // controls :
117  for (i = 0; i < irregular->nb_control; i++) {
118  fprintf(file, "predicat%d's\niterators : ", i);
119  for(j = 0; j < irregular->nb_iterators[i]; j++)
120  fprintf(file, "%s ", irregular->iterators[i][j]);
121  fprintf(file, "\ncontrol body: %s\n", irregular->body[i]);
122  }
123  // exits :
124  for(i = irregular->nb_control;
125  i < irregular->nb_control + irregular->nb_exit; i++) {
126  fprintf(file, "predicat%d's\niterators : ", i);
127  for(j = 0; j < irregular->nb_iterators[i]; j++)
128  fprintf(file, "%s ", irregular->iterators[i][j]);
129  fprintf(file, "\nexit body: %s\n", irregular->body[i]);
130  }
131  }
132 
133  // The last line.
134  for (j = 0; j <= level; j++)
135  fprintf(file, "|\t");
136  fprintf(file, "\n");
137 }
138 
139 
147 void osl_irregular_dump(FILE * file, osl_irregular_p irregular) {
148  osl_irregular_idump(file, irregular, 0);
149 }
150 
151 
160  int high_water_mark = OSL_MAX_STRING,i,j;
161  char * string = NULL;
162  char * buffer;
163 
164  if (irregular != NULL) {
165  OSL_malloc(string, char *, high_water_mark * sizeof(char));
166  OSL_malloc(buffer, char *, OSL_MAX_STRING * sizeof(char));
167  string[0] = '\0';
168 
169  // Print the begin tag.
170  sprintf(buffer, OSL_TAG_IRREGULAR_START);
171  osl_util_safe_strcat(&string, buffer, &high_water_mark);
172 
173  // Print the content.
174  sprintf(buffer, "\n%d\n", irregular->nb_statements);
175  for(i=0; i<irregular->nb_statements; i++) {
176  sprintf(buffer, "%s%d ", buffer, irregular->nb_predicates[i]);
177  for(j=0; j<irregular->nb_predicates[i]; j++) {
178  sprintf(buffer, "%s%d ", buffer, irregular->predicates[i][j]);
179  }
180  sprintf(buffer, "%s\n", buffer);
181  }
182  // Print the predicates.
183  // controls:
184  sprintf(buffer, "%s%d\n", buffer, irregular->nb_control);
185  sprintf(buffer, "%s%d\n", buffer, irregular->nb_exit);
186  for(i=0; i<irregular->nb_control; i++) {
187  sprintf(buffer, "%s%d ", buffer, irregular->nb_iterators[i]);
188  for(j=0; j<irregular->nb_iterators[i];j++)
189  sprintf(buffer, "%s%s ", buffer, irregular->iterators[i][j]);
190  sprintf(buffer, "%s\n%s\n", buffer, irregular->body[i]);
191  }
192  // exits:
193  for(i=0; i<irregular->nb_exit; i++) {
194  sprintf(buffer, "%s%d ", buffer, irregular->nb_iterators[
195  irregular->nb_control + i]);
196  for(j=0; j<irregular->nb_iterators[irregular->nb_control + i];j++)
197  sprintf(buffer, "%s%s ", buffer, irregular->iterators[
198  irregular->nb_control+i][j]);
199  sprintf(buffer, "%s\n%s\n", buffer, irregular->body[
200  irregular->nb_control + i]);
201  }
202 
203  osl_util_safe_strcat(&string, buffer, &high_water_mark);
204 
205  // Print the end tag.
206  sprintf(buffer, OSL_TAG_IRREGULAR_STOP"\n");
207  osl_util_safe_strcat(&string, buffer, &high_water_mark);
208 
209  // Keep only the memory space we need.
210  OSL_realloc(string, char *, (strlen(string) + 1) * sizeof(char));
211  free(buffer);
212  }
213 
214  return string;
215 }
216 
217 
218 /*****************************************************************************
219  * Reading function *
220  *****************************************************************************/
221 
230 osl_irregular_p osl_irregular_sread(char ** extensions_fixme) {
231  char * content,*tok;
232  int i,j;
233  osl_irregular_p irregular;
234 
235  // FIXME: this is a quick and dirty thing to accept char ** instead
236  // of char * in the parameter: really do it and update the
237  // pointer to after what has been read.
238  content = *extensions_fixme;
239 
240  if (content == NULL) {
241  OSL_debug("no irregular optional tag");
242  return NULL;
243  }
244 
245  if (strlen(content) > OSL_MAX_STRING)
246  OSL_error("irregular too long");
247 
248  irregular = osl_irregular_malloc();
249 
250  // nb statements
251  tok = strtok(content," \n");
252  irregular->nb_statements = atoi(tok);
253  OSL_malloc(irregular->predicates, int **,
254  sizeof(int*) * irregular->nb_statements);
255  OSL_malloc(irregular->nb_predicates, int *,
256  sizeof(int) * irregular->nb_statements);
257 
258  // get predicats
259  for(i = 0; i < irregular->nb_statements; i++) {
260  // nb conditions
261  tok = strtok(NULL," \n");
262  irregular->nb_predicates[i] = atoi(tok);
263  OSL_malloc(irregular->predicates[i], int *,
264  sizeof(int) * irregular->nb_predicates[i]);
265  for(j = 0; j < irregular->nb_predicates[i]; j++){
266  tok = strtok(NULL, " \n");
267  irregular->predicates[i][j] = atoi(tok);
268  }
269  }
270  // Get nb predicat
271  // control and exits :
272  tok = strtok(NULL, " \n");
273  irregular->nb_control=atoi(tok);
274  tok = strtok(NULL, " \n");
275  irregular->nb_exit = atoi(tok);
276 
277  int nb_predicates = irregular->nb_control + irregular->nb_exit;
278 
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);
283 
284  for(i = 0; i < nb_predicates; i++) {
285  // Get number of iterators
286  tok = strtok(NULL, " \n");
287  irregular->nb_iterators[i] = atoi(tok);
288  OSL_malloc(irregular->iterators[i], char **,
289  sizeof(char *) * irregular->nb_iterators[i]);
290 
291  // Get iterators
292  for(j = 0; j < irregular->nb_iterators[i]; j++)
293  OSL_strdup(irregular->iterators[i][j], strtok(NULL, " \n"));
294  // Get predicat string
295  OSL_strdup(irregular->body[i], strtok(NULL, "\n"));
296  }
297 
298  return irregular;
299 }
300 
301 
302 /*+***************************************************************************
303  * Memory allocation/deallocation function *
304  *****************************************************************************/
305 
306 
316  osl_irregular_p irregular;
317 
318  OSL_malloc(irregular, osl_irregular_p,
319  sizeof(osl_irregular_t));
320  irregular->nb_statements = 0;
321  irregular->predicates = NULL;
322  irregular->nb_predicates = NULL;
323  irregular->nb_control = 0;
324  irregular->nb_exit = 0;
325  irregular->nb_iterators = NULL;
326  irregular->iterators = NULL;
327  irregular->body = NULL;
328 
329  return irregular;
330 }
331 
332 
340  int i, j, nb_predicates;
341 
342  if (irregular != NULL) {
343  for(i = 0; i < irregular->nb_statements; i++)
344  free(irregular->predicates[i]);
345 
346  if(irregular->predicates != NULL)
347  free(irregular->predicates);
348 
349  nb_predicates = irregular->nb_control + irregular->nb_exit;
350  for(i = 0; i < nb_predicates; i++) {
351  for(j = 0; j < irregular->nb_iterators[i]; j++)
352  free(irregular->iterators[i][j]);
353  free(irregular->iterators[i]);
354  free(irregular->body[i]);
355  }
356  if(irregular->iterators != NULL)
357  free(irregular->iterators);
358  if(irregular->nb_iterators != NULL)
359  free(irregular->nb_iterators);
360  if(irregular->body != NULL)
361  free(irregular->body);
362  if(irregular->nb_predicates != NULL)
363  free(irregular->nb_predicates);
364  free(irregular);
365  }
366 }
367 
368 
369 /*+***************************************************************************
370  * Processing functions *
371  *****************************************************************************/
372 
373 
382  int i,j;
383  osl_irregular_p copy;
384 
385  if (irregular == NULL)
386  return NULL;
387 
388  copy = osl_irregular_malloc();
389  copy->nb_statements = irregular->nb_statements;
390  copy->nb_predicates = (int *)malloc(sizeof(int)*copy->nb_statements);
391  if (copy->nb_predicates == NULL)
392  {
393  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
394  exit(1);
395  }
396  copy->predicates = (int **)malloc(sizeof(int*)*copy->nb_statements);
397  if (copy->predicates == NULL)
398  {
399  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
400  exit(1);
401  }
402  for(i=0; i<copy->nb_statements; i++)
403  {
404  copy->nb_predicates[i]=irregular->nb_predicates[i];
405  copy->predicates[i] = (int *)malloc(sizeof(int)*copy->nb_predicates[i]);
406  if (copy->predicates[i] == NULL)
407  {
408  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
409  exit(1);
410  }
411  for(j=0; j<copy->nb_predicates[i]; j++)
412  copy->predicates[i][j] = irregular->predicates[i][j];
413  }
414 
415  copy->nb_control = irregular->nb_control;
416  copy->nb_exit = irregular->nb_exit;
417  int nb_predicates = irregular->nb_control + irregular->nb_exit;
418  copy->nb_iterators = (int *)malloc(sizeof(int)*nb_predicates);
419  if (copy->nb_iterators == NULL)
420  {
421  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
422  exit(1);
423  }
424  copy->iterators = (char ***)malloc(sizeof(char**)*nb_predicates);
425  if (copy->iterators == NULL)
426  {
427  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
428  exit(1);
429  }
430  copy->body = (char **)malloc(sizeof(char*)*nb_predicates);
431  if (copy->body == NULL)
432  {
433  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
434  exit(1);
435  }
436  for(i=0; i<nb_predicates; i++)
437  {
438  copy->nb_iterators[i] = irregular->nb_iterators[i];
439  copy->iterators[i] = (char**)malloc(sizeof(char*)*copy->nb_iterators[i]);
440  if (copy->iterators[i] == NULL)
441  {
442  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
443  exit(1);
444  }
445  for(j=0;j<copy->nb_iterators[i];j++)
446  OSL_strdup(copy->iterators[i][j], irregular->iterators[i][j]);
447  OSL_strdup(copy->iterators[i][j], irregular->body[i]);
448  }
449 
450  return copy;
451 }
452 
453 
462 int
464 {
465  int i,j,bool = 0;
466  if (c1 == c2)
467  return 1;
468 
469  if (((c1 == NULL) && (c2 != NULL)) || ((c1 != NULL) && (c2 == NULL)))
470  return 0;
471 
472  if(c1->nb_statements != c2->nb_statements ||
473  c1->nb_control != c2->nb_control ||
474  c1->nb_exit != c2->nb_exit)
475  return 0;
476  i=0;
477  while(bool == 0 && i < c1->nb_statements)
478  {
479  bool = c1->nb_predicates[i] != c2->nb_predicates[i] ? 1 : 0;
480  i++;
481  }
482  if(bool != 0)
483  return 0;
484 
485  i = 0;
486  while(bool == 0 && i < c1->nb_control + c1->nb_exit)
487  {
488  bool += c1->nb_iterators[i] != c2->nb_iterators[i] ? 1 : 0;
489  bool += strcmp(c1->body[i],c2->body[i]);
490  j = 0;
491  while(bool == 0 && j < c1->nb_iterators[i])
492  {
493  bool += strcmp(c1->iterators[i][j],c2->iterators[i][j]);
494  j++;
495  }
496  i++;
497  }
498  if(bool != 0)
499  return 0;
500  return 1;
501 }
502 
504  osl_irregular_p irregular,
505  char** iterators,
506  int nb_iterators,
507  char* body)
508 {
509  int i,j;
511 
512  result->nb_control = irregular->nb_control + 1;
513  result->nb_exit = irregular->nb_exit;
514  result->nb_statements = irregular->nb_statements;
515  int nb_predicates = result->nb_control + result->nb_exit;
516 
517  result->iterators = (char***)malloc(sizeof(char**)*nb_predicates);
518  result->nb_iterators = (int*)malloc(sizeof(int)*nb_predicates);
519  result->body = (char**)malloc(sizeof(char*)*nb_predicates);
520  if (result->iterators == NULL ||
521  result->nb_iterators == NULL ||
522  result->body == NULL)
523  {
524  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
525  exit(1);
526  }
527  //copy controls
528  for(i=0; i<irregular->nb_control; i++)
529  {
530  result->nb_iterators[i] = irregular->nb_iterators[i];
531  OSL_strdup(result->body[i], irregular->body[i]);
532  result->iterators[i] = (char**)malloc(sizeof(char*) *
533  irregular->nb_iterators[i]);
534  if (result->iterators[i] == NULL)
535  {
536  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
537  exit(1);
538  }
539  for(j=0; j<irregular->nb_iterators[i];j++)
540  OSL_strdup(result->iterators[i][j], irregular->iterators[i][j]);
541  }
542  //add controls
543  result->iterators[irregular->nb_control] = (char**)malloc(sizeof(char*)*nb_iterators);
544  if (result->iterators[irregular->nb_control] == NULL)
545  {
546  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
547  exit(1);
548  }
549  for(i=0; i<nb_iterators; i++)
550  OSL_strdup(result->iterators[irregular->nb_control][i], iterators[i]);
551  result->nb_iterators[irregular->nb_control] = nb_iterators;
552  OSL_strdup(result->body[irregular->nb_control], body);
553  //copy exits
554  for(i=result->nb_control; i<nb_predicates; i++)
555  {
556  result->nb_iterators[i] = irregular->nb_iterators[i-1];
557  OSL_strdup(result->body[i], irregular->body[i-1]);
558  result->iterators[i] = (char**)malloc(sizeof(char*) *
559  irregular->nb_iterators[i-1]);
560  if (result->iterators[i] == NULL)
561  {
562  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
563  exit(1);
564  }
565  for(j=0; j<irregular->nb_iterators[i-1];j++)
566  OSL_strdup(result->iterators[i][j], irregular->iterators[i-1][j]);
567  }
568  // copy statements
569  result->nb_predicates = (int*)malloc(sizeof(int)*irregular->nb_statements);
570  result->predicates = (int**)malloc(sizeof(int*)*irregular->nb_statements);
571  if (result->nb_predicates == NULL || result->predicates == NULL)
572  {
573  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
574  exit(1);
575  }
576  for(i=0; i<irregular->nb_statements; i++)
577  {
578  result->predicates[i] = (int*)malloc(sizeof(int)*irregular->nb_predicates[i]);
579  if (result->predicates[i] == NULL)
580  {
581  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
582  exit(1);
583  }
584  result->nb_predicates[i] = irregular->nb_predicates[i];
585  for(j=0; j<irregular->nb_predicates[i]; j++)
586  result->predicates[i][j]=irregular->predicates[i][j];
587  }
588  return result;
589 }
590 
591 
593  osl_irregular_p irregular,
594  char** iterators,
595  int nb_iterators,
596  char* body)
597 {
598  int i,j;
600 
601  result->nb_control = irregular->nb_control;
602  result->nb_exit = irregular->nb_exit + 1;
603  result->nb_statements = irregular->nb_statements;
604  int nb_predicates = result->nb_control + result->nb_exit;
605 
606  result->iterators = (char***)malloc(sizeof(char**)*nb_predicates);
607  result->nb_iterators = (int*)malloc(sizeof(int)*nb_predicates);
608  result->body = (char**)malloc(sizeof(char*)*nb_predicates);
609  if (result->iterators == NULL ||
610  result->nb_iterators == NULL ||
611  result->body == NULL)
612  {
613  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
614  exit(1);
615  }
616  //copy controls and exits
617  for(i=0; i<nb_predicates - 1; i++)
618  {
619  result->nb_iterators[i] = irregular->nb_iterators[i];
620  OSL_strdup(result->body[i], irregular->body[i]);
621  result->iterators[i] = (char**)malloc(sizeof(char*) *
622  irregular->nb_iterators[i]);
623  if (result->iterators[i] == NULL)
624  {
625  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
626  exit(1);
627  }
628  for(j=0; j<irregular->nb_iterators[i];j++)
629  OSL_strdup(result->iterators[i][j], irregular->iterators[i][j]);
630  }
631  //add exit
632  result->iterators[nb_predicates-1] = (char**)malloc(sizeof(char*)*nb_iterators);
633  if (result->iterators[nb_predicates-1] == NULL)
634  {
635  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
636  exit(1);
637  }
638 
639  for(i=0; i<nb_iterators; i++)
640  OSL_strdup(result->iterators[nb_predicates-1][i], iterators[i]);
641  result->nb_iterators[nb_predicates-1] = nb_iterators;
642  OSL_strdup(result->body[nb_predicates-1], body);
643  // copy statements
644  result->nb_predicates = (int*)malloc(sizeof(int)*irregular->nb_statements);
645  result->predicates = (int**)malloc(sizeof(int*)*irregular->nb_statements);
646  if (result->nb_predicates == NULL || result->predicates == NULL)
647  {
648  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
649  exit(1);
650  }
651  for(i=0; i<irregular->nb_statements; i++)
652  {
653  result->predicates[i] = (int*)malloc(sizeof(int)*irregular->nb_predicates[i]);
654  if (result->predicates[i] == NULL)
655  {
656  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
657  exit(1);
658  }
659  result->nb_predicates[i] = irregular->nb_predicates[i];
660  for(j=0; j<irregular->nb_predicates[i]; j++)
661  result->predicates[i][j]=irregular->predicates[i][j];
662  }
663  return result;
664 }
665 
666 
668  osl_irregular_p irregular,
669  int* predicates,
670  int nb_add_predicates)
671 {
672  int i,j;
674 
675  result->nb_control = irregular->nb_control;
676  result->nb_exit = irregular->nb_exit;
677  result->nb_statements = irregular->nb_statements+1;
678  int nb_predicates = result->nb_control + result->nb_exit;
679 
680  result->iterators = (char***)malloc(sizeof(char**)*nb_predicates);
681  result->nb_iterators = (int*)malloc(sizeof(int)*nb_predicates);
682  result->body = (char**)malloc(sizeof(char*)*nb_predicates);
683  if (result->iterators == NULL ||
684  result->nb_iterators == NULL ||
685  result->body == NULL)
686  {
687  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
688  exit(1);
689  }
690  //copy controls and exits
691  for(i=0; i<nb_predicates; i++)
692  {
693  result->nb_iterators[i] = irregular->nb_iterators[i];
694  OSL_strdup(result->body[i], irregular->body[i]);
695  result->iterators[i] = (char**)malloc(sizeof(char*) *
696  irregular->nb_iterators[i]);
697  if (result->iterators[i] == NULL)
698  {
699  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
700  exit(1);
701  }
702  for(j=0; j<irregular->nb_iterators[i];j++)
703  OSL_strdup(result->iterators[i][j], irregular->iterators[i][j]);
704  }
705  //copy statements
706  result->nb_predicates = (int*)malloc(sizeof(int)*result->nb_statements);
707  result->predicates = (int**)malloc(sizeof(int*)*result->nb_statements);
708  if (result->nb_predicates == NULL ||
709  result->predicates == NULL)
710  {
711  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
712  exit(1);
713  }
714  for(i=0; i<irregular->nb_statements; i++)
715  {
716  result->predicates[i] = (int*)malloc(sizeof(int)*irregular->nb_predicates[i]);
717  if (result->predicates[i] == NULL)
718  {
719  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
720  exit(1);
721  }
722  result->nb_predicates[i] = irregular->nb_predicates[i];
723  for(j=0; j<irregular->nb_predicates[i]; j++)
724  result->predicates[i][j]=irregular->predicates[i][j];
725  }
726  //add statement
727  result->predicates[irregular->nb_statements] = (int*)malloc(sizeof(int)*nb_add_predicates);
728  if (result->predicates[irregular->nb_statements] == NULL)
729  {
730  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
731  exit(1);
732  }
733  for(i=0; i<nb_add_predicates; i++)
734  result->predicates[irregular->nb_statements][i] = predicates[i];
735  result->nb_predicates[irregular->nb_statements] = nb_add_predicates;
736 
737  return result;
738 
739 
740 }
741 
742 
751 
752  OSL_strdup(interface->URI, OSL_URI_IRREGULAR);
753  interface->idump = (osl_idump_f)osl_irregular_idump;
754  interface->sprint = (osl_sprint_f)osl_irregular_sprint;
755  interface->sread = (osl_sread_f)osl_irregular_sread;
756  interface->malloc = (osl_malloc_f)osl_irregular_malloc;
757  interface->free = (osl_free_f)osl_irregular_free;
758  interface->clone = (osl_clone_f)osl_irregular_clone;
759  interface->equal = (osl_equal_f)osl_irregular_equal;
760 
761  return interface;
762 }
763 
764 
void *(* osl_clone_f)(void *)
Definition: interface.h:80
osl_interface_p osl_irregular_interface()
Definition: irregular.c:749
osl_interface_p osl_interface_malloc()
Definition: interface.c:212
osl_malloc_f malloc
Definition: interface.h:94
int osl_irregular_equal(osl_irregular_p c1, osl_irregular_p c2)
Definition: irregular.c:463
void *(* osl_sread_f)(char **)
Definition: interface.h:77
void osl_irregular_free(osl_irregular_p irregular)
Definition: irregular.c:339
char * osl_irregular_sprint(osl_irregular_p irregular)
Definition: irregular.c:159
int ** predicates
Definition: irregular.h:105
void osl_util_safe_strcat(char **dst, char *src, int *hwm)
Definition: util.c:483
char *** iterators
Definition: irregular.h:96
int nb_statements
Definition: irregular.h:103
osl_irregular_p osl_irregular_malloc()
Definition: irregular.c:315
void(* osl_idump_f)(FILE *, void *, int)
Definition: interface.h:75
char *(* osl_sprint_f)(void *)
Definition: interface.h:76
osl_irregular_p osl_irregular_sread(char **extensions_fixme)
Definition: irregular.c:230
void osl_irregular_idump(FILE *file, osl_irregular_p irregular, int level)
Definition: irregular.c:89
void *(* osl_malloc_f)()
Definition: interface.h:78
int(* osl_equal_f)(void *, void *)
Definition: interface.h:81
osl_free_f free
Definition: interface.h:95
int nb_control
Definition: irregular.h:93
char ** body
Definition: irregular.h:100
osl_irregular_p osl_irregular_add_control(osl_irregular_p irregular, char **iterators, int nb_iterators, char *body)
Definition: irregular.c:503
void osl_irregular_dump(FILE *file, osl_irregular_p irregular)
Definition: irregular.c:147
int * nb_iterators
Definition: irregular.h:95
osl_irregular_p osl_irregular_clone(osl_irregular_p irregular)
Definition: irregular.c:381
osl_irregular_p osl_irregular_add_exit(osl_irregular_p irregular, char **iterators, int nb_iterators, char *body)
Definition: irregular.c:592
int * nb_predicates
Definition: irregular.h:104
osl_irregular_p osl_irregular_add_predicates(osl_irregular_p irregular, int *predicates, int nb_add_predicates)
Definition: irregular.c:667
void(* osl_free_f)(void *)
Definition: interface.h:79