source/scop.c

   1
   2     /*+-----------------------------------------------------------------**
   3      **                       OpenScop Library                          **
   4      **-----------------------------------------------------------------**
   5      **                            scop.c                               **
   6      **-----------------------------------------------------------------**
   7      **                   First version: 30/04/2008                     **
   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 <ctype.h>
  66 # include <string.h>
  67 # include <osl/scop.h>
  68
  69
  70 /*+***************************************************************************
  71  *                         Structure display functions                       *
  72  *****************************************************************************/
  73
  74
  75 /**
  76  * osl_scop_idump function:
  77  * this function displays an osl_scop_t structure (*scop) into a
  78  * file (file, possibly stdout) in a way that trends to be understandable. It
  79  * includes an indentation level (level) in order to work with others
  80  * print_structure functions.
  81  * \param file  The file where the information has to be printed.
  82  * \param scop  The scop structure whose information has to be printed.
  83  * \param level Number of spaces before printing, for each line.
  84  */
  85 void osl_scop_idump(FILE * file, osl_scop_p scop, int level) {
  86   int j, first = 1;
  87
  88   // Go to the right level.
  89   for (j = 0; j < level; j++)
  90     fprintf(file, "|\t");
  91
  92   if (scop != NULL)
  93     fprintf(file, "+-- osl_scop_t\n");
  94   else
  95     fprintf(file, "+-- NULL scop\n");
  96
  97   while (scop != NULL) {
  98     if (!first) {
  99       // Go to the right level.
 100       for (j = 0; j < level; j++)
 101         fprintf(file, "|\t");
 102       fprintf(file, "|   osl_scop_t\n");
 103     }
 104     else
 105       first = 0;
 106
 107     // A blank line.
 108     for (j = 0; j <= level+1; j++)
 109       fprintf(file, "|\t");
 110     fprintf(file, "\n");
 111
 112     // Print the version.
 113     for (j = 0; j < level; j++)
 114       fprintf(file, "|\t");
 115     fprintf(file, "|\tVersion: %d\n", scop->version);
 116
 117     // A blank line.
 118     for (j = 0; j <= level+1; j++)
 119       fprintf(file, "|\t");
 120     fprintf(file, "\n");
 121
 122     // Print the language.
 123     for (j = 0; j < level; j++)
 124       fprintf(file, "|\t");
 125     fprintf(file, "|\tLanguage: %s\n", scop->language);
 126
 127     // A blank line.
 128     for (j = 0; j <= level+1; j++)
 129       fprintf(file, "|\t");
 130     fprintf(file, "\n");
 131
 132     // Print the context of the scop.
 133     osl_relation_idump(file, scop->context, level+1);
 134
 135     // Print the parameters.
 136     osl_generic_idump(file, scop->parameters, level+1);
 137
 138     // Print the statements.
 139     osl_statement_idump(file, scop->statement, level+1);
 140
 141     // Print the registered extension interfaces.
 142     osl_interface_idump(file, scop->registry, level+1);
 143
 144     // Print the extensions.
 145     osl_generic_idump(file, scop->extension, level+1);
 146
 147     scop = scop->next;
 148
 149     // Next line.
 150     if (scop != NULL) {
 151       for (j = 0; j <= level; j++)
 152         fprintf(file, "|\t");
 153       fprintf(file, "V\n");
 154     }
 155   }
 156
 157   // The last line.
 158   for (j = 0; j <= level; j++)
 159     fprintf(file, "|\t");
 160   fprintf(file, "\n");
 161 }
 162
 163
 164 /**
 165  * osl_scop_dump function:
 166  * this function prints the content of an osl_scop_t structure (*scop)
 167  * into a file (file, possibly stdout).
 168  * \param file The file where the information has to be printed.
 169  * \param scop The scop structure whose information has to be printed.
 170  */
 171 void osl_scop_dump(FILE * file, osl_scop_p scop) {
 172   osl_scop_idump(file, scop, 0);
 173 }
 174
 175
 176 /**
 177  * osl_scop_names function:
 178  * this function generates as set of names for all the dimensions
 179  * involved in a given scop.
 180  * \param[in] scop The scop (list) we have to generate names for.
 181  * \return A set of generated names for the input scop dimensions.
 182  */
 183 static
 184 osl_names_p osl_scop_names(osl_scop_p scop) {
 185   int nb_parameters = OSL_UNDEFINED;
 186   int nb_iterators  = OSL_UNDEFINED;
 187   int nb_scattdims  = OSL_UNDEFINED;
 188   int nb_localdims  = OSL_UNDEFINED;
 189   int array_id      = OSL_UNDEFINED;
 190
 191   osl_scop_get_attributes(scop, &nb_parameters, &nb_iterators,
 192                           &nb_scattdims,  &nb_localdims, &array_id);
 193
 194   return osl_names_generate("P", nb_parameters,
 195                             "i", nb_iterators,
 196                             "c", nb_scattdims,
 197                             "l", nb_localdims,
 198                             "A", array_id);
 199 }
 200
 201
 202 /**
 203  * osl_scop_print function:
 204  * this function prints the content of an osl_scop_t structure (*scop)
 205  * into a file (file, possibly stdout) in the OpenScop textual format.
 206  * \param file The file where the information has to be printed.
 207  * \param scop The scop structure whose information has to be printed.
 208  */
 209 void osl_scop_print(FILE * file, osl_scop_p scop) {
 210   int parameters_backedup = 0;
 211   osl_strings_p parameters_backup = NULL;
 212   osl_names_p names;
 213
 214   if (scop == NULL) {
 215     fprintf(file, "# NULL scop\n");
 216     return;
 217   }
 218   else {
 219     fprintf(file, "# [File generated by the OpenScop Library %s]\n",
 220             OSL_RELEASE);
 221   }
 222
 223   if (osl_scop_integrity_check(scop) == 0)
 224     OSL_warning("OpenScop integrity check failed. "
 225                      "Something may go wrong.");
 226
 227   // Generate the names for the various dimensions.
 228   names = osl_scop_names(scop);
 229
 230   while (scop != NULL) {
 231     // If possible, replace parameter names with scop iterator names.
 232     if (osl_generic_has_URI(scop->parameters, OSL_URI_STRINGS)) {
 233       parameters_backedup = 1;
 234       parameters_backup = names->parameters;
 235       names->parameters = scop->parameters->data;
 236     }
 237
 238     fprintf(file, "\n"OSL_TAG_START_SCOP"\n\n");
 239     fprintf(file, "# =============================================== "
 240                   "Global\n");
 241     fprintf(file, "# Language\n");
 242     fprintf(file, "%s\n\n", scop->language);
 243
 244     fprintf(file, "# Context\n");
 245     osl_relation_pprint(file, scop->context, names);
 246     fprintf(file, "\n");
 247
 248     osl_util_print_provided(file,
 249         osl_generic_has_URI(scop->parameters, OSL_URI_STRINGS),
 250         "Parameters are");
 251     osl_generic_print(file, scop->parameters);
 252
 253     fprintf(file, "\n# Number of statements\n");
 254     fprintf(file, "%d\n\n",osl_statement_number(scop->statement));
 255
 256     osl_statement_pprint(file, scop->statement, names);
 257
 258     if (scop->extension) {
 259       fprintf(file, "# =============================================== "
 260                     "Extensions\n");
 261       osl_generic_print(file, scop->extension);
 262     }
 263     fprintf(file, "\n"OSL_TAG_END_SCOP"\n\n");
 264
 265     // If necessary, switch back parameter names.
 266     if (parameters_backedup) {
 267       parameters_backedup = 0;
 268       names->parameters = parameters_backup;
 269     }
 270
 271     scop = scop->next;
 272   }
 273
 274   osl_names_free(names);
 275 }
 276
 277
 278 /*****************************************************************************
 279  *                               Reading function                            *
 280  *****************************************************************************/
 281
 282
 283 /**
 284  * osl_scop_pread function ("precision read"):
 285  * this function reads a list of scop structures from a file (possibly stdin)
 286  * complying to the OpenScop textual format and returns a pointer to this
 287  * scop list. If some relation properties (number of input/output/local
 288  * dimensions and number of parameters) are undefined, it will define them
 289  * according to the available information.
 290  * \param[in] file      The file where the scop has to be read.
 291  * \param[in] precision The precision of the relation elements.
 292  * \return A pointer to the scop structure that has been read.
 293  */
 294 osl_scop_p osl_scop_pread(FILE * file, int precision) {
 295   osl_scop_p list = NULL, current = NULL, scop;
 296   osl_statement_p stmt = NULL;
 297   osl_statement_p prev = NULL;
 298   osl_interface_p interface;
 299   osl_strings_p language;
 300   int nb_statements;
 301   char buffer[OSL_MAX_STRING];
 302   char * tmp, * start;
 303   int first = 1;
 304   int i;
 305
 306   if (file == NULL)
 307     return NULL;
 308
 309   while(1) {
 310     //
 311     // I. START TAG
 312     //
 313     tmp = osl_util_read_uptotag(file, OSL_TAG_START_SCOP);
 314     free(tmp);
 315     if (feof(file)) {
 316       OSL_debug("no more scop in the file");
 317       break;
 318     }
 319
 320     scop = osl_scop_malloc();
 321     osl_scop_register_default_extensions(scop);
 322
 323     //
 324     // II. CONTEXT PART
 325     //
 326
 327     // Read the language.
 328     language = osl_strings_read(file);
 329     if (osl_strings_size(language) == 0)
 330       OSL_error("no language (backend) specified");
 331
 332     if (osl_strings_size(language) > 1)
 333       OSL_warning("uninterpreted information (after language)");
 334
 335     if (language != NULL) {
 336       scop->language = strdup(language->string[0]);
 337       osl_strings_free(language);
 338     }
 339
 340     // Read the context domain.
 341     scop->context = osl_relation_pread(file, precision);
 342
 343     // Read the parameters.
 344     scop->parameter_type = OSL_TYPE_STRING;
 345     if (osl_util_read_int(file, NULL) > 0) {
 346       interface = osl_strings_interface();
 347       start = osl_util_skip_blank_and_comments(file, buffer);
 348       scop->parameters = osl_generic_sread(start, interface);
 349       osl_interface_free(interface);
 350     }
 351
 352     //
 353     // III. STATEMENT PART
 354     //
 355
 356     // Read the number of statements.
 357     nb_statements = osl_util_read_int(file, NULL);
 358
 359     for (i = 0; i < nb_statements; i++) {
 360       // Read each statement.
 361       stmt = osl_statement_pread(file, precision);
 362       if (scop->statement == NULL)
 363         scop->statement = stmt;
 364       else
 365         prev->next = stmt;
 366       prev = stmt;
 367     }
 368
 369     //
 370     // IV. EXTENSION PART (TO THE END TAG)
 371     //
 372
 373     // Read up the end tag (if any), and store extensions.
 374     scop->extension = osl_generic_read(file, scop->registry);
 375
 376     // Add the new scop to the list.
 377     if (first) {
 378       list = scop;
 379       first = 0;
 380     }
 381     else {
 382       current->next = scop;
 383     }
 384     current = scop;
 385   }
 386
 387   if (!osl_scop_integrity_check(list))
 388     OSL_warning("scop integrity check failed");
 389
 390   return list;
 391 }
 392
 393
 394 /**
 395  * osl_scop_read function:
 396  * this function is equivalent to osl_scop_pread() except that
 397  * the precision corresponds to the precision environment variable or
 398  * to the highest available precision if it is not defined.
 399  * \see{osl_scop_pread}
 400  */
 401 osl_scop_p osl_scop_read(FILE * foo) {
 402   int precision = osl_util_get_precision();
 403   return osl_scop_pread(foo, precision);
 404 }
 405
 406
 407 /*+***************************************************************************
 408  *                   Memory allocation/deallocation functions                *
 409  *****************************************************************************/
 410
 411
 412 /**
 413  * osl_scop_malloc function:
 414  * this function allocates the memory space for a osl_scop_t structure and
 415  * sets its fields with default values. Then it returns a pointer to the
 416  * allocated space.
 417  * \return A pointer to an empty scop with fields set to default values.
 418  */
 419 osl_scop_p osl_scop_malloc() {
 420   osl_scop_p scop;
 421
 422   OSL_malloc(scop, osl_scop_p, sizeof(osl_scop_t));
 423   scop->version        = 1;
 424   scop->language       = NULL;
 425   scop->context        = NULL;
 426   scop->parameter_type = OSL_UNDEFINED;
 427   scop->parameters     = NULL;
 428   scop->statement      = NULL;
 429   scop->registry       = NULL;
 430   scop->extension      = NULL;
 431   scop->usr            = NULL;
 432   scop->next           = NULL;
 433
 434   return scop;
 435 }
 436
 437
 438 /**
 439  * osl_scop_free function:
 440  * This function frees the allocated memory for a osl_scop_t structure.
 441  * \param scop The pointer to the scop we want to free.
 442  */
 443 void osl_scop_free(osl_scop_p scop) {
 444   osl_scop_p tmp;
 445
 446   while (scop != NULL) {
 447     if (scop->language != NULL)
 448       free(scop->language);
 449     osl_generic_free(scop->parameters);
 450     osl_relation_free(scop->context);
 451     osl_statement_free(scop->statement);
 452     osl_interface_free(scop->registry);
 453     osl_generic_free(scop->extension);
 454
 455     tmp = scop->next;
 456     free(scop);
 457     scop = tmp;
 458   }
 459 }
 460
 461
 462 /*+***************************************************************************
 463  *                            Processing functions                           *
 464  *****************************************************************************/
 465
 466
 467 /**
 468  * osl_scop_register_default_extensions function:
 469  * this function registers the default OpenScop Library extensions to an
 470  * existing scop.
 471  * \param scop The scop for which default options have to be registered.
 472  */
 473 void osl_scop_register_default_extensions(osl_scop_p scop) {
 474
 475   osl_interface_add(&(scop->registry), osl_textual_interface());
 476   osl_interface_add(&(scop->registry), osl_comment_interface());
 477   osl_interface_add(&(scop->registry), osl_arrays_interface());
 478   osl_interface_add(&(scop->registry), osl_lines_interface());
 479   osl_interface_add(&(scop->registry), osl_irregular_interface());
 480 }
 481
 482
 483 /**
 484  * osl_scop_clone function:
 485  * This functions builds and returns a "hard copy" (not a pointer copy)
 486  * of a osl_statement_t data structure provided as parameter.
 487  * Note that the usr field is not touched by this function.
 488  * \param statement The pointer to the scop we want to clone.
 489  * \return A pointer to the full clone of the scop provided as parameter.
 490  */
 491 osl_scop_p osl_scop_clone(osl_scop_p scop) {
 492   osl_scop_p clone = NULL, node, previous = NULL;
 493   int first = 1;
 494
 495   while (scop != NULL) {
 496     node                 = osl_scop_malloc();
 497     node->version        = scop->version;
 498     if (scop->language != NULL)
 499       node->language     = strdup(scop->language);
 500     node->context        = osl_relation_clone(scop->context);
 501     node->parameter_type = scop->parameter_type;
 502     node->parameters     = osl_generic_clone(scop->parameters);
 503     node->statement      = osl_statement_clone(scop->statement);
 504     node->registry       = osl_interface_clone(scop->registry);
 505     node->extension      = osl_generic_clone(scop->extension);
 506
 507     if (first) {
 508       first = 0;
 509       clone = node;
 510       previous = node;
 511     }
 512     else {
 513       previous->next = node;
 514       previous = previous->next;
 515     }
 516
 517     scop = scop->next;
 518   }
 519
 520   return clone;
 521 }
 522
 523
 524 /**
 525  * osl_scop_equal function:
 526  * this function returns true if the two scops are the same, false
 527  * otherwise (the usr field is not tested).
 528  * \param s1 The first scop.
 529  * \param s2 The second scop.
 530  * \return 1 if s1 and s2 are the same (content-wise), 0 otherwise.
 531  */
 532 int osl_scop_equal(osl_scop_p s1, osl_scop_p s2) {
 533
 534   while ((s1 != NULL) && (s2 != NULL)) {
 535     if (s1 == s2)
 536       return 1;
 537
 538     if (s1->version != s2->version) {
 539       OSL_info("versions are not the same");
 540       return 0;
 541     }
 542
 543     if (strcmp(s1->language, s2->language) != 0) {
 544       OSL_info("languages are not the same");
 545       return 0;
 546     }
 547
 548     if (!osl_relation_equal(s1->context, s2->context)) {
 549       OSL_info("contexts are not the same");
 550       return 0;
 551     }
 552
 553     if (s1->parameter_type != s2->parameter_type) {
 554       OSL_info("parameter types are not the same");
 555       return 0;
 556     }
 557
 558     if (!osl_generic_equal(s1->parameters, s2->parameters)) {
 559       OSL_info("parameters are not the same");
 560       return 0;
 561     }
 562
 563     if (!osl_statement_equal(s1->statement, s2->statement)) {
 564       OSL_info("statements are not the same");
 565       return 0;
 566     }
 567
 568     if (!osl_interface_equal(s1->registry, s2->registry)) {
 569       OSL_info("registries are not the same");
 570       return 0;
 571     }
 572
 573     if (!osl_generic_equal(s1->extension, s2->extension)) {
 574       OSL_info("extensions are not the same");
 575       return 0;
 576     }
 577
 578     s1 = s1->next;
 579     s2 = s2->next;
 580   }
 581
 582   if (((s1 == NULL) && (s2 != NULL)) || ((s1 != NULL) && (s2 == NULL)))
 583     return 0;
 584
 585   return 1;
 586 }
 587
 588
 589 /**
 590  * osl_scop_integrity_check function:
 591  * This function checks that a scop is "well formed". It returns 0 if the
 592  * check failed or 1 if no problem has been detected.
 593  * \param scop  The scop we want to check.
 594  * \return 0 if the integrity check fails, 1 otherwise.
 595  */
 596 int osl_scop_integrity_check(osl_scop_p scop) {
 597   int expected_nb_parameters;
 598
 599
 600   while (scop != NULL) {
 601     // Check the language.
 602     if ((scop->language != NULL) &&
 603         (!strcmp(scop->language, "caml")  || !strcmp(scop->language, "Caml") ||
 604          !strcmp(scop->language, "ocaml") || !strcmp(scop->language, "OCaml")))
 605       fprintf(stderr, "[OpenScop] Alert: What ?! Caml ?! Are you sure ?!?!\n");
 606
 607     // Check the context.
 608     if (!osl_relation_integrity_check(scop->context,
 609                                       OSL_TYPE_CONTEXT,
 610                                       OSL_UNDEFINED,
 611                                       OSL_UNDEFINED,
 612                                       OSL_UNDEFINED))
 613       return 0;
 614
 615     // Get the number of parameters.
 616     if (scop->context != NULL)
 617       expected_nb_parameters = scop->context->nb_parameters;
 618     else
 619       expected_nb_parameters = OSL_UNDEFINED;
 620
 621     // TODO : check the number of parameter strings.
 622
 623     if (!osl_statement_integrity_check(scop->statement,
 624                                        expected_nb_parameters))
 625       return 0;
 626
 627     scop = scop->next;
 628   }
 629
 630   return 1;
 631 }
 632
 633
 634 /**
 635  * osl_scop_get_nb_parameters function:
 636  * this function returns the number of global parameters of a given SCoP.
 637  * \param scop The scop we want to know the number of global parameters.
 638  * \return The number of global parameters in the scop.
 639  */
 640 int osl_scop_get_nb_parameters(osl_scop_p scop) {
 641
 642   if (scop->context == NULL) {
 643     OSL_warning("no context domain, assuming 0 parameters");
 644     return 0;
 645   }
 646   else {
 647     return scop->context->nb_parameters;
 648   }
 649 }
 650
 651
 652 /**
 653  * osl_scop_register_extension function:
 654  * this function registers a list of extension interfaces to a scop, i.e., it
 655  * adds them to the scop registry. In addition, it will extract extensions
 656  * corresponding to those interfaces from the textual form of the extensions
 657  * (if any) and add them to the scop extension list.
 658  * \param scop      The scop for which an extension has to be registered.
 659  * \param interface The extension interface to register within the scop.
 660  */
 661 void osl_scop_register_extension(osl_scop_p scop, osl_interface_p interface) {
 662   osl_generic_p textual, new;
 663   char * extension_string;
 664
 665   if ((interface != NULL) && (scop != NULL)) {
 666     osl_interface_add(&scop->registry, interface);
 667
 668     textual = osl_generic_lookup(scop->extension, interface->URI);
 669     if (textual != NULL) {
 670       extension_string = ((osl_textual_p)textual->data)->textual;
 671       new = osl_generic_sread(extension_string, interface);
 672       osl_generic_add(&scop->extension, new);
 673     }
 674   }
 675 }
 676
 677
 678 /**
 679  * osl_scop_get_attributes function:
 680  * this function returns, through its parameters, the maximum values of the
 681  * relation attributes (nb_iterators, nb_parameters etc) in the scop.
 682  * HOWEVER, it updates the parameter value iff the attribute is greater than
 683  * the input parameter value. Hence it may be used to get the attributes as
 684  * well as to find the maximum attributes for several scop lists. The array
 685  * identifier 0 is used when there is no array identifier (AND this is OK),
 686  * OSL_UNDEFINED is used to report it is impossible to provide the property
 687  * while it should. This function is not intended for checking, the input
 688  * scop should be correct.
 689  * \param[in]     scop          The scop to extract attributes values.
 690  * \param[in,out] nb_parameters Number of parameter attribute.
 691  * \param[in,out] nb_iterators  Number of iterators attribute.
 692  * \param[in,out] nb_scattdims  Number of scattering dimensions attribute.
 693  * \param[in,out] nb_localdims  Number of local dimensions attribute.
 694  * \param[in,out] array_id      Maximum array identifier attribute.
 695  */
 696 void osl_scop_get_attributes(osl_scop_p scop,
 697                              int * nb_parameters,
 698                              int * nb_iterators,
 699                              int * nb_scattdims,
 700                              int * nb_localdims,
 701                              int * array_id) {
 702   int local_nb_parameters = OSL_UNDEFINED;
 703   int local_nb_iterators  = OSL_UNDEFINED;
 704   int local_nb_scattdims  = OSL_UNDEFINED;
 705   int local_nb_localdims  = OSL_UNDEFINED;
 706   int local_array_id      = OSL_UNDEFINED;
 707
 708   while (scop != NULL) {
 709     osl_relation_get_attributes(scop->context,
 710                                 &local_nb_parameters,
 711                                 &local_nb_iterators,
 712                                 &local_nb_scattdims,
 713                                 &local_nb_localdims,
 714                                 &local_array_id);
 715
 716     osl_statement_get_attributes(scop->statement,
 717                                 &local_nb_parameters,
 718                                 &local_nb_iterators,
 719                                 &local_nb_scattdims,
 720                                 &local_nb_localdims,
 721                                 &local_array_id);
 722     // Update.
 723     *nb_parameters = OSL_max(*nb_parameters, local_nb_parameters);
 724     *nb_iterators  = OSL_max(*nb_iterators,  local_nb_iterators);
 725     *nb_scattdims  = OSL_max(*nb_scattdims,  local_nb_scattdims);
 726     *nb_localdims  = OSL_max(*nb_localdims,  local_nb_localdims);
 727     *array_id      = OSL_max(*array_id,      local_array_id);
 728     scop = scop->next;
 729   }
 730 }
 731
 732
 733 /**
 734  * osl_scop_normalize_scattering function:
 735  * this function modifies a scop such that all scattering relation have
 736  * the same number of output dimensions (additional output dimensions are
 737  * set as being equal to zero).
 738  * \param[in,out] scop The scop to nomalize the scattering functions.
 739  */
 740 void osl_scop_normalize_scattering(osl_scop_p scop) {
 741   int max_scattering_dims = 0;
 742   osl_statement_p statement;
 743   osl_relation_p extended;
 744
 745   if ((scop != NULL) && (scop->statement != NULL)) {
 746     // Get the max number of scattering dimensions.
 747     statement = scop->statement;
 748     while (statement != NULL) {
 749       if (statement->scattering != NULL) {
 750         max_scattering_dims = OSL_max(max_scattering_dims,
 751                                       statement->scattering->nb_output_dims);
 752       }
 753       statement = statement->next;
 754     }
 755
 756     // Normalize.
 757     statement = scop->statement;
 758     while (statement != NULL) {
 759       if (statement->scattering != NULL) {
 760         extended = osl_relation_extend_output(statement->scattering,
 761                                               max_scattering_dims);
 762         osl_relation_free(statement->scattering);
 763         statement->scattering = extended;
 764       }
 765       statement = statement->next;
 766     }
 767   }
 768 }
 769