OpenScop  0.9.1
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  size_t high_water_mark = OSL_MAX_STRING;
161  int i,j;
162  char * string = NULL;
163  char * buffer;
164 
165  if (irregular != NULL) {
166  OSL_malloc(string, char *, high_water_mark * sizeof(char));
167  OSL_malloc(buffer, char *, OSL_MAX_STRING * sizeof(char));
168  string[0] = '\0';
169 
170  // Print the begin tag.
171  sprintf(buffer, OSL_TAG_IRREGULAR_START);
172  osl_util_safe_strcat(&string, buffer, &high_water_mark);
173 
174  // Print the content.
175  sprintf(buffer, "\n%d\n", irregular->nb_statements);
176  for(i=0; i<irregular->nb_statements; i++) {
177  sprintf(buffer, "%s%d ", buffer, irregular->nb_predicates[i]);
178  for(j=0; j<irregular->nb_predicates[i]; j++) {
179  sprintf(buffer, "%s%d ", buffer, irregular->predicates[i][j]);
180  }
181  sprintf(buffer, "%s\n", buffer);
182  }
183  // Print the predicates.
184  // controls:
185  sprintf(buffer, "%s%d\n", buffer, irregular->nb_control);
186  sprintf(buffer, "%s%d\n", buffer, irregular->nb_exit);
187  for(i=0; i<irregular->nb_control; i++) {
188  sprintf(buffer, "%s%d ", buffer, irregular->nb_iterators[i]);
189  for(j=0; j<irregular->nb_iterators[i];j++)
190  sprintf(buffer, "%s%s ", buffer, irregular->iterators[i][j]);
191  sprintf(buffer, "%s\n%s\n", buffer, irregular->body[i]);
192  }
193  // exits:
194  for(i=0; i<irregular->nb_exit; i++) {
195  sprintf(buffer, "%s%d ", buffer, irregular->nb_iterators[
196  irregular->nb_control + i]);
197  for(j=0; j<irregular->nb_iterators[irregular->nb_control + i];j++)
198  sprintf(buffer, "%s%s ", buffer, irregular->iterators[
199  irregular->nb_control+i][j]);
200  sprintf(buffer, "%s\n%s\n", buffer, irregular->body[
201  irregular->nb_control + i]);
202  }
203 
204  osl_util_safe_strcat(&string, buffer, &high_water_mark);
205 
206  // Print the end tag.
207  sprintf(buffer, OSL_TAG_IRREGULAR_STOP"\n");
208  osl_util_safe_strcat(&string, buffer, &high_water_mark);
209 
210  // Keep only the memory space we need.
211  OSL_realloc(string, char *, (strlen(string) + 1) * sizeof(char));
212  free(buffer);
213  }
214 
215  return string;
216 }
217 
218 
219 /*****************************************************************************
220  * Reading function *
221  *****************************************************************************/
222 
231 osl_irregular_p osl_irregular_sread(char ** extensions_fixme) {
232  char * content,*tok;
233  int i,j;
234  osl_irregular_p irregular;
235 
236  // FIXME: this is a quick and dirty thing to accept char ** instead
237  // of char * in the parameter: really do it and update the
238  // pointer to after what has been read.
239  content = *extensions_fixme;
240 
241  if (content == NULL) {
242  OSL_debug("no irregular optional tag");
243  return NULL;
244  }
245 
246  if (strlen(content) > OSL_MAX_STRING)
247  OSL_error("irregular too long");
248 
249  irregular = osl_irregular_malloc();
250 
251  // nb statements
252  tok = strtok(content," \n");
253  irregular->nb_statements = atoi(tok);
254  OSL_malloc(irregular->predicates, int **,
255  sizeof(int*) * irregular->nb_statements);
256  OSL_malloc(irregular->nb_predicates, int *,
257  sizeof(int) * irregular->nb_statements);
258 
259  // get predicats
260  for(i = 0; i < irregular->nb_statements; i++) {
261  // nb conditions
262  tok = strtok(NULL," \n");
263  irregular->nb_predicates[i] = atoi(tok);
264  OSL_malloc(irregular->predicates[i], int *,
265  sizeof(int) * irregular->nb_predicates[i]);
266  for(j = 0; j < irregular->nb_predicates[i]; j++){
267  tok = strtok(NULL, " \n");
268  irregular->predicates[i][j] = atoi(tok);
269  }
270  }
271  // Get nb predicat
272  // control and exits :
273  tok = strtok(NULL, " \n");
274  irregular->nb_control=atoi(tok);
275  tok = strtok(NULL, " \n");
276  irregular->nb_exit = atoi(tok);
277 
278  int nb_predicates = irregular->nb_control + irregular->nb_exit;
279 
280  OSL_malloc(irregular->iterators, char ***,
281  sizeof(char **) * nb_predicates);
282  OSL_malloc(irregular->nb_iterators, int *, sizeof(int) * nb_predicates);
283  OSL_malloc(irregular->body, char **, sizeof(char *) * nb_predicates);
284 
285  for(i = 0; i < nb_predicates; i++) {
286  // Get number of iterators
287  tok = strtok(NULL, " \n");
288  irregular->nb_iterators[i] = atoi(tok);
289  OSL_malloc(irregular->iterators[i], char **,
290  sizeof(char *) * irregular->nb_iterators[i]);
291 
292  // Get iterators
293  for(j = 0; j < irregular->nb_iterators[i]; j++)
294  OSL_strdup(irregular->iterators[i][j], strtok(NULL, " \n"));
295  // Get predicat string
296  OSL_strdup(irregular->body[i], strtok(NULL, "\n"));
297  }
298 
299  return irregular;
300 }
301 
302 
303 /*+***************************************************************************
304  * Memory allocation/deallocation function *
305  *****************************************************************************/
306 
307 
317  osl_irregular_p irregular;
318 
319  OSL_malloc(irregular, osl_irregular_p,
320  sizeof(osl_irregular_t));
321  irregular->nb_statements = 0;
322  irregular->predicates = NULL;
323  irregular->nb_predicates = NULL;
324  irregular->nb_control = 0;
325  irregular->nb_exit = 0;
326  irregular->nb_iterators = NULL;
327  irregular->iterators = NULL;
328  irregular->body = NULL;
329 
330  return irregular;
331 }
332 
333 
341  int i, j, nb_predicates;
342 
343  if (irregular != NULL) {
344  for(i = 0; i < irregular->nb_statements; i++)
345  free(irregular->predicates[i]);
346 
347  if(irregular->predicates != NULL)
348  free(irregular->predicates);
349 
350  nb_predicates = irregular->nb_control + irregular->nb_exit;
351  for(i = 0; i < nb_predicates; i++) {
352  for(j = 0; j < irregular->nb_iterators[i]; j++)
353  free(irregular->iterators[i][j]);
354  free(irregular->iterators[i]);
355  free(irregular->body[i]);
356  }
357  if(irregular->iterators != NULL)
358  free(irregular->iterators);
359  if(irregular->nb_iterators != NULL)
360  free(irregular->nb_iterators);
361  if(irregular->body != NULL)
362  free(irregular->body);
363  if(irregular->nb_predicates != NULL)
364  free(irregular->nb_predicates);
365  free(irregular);
366  }
367 }
368 
369 
370 /*+***************************************************************************
371  * Processing functions *
372  *****************************************************************************/
373 
374 
383  int i,j;
384  osl_irregular_p copy;
385 
386  if (irregular == NULL)
387  return NULL;
388 
389  copy = osl_irregular_malloc();
390  copy->nb_statements = irregular->nb_statements;
391  copy->nb_predicates = (int *)malloc(sizeof(int)*copy->nb_statements);
392  if (copy->nb_predicates == NULL)
393  {
394  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
395  exit(1);
396  }
397  copy->predicates = (int **)malloc(sizeof(int*)*copy->nb_statements);
398  if (copy->predicates == NULL)
399  {
400  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
401  exit(1);
402  }
403  for(i=0; i<copy->nb_statements; i++)
404  {
405  copy->nb_predicates[i]=irregular->nb_predicates[i];
406  copy->predicates[i] = (int *)malloc(sizeof(int)*copy->nb_predicates[i]);
407  if (copy->predicates[i] == NULL)
408  {
409  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
410  exit(1);
411  }
412  for(j=0; j<copy->nb_predicates[i]; j++)
413  copy->predicates[i][j] = irregular->predicates[i][j];
414  }
415 
416  copy->nb_control = irregular->nb_control;
417  copy->nb_exit = irregular->nb_exit;
418  int nb_predicates = irregular->nb_control + irregular->nb_exit;
419  copy->nb_iterators = (int *)malloc(sizeof(int)*nb_predicates);
420  if (copy->nb_iterators == NULL)
421  {
422  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
423  exit(1);
424  }
425  copy->iterators = (char ***)malloc(sizeof(char**)*nb_predicates);
426  if (copy->iterators == NULL)
427  {
428  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
429  exit(1);
430  }
431  copy->body = (char **)malloc(sizeof(char*)*nb_predicates);
432  if (copy->body == NULL)
433  {
434  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
435  exit(1);
436  }
437  for(i=0; i<nb_predicates; i++)
438  {
439  copy->nb_iterators[i] = irregular->nb_iterators[i];
440  copy->iterators[i] = (char**)malloc(sizeof(char*)*copy->nb_iterators[i]);
441  if (copy->iterators[i] == NULL)
442  {
443  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
444  exit(1);
445  }
446  for(j=0;j<copy->nb_iterators[i];j++)
447  OSL_strdup(copy->iterators[i][j], irregular->iterators[i][j]);
448  OSL_strdup(copy->iterators[i][j], irregular->body[i]);
449  }
450 
451  return copy;
452 }
453 
454 
463 int
465 {
466  int i,j,bool = 0;
467  if (c1 == c2)
468  return 1;
469 
470  if (((c1 == NULL) && (c2 != NULL)) || ((c1 != NULL) && (c2 == NULL)))
471  return 0;
472 
473  if(c1->nb_statements != c2->nb_statements ||
474  c1->nb_control != c2->nb_control ||
475  c1->nb_exit != c2->nb_exit)
476  return 0;
477  i=0;
478  while(bool == 0 && i < c1->nb_statements)
479  {
480  bool = c1->nb_predicates[i] != c2->nb_predicates[i] ? 1 : 0;
481  i++;
482  }
483  if(bool != 0)
484  return 0;
485 
486  i = 0;
487  while(bool == 0 && i < c1->nb_control + c1->nb_exit)
488  {
489  bool += c1->nb_iterators[i] != c2->nb_iterators[i] ? 1 : 0;
490  bool += strcmp(c1->body[i],c2->body[i]);
491  j = 0;
492  while(bool == 0 && j < c1->nb_iterators[i])
493  {
494  bool += strcmp(c1->iterators[i][j],c2->iterators[i][j]);
495  j++;
496  }
497  i++;
498  }
499  if(bool != 0)
500  return 0;
501  return 1;
502 }
503 
505  osl_irregular_p irregular,
506  char** iterators,
507  int nb_iterators,
508  char* body)
509 {
510  int i,j;
512 
513  result->nb_control = irregular->nb_control + 1;
514  result->nb_exit = irregular->nb_exit;
515  result->nb_statements = irregular->nb_statements;
516  int nb_predicates = result->nb_control + result->nb_exit;
517 
518  result->iterators = (char***)malloc(sizeof(char**)*nb_predicates);
519  result->nb_iterators = (int*)malloc(sizeof(int)*nb_predicates);
520  result->body = (char**)malloc(sizeof(char*)*nb_predicates);
521  if (result->iterators == NULL ||
522  result->nb_iterators == NULL ||
523  result->body == NULL)
524  {
525  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
526  exit(1);
527  }
528  //copy controls
529  for(i=0; i<irregular->nb_control; i++)
530  {
531  result->nb_iterators[i] = irregular->nb_iterators[i];
532  OSL_strdup(result->body[i], irregular->body[i]);
533  result->iterators[i] = (char**)malloc(sizeof(char*) *
534  irregular->nb_iterators[i]);
535  if (result->iterators[i] == NULL)
536  {
537  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
538  exit(1);
539  }
540  for(j=0; j<irregular->nb_iterators[i];j++)
541  OSL_strdup(result->iterators[i][j], irregular->iterators[i][j]);
542  }
543  //add controls
544  result->iterators[irregular->nb_control] = (char**)malloc(sizeof(char*)*nb_iterators);
545  if (result->iterators[irregular->nb_control] == NULL)
546  {
547  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
548  exit(1);
549  }
550  for(i=0; i<nb_iterators; i++)
551  OSL_strdup(result->iterators[irregular->nb_control][i], iterators[i]);
552  result->nb_iterators[irregular->nb_control] = nb_iterators;
553  OSL_strdup(result->body[irregular->nb_control], body);
554  //copy exits
555  for(i=result->nb_control; i<nb_predicates; i++)
556  {
557  result->nb_iterators[i] = irregular->nb_iterators[i-1];
558  OSL_strdup(result->body[i], irregular->body[i-1]);
559  result->iterators[i] = (char**)malloc(sizeof(char*) *
560  irregular->nb_iterators[i-1]);
561  if (result->iterators[i] == NULL)
562  {
563  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
564  exit(1);
565  }
566  for(j=0; j<irregular->nb_iterators[i-1];j++)
567  OSL_strdup(result->iterators[i][j], irregular->iterators[i-1][j]);
568  }
569  // copy statements
570  result->nb_predicates = (int*)malloc(sizeof(int)*irregular->nb_statements);
571  result->predicates = (int**)malloc(sizeof(int*)*irregular->nb_statements);
572  if (result->nb_predicates == NULL || result->predicates == NULL)
573  {
574  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
575  exit(1);
576  }
577  for(i=0; i<irregular->nb_statements; i++)
578  {
579  result->predicates[i] = (int*)malloc(sizeof(int)*irregular->nb_predicates[i]);
580  if (result->predicates[i] == NULL)
581  {
582  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
583  exit(1);
584  }
585  result->nb_predicates[i] = irregular->nb_predicates[i];
586  for(j=0; j<irregular->nb_predicates[i]; j++)
587  result->predicates[i][j]=irregular->predicates[i][j];
588  }
589  return result;
590 }
591 
592 
594  osl_irregular_p irregular,
595  char** iterators,
596  int nb_iterators,
597  char* body)
598 {
599  int i,j;
601 
602  result->nb_control = irregular->nb_control;
603  result->nb_exit = irregular->nb_exit + 1;
604  result->nb_statements = irregular->nb_statements;
605  int nb_predicates = result->nb_control + result->nb_exit;
606 
607  result->iterators = (char***)malloc(sizeof(char**)*nb_predicates);
608  result->nb_iterators = (int*)malloc(sizeof(int)*nb_predicates);
609  result->body = (char**)malloc(sizeof(char*)*nb_predicates);
610  if (result->iterators == NULL ||
611  result->nb_iterators == NULL ||
612  result->body == NULL)
613  {
614  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
615  exit(1);
616  }
617  //copy controls and exits
618  for(i=0; i<nb_predicates - 1; i++)
619  {
620  result->nb_iterators[i] = irregular->nb_iterators[i];
621  OSL_strdup(result->body[i], irregular->body[i]);
622  result->iterators[i] = (char**)malloc(sizeof(char*) *
623  irregular->nb_iterators[i]);
624  if (result->iterators[i] == NULL)
625  {
626  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
627  exit(1);
628  }
629  for(j=0; j<irregular->nb_iterators[i];j++)
630  OSL_strdup(result->iterators[i][j], irregular->iterators[i][j]);
631  }
632  //add exit
633  result->iterators[nb_predicates-1] = (char**)malloc(sizeof(char*)*nb_iterators);
634  if (result->iterators[nb_predicates-1] == NULL)
635  {
636  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
637  exit(1);
638  }
639 
640  for(i=0; i<nb_iterators; i++)
641  OSL_strdup(result->iterators[nb_predicates-1][i], iterators[i]);
642  result->nb_iterators[nb_predicates-1] = nb_iterators;
643  OSL_strdup(result->body[nb_predicates-1], body);
644  // copy statements
645  result->nb_predicates = (int*)malloc(sizeof(int)*irregular->nb_statements);
646  result->predicates = (int**)malloc(sizeof(int*)*irregular->nb_statements);
647  if (result->nb_predicates == NULL || result->predicates == NULL)
648  {
649  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
650  exit(1);
651  }
652  for(i=0; i<irregular->nb_statements; i++)
653  {
654  result->predicates[i] = (int*)malloc(sizeof(int)*irregular->nb_predicates[i]);
655  if (result->predicates[i] == NULL)
656  {
657  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
658  exit(1);
659  }
660  result->nb_predicates[i] = irregular->nb_predicates[i];
661  for(j=0; j<irregular->nb_predicates[i]; j++)
662  result->predicates[i][j]=irregular->predicates[i][j];
663  }
664  return result;
665 }
666 
667 
669  osl_irregular_p irregular,
670  int* predicates,
671  int nb_add_predicates)
672 {
673  int i,j;
675 
676  result->nb_control = irregular->nb_control;
677  result->nb_exit = irregular->nb_exit;
678  result->nb_statements = irregular->nb_statements+1;
679  int nb_predicates = result->nb_control + result->nb_exit;
680 
681  result->iterators = (char***)malloc(sizeof(char**)*nb_predicates);
682  result->nb_iterators = (int*)malloc(sizeof(int)*nb_predicates);
683  result->body = (char**)malloc(sizeof(char*)*nb_predicates);
684  if (result->iterators == NULL ||
685  result->nb_iterators == NULL ||
686  result->body == NULL)
687  {
688  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
689  exit(1);
690  }
691  //copy controls and exits
692  for(i=0; i<nb_predicates; i++)
693  {
694  result->nb_iterators[i] = irregular->nb_iterators[i];
695  OSL_strdup(result->body[i], irregular->body[i]);
696  result->iterators[i] = (char**)malloc(sizeof(char*) *
697  irregular->nb_iterators[i]);
698  if (result->iterators[i] == NULL)
699  {
700  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
701  exit(1);
702  }
703  for(j=0; j<irregular->nb_iterators[i];j++)
704  OSL_strdup(result->iterators[i][j], irregular->iterators[i][j]);
705  }
706  //copy statements
707  result->nb_predicates = (int*)malloc(sizeof(int)*result->nb_statements);
708  result->predicates = (int**)malloc(sizeof(int*)*result->nb_statements);
709  if (result->nb_predicates == NULL ||
710  result->predicates == NULL)
711  {
712  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
713  exit(1);
714  }
715  for(i=0; i<irregular->nb_statements; i++)
716  {
717  result->predicates[i] = (int*)malloc(sizeof(int)*irregular->nb_predicates[i]);
718  if (result->predicates[i] == NULL)
719  {
720  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
721  exit(1);
722  }
723  result->nb_predicates[i] = irregular->nb_predicates[i];
724  for(j=0; j<irregular->nb_predicates[i]; j++)
725  result->predicates[i][j]=irregular->predicates[i][j];
726  }
727  //add statement
728  result->predicates[irregular->nb_statements] = (int*)malloc(sizeof(int)*nb_add_predicates);
729  if (result->predicates[irregular->nb_statements] == NULL)
730  {
731  fprintf(stderr, "[OpenScop] Error: memory overflow.\n");
732  exit(1);
733  }
734  for(i=0; i<nb_add_predicates; i++)
735  result->predicates[irregular->nb_statements][i] = predicates[i];
736  result->nb_predicates[irregular->nb_statements] = nb_add_predicates;
737 
738  return result;
739 
740 
741 }
742 
743 
752 
753  OSL_strdup(interface->URI, OSL_URI_IRREGULAR);
754  interface->idump = (osl_idump_f)osl_irregular_idump;
755  interface->sprint = (osl_sprint_f)osl_irregular_sprint;
756  interface->sread = (osl_sread_f)osl_irregular_sread;
757  interface->malloc = (osl_malloc_f)osl_irregular_malloc;
758  interface->free = (osl_free_f)osl_irregular_free;
759  interface->clone = (osl_clone_f)osl_irregular_clone;
760  interface->equal = (osl_equal_f)osl_irregular_equal;
761 
762  return interface;
763 }
764 
765 
int nb_statements
Definition: irregular.h:103
void *(* osl_clone_f)(void *)
Definition: interface.h:80
#define OSL_error(msg)
Definition: macros.h:149
void *(* osl_sread_f)(char **)
Definition: interface.h:77
#define OSL_TAG_IRREGULAR_START
Definition: irregular.h:79
void(* osl_idump_f)(FILE *, void *, int)
Definition: interface.h:75
int * nb_predicates
Definition: irregular.h:104
osl_interface_p osl_interface_malloc(void)
Definition: interface.c:212
osl_free_f free
Definition: interface.h:95
int osl_irregular_equal(osl_irregular_p c1, osl_irregular_p c2)
Definition: irregular.c:464
void osl_util_safe_strcat(char **dst, char *src, size_t *hwm)
Definition: util.c:482
char *(* osl_sprint_f)(void *)
Definition: interface.h:76
#define OSL_debug(msg)
Definition: macros.h:133
char * osl_irregular_sprint(osl_irregular_p irregular)
Definition: irregular.c:159
osl_irregular_p osl_irregular_malloc(void)
Definition: irregular.c:316
#define OSL_strdup(destination, source)
Definition: macros.h:169
void *(* osl_malloc_f)(void)
Definition: interface.h:78
int nb_control
Definition: irregular.h:93
#define OSL_realloc(ptr, type, size)
Definition: macros.h:163
int(* osl_equal_f)(void *, void *)
Definition: interface.h:81
osl_malloc_f malloc
Definition: interface.h:94
char ** body
Definition: irregular.h:100
osl_interface_p osl_irregular_interface(void)
Definition: irregular.c:750
osl_irregular_p osl_irregular_add_control(osl_irregular_p irregular, char **iterators, int nb_iterators, char *body)
Definition: irregular.c:504
void osl_irregular_dump(FILE *file, osl_irregular_p irregular)
Definition: irregular.c:147
#define OSL_URI_IRREGULAR
Definition: irregular.h:78
osl_irregular_p osl_irregular_add_exit(osl_irregular_p irregular, char **iterators, int nb_iterators, char *body)
Definition: irregular.c:593
#define OSL_MAX_STRING
Definition: macros.h:94
void(* osl_free_f)(void *)
Definition: interface.h:79
void osl_irregular_free(osl_irregular_p irregular)
Definition: irregular.c:340
osl_irregular_p osl_irregular_add_predicates(osl_irregular_p irregular, int *predicates, int nb_add_predicates)
Definition: irregular.c:668
#define OSL_TAG_IRREGULAR_STOP
Definition: irregular.h:80
void osl_irregular_idump(FILE *file, osl_irregular_p irregular, int level)
Definition: irregular.c:89
osl_irregular_p osl_irregular_clone(osl_irregular_p irregular)
Definition: irregular.c:382
char *** iterators
Definition: irregular.h:96
int ** predicates
Definition: irregular.h:105
osl_irregular_p osl_irregular_sread(char **extensions_fixme)
Definition: irregular.c:231
int * nb_iterators
Definition: irregular.h:95
#define OSL_malloc(ptr, type, size)
Definition: macros.h:157