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 #if 0
 177 /**
 178  * osl_scop_name_limits function:
 179  * this function finds the (maximum) number of various elements of a scop and
 180  * return the values through parameters. To ensure the correctness of the
 181  * results, an integrity check of the input scop should be run before calling
 182  * this function.
 183  * \param scop          The scop to analyse.
 184  * \parem nb_parameters The number of parameters in the scop (output).
 185  * \parem nb_iterators  The number of iterators in the scop (output).
 186  * \parem nb_scattdims  The number of scattdims in the scop (output).
 187  * \parem nb_localdims  The number of local dimensions in the scop (output).
 188  * \parem nb_arrays     The number of arrays in the scop (output).
 189  */
 190 static
 191 void osl_scop_name_limits(osl_scop_p scop,
 192                               int * nb_parameters,
 193                               int * nb_iterators,
 194                               int * nb_scattdims,
 195                               int * nb_localdims,
 196                               int * nb_arrays) {
 197   int array_id;
 198   osl_statement_p statement;
 199   osl_relation_list_p list;
 200
 201   // * The number of parameters is collected from the context,
 202   // * The numbers of local dimensions are collected from all relations
 203   //   in the corresponding field.
 204   *nb_parameters = 0;
 205   *nb_localdims = 0;
 206   if (scop->context != NULL) {
 207     *nb_parameters = scop->context->nb_parameters;
 208     *nb_localdims  = scop->context->nb_local_dims;
 209   }
 210
 211   *nb_iterators = 0;
 212   *nb_scattdims = 0;
 213   *nb_arrays    = 0;
 214   statement = scop->statement;
 215   while (statement != NULL) {
 216     // * The number of iterators are defined by iteration domains,
 217     //   it corresponds to the #output_dims.
 218     if (statement->domain != NULL) {
 219       if (statement->domain->nb_output_dims > *nb_iterators)
 220         *nb_iterators = statement->domain->nb_output_dims;
 221
 222       if (statement->domain->nb_local_dims > *nb_localdims)
 223         *nb_localdims = statement->domain->nb_local_dims;
 224     }
 225
 226     // * The number of scattdims are defined by scattering,
 227     //   it corresponds to the #output_dims.
 228     if (statement->scattering != NULL) {
 229       if (statement->scattering->nb_output_dims > *nb_scattdims)
 230         *nb_scattdims = statement->scattering->nb_output_dims;
 231
 232       if (statement->scattering->nb_local_dims > *nb_localdims)
 233         *nb_localdims = statement->scattering->nb_local_dims;
 234     }
 235
 236     // * The number of arrays are defined by accesses,
 237     list = statement->access;
 238     while (list != NULL) {
 239       array_id = osl_relation_get_array_id(list->elt);
 240       if (array_id > *nb_arrays)
 241         *nb_arrays = array_id;
 242
 243       list = list->next;
 244     }
 245
 246     statement = statement->next;
 247   }
 248 }
 249
 250
 251 /**
 252  * osl_scop_full_names function:
 253  * this function generates an osl_names_p structure which contains
 254  * enough names for the scop provided as parameter, for each kind of names.
 255  * If the names contained in the input scop are not sufficient, this function
 256  * generated the missing names.
 257  * \param scop The scop we need a name for each element.
 258  * \return A set of names for the scop.
 259  */
 260 static
 261 osl_names_p osl_scop_full_names(osl_scop_p scop) {
 262   int nb_parameters;
 263   int nb_iterators;
 264   int nb_scattdims;
 265   int nb_localdims;
 266   int nb_arrays;
 267   osl_arrays_p arrays;
 268   osl_names_p names;
 269
 270   names = osl_names_clone(scop->names);
 271
 272   // Extract array names information from extensions.
 273   osl_strings_free(names->arrays, names->nb_arrays);
 274   arrays = (osl_arrays_p)osl_extension_lookup(scop->extension,
 275                                   OSL_EXTENSION_ARRAYS);
 276   names->arrays = osl_arrays_generate_names(arrays,
 277                                   &(names->nb_arrays));
 278
 279   // Complete names if necessary.
 280   osl_scop_name_limits(scop, &nb_parameters,
 281                                   &nb_iterators,
 282                                   &nb_scattdims,
 283                                   &nb_localdims,
 284                                   &nb_arrays);
 285
 286   osl_strings_complete(&names->parameters, &names->nb_parameters,
 287                                  "P_", nb_parameters);
 288
 289   osl_strings_complete(&names->iterators,  &names->nb_iterators,
 290                                  "i_", nb_iterators);
 291
 292   osl_strings_complete(&names->scattdims,  &names->nb_scattdims,
 293                                  "s_", nb_scattdims);
 294
 295   osl_strings_complete(&names->localdims,  &names->nb_localdims,
 296                                  "l_", nb_localdims);
 297
 298   osl_strings_complete(&names->arrays,     &names->nb_arrays,
 299                                  "A_", nb_arrays);
 300
 301   return names;
 302 }
 303 #endif
 304
 305
 306 /**
 307  * osl_scop_print function:
 308  * this function prints the content of an osl_scop_t structure (*scop)
 309  * into a file (file, possibly stdout) in the OpenScop textual format.
 310  * \param file The file where the information has to be printed.
 311  * \param scop The scop structure whose information has to be printed.
 312  */
 313 void osl_scop_print(FILE * file, osl_scop_p scop) {
 314
 315   if (scop == NULL) {
 316     fprintf(file, "# NULL scop\n");
 317     return;
 318   }
 319   else {
 320     fprintf(file, "# [File generated by the OpenScop Library %s %s bits]\n",
 321             OSL_RELEASE,OSL_VERSION);
 322   }
 323
 324   if (osl_scop_integrity_check(scop) == 0)
 325     OSL_warning("OpenScop integrity check failed. "
 326                      "Something may go wrong.");
 327
 328   while (scop != NULL) {
 329     fprintf(file, "\n"OSL_TAG_START_SCOP"\n\n");
 330     fprintf(file, "# =============================================== "
 331                   "Global\n");
 332     fprintf(file, "# Language\n");
 333     fprintf(file, "%s\n\n", scop->language);
 334
 335     fprintf(file, "# Context\n");
 336     osl_relation_print(file, scop->context);
 337     fprintf(file, "\n");
 338
 339     osl_util_print_provided(file,
 340         osl_generic_hasURI(scop->parameters, OSL_URI_STRINGS),
 341         "Parameters are");
 342     osl_generic_print(file, scop->parameters);
 343
 344     fprintf(file, "\n# Number of statements\n");
 345     fprintf(file, "%d\n\n",osl_statement_number(scop->statement));
 346
 347     osl_statement_print(file, scop->statement);
 348
 349     if (scop->extension) {
 350       fprintf(file, "# =============================================== "
 351                     "Extensions\n");
 352       osl_generic_print(file, scop->extension);
 353     }
 354     fprintf(file, "\n"OSL_TAG_END_SCOP"\n\n");
 355
 356     scop = scop->next;
 357   }
 358 }
 359
 360
 361 /*****************************************************************************
 362  *                               Reading function                            *
 363  *****************************************************************************/
 364
 365
 366 /**
 367  * osl_scop_pread function ("precision read"):
 368  * this function reads a list of scop structures from a file (possibly stdin)
 369  * complying to the OpenScop textual format and returns a pointer to this
 370  * scop list. If some relation properties (number of input/output/local
 371  * dimensions and number of parameters) are undefined, it will define them
 372  * according to the available information.
 373  * \param[in] file      The file where the scop has to be read.
 374  * \param[in] precision The precision of the relation elements.
 375  * \return A pointer to the scop structure that has been read.
 376  */
 377 osl_scop_p osl_scop_pread(FILE * file, int precision) {
 378   osl_scop_p list = NULL, current = NULL, scop;
 379   osl_statement_p stmt = NULL;
 380   osl_statement_p prev = NULL;
 381   osl_interface_p interface;
 382   osl_strings_p language;
 383   int nb_statements;
 384   char buffer[OSL_MAX_STRING];
 385   char * tmp, * start;
 386   int first = 1;
 387   int i;
 388
 389   if (file == NULL)
 390     return NULL;
 391
 392   while(1) {
 393     //
 394     // I. START TAG
 395     //
 396     tmp = osl_util_read_uptotag(file, OSL_TAG_START_SCOP);
 397     free(tmp);
 398     if (feof(file)) {
 399       OSL_info("no more scop in the file");
 400       break;
 401     }
 402
 403     scop = osl_scop_malloc();
 404     osl_scop_register_default_extensions(scop);
 405
 406     //
 407     // II. CONTEXT PART
 408     //
 409
 410     // Read the language.
 411     language = osl_strings_read(file);
 412     if (osl_strings_size(language) == 0)
 413       OSL_error("no language (backend) specified");
 414
 415     if (osl_strings_size(language) > 1)
 416       OSL_warning("uninterpreted information (after language)");
 417
 418     if (language != NULL) {
 419       scop->language = strdup(language->string[0]);
 420       osl_strings_free(language);
 421     }
 422
 423     // Read the context domain.
 424     scop->context = osl_relation_pread(file, precision);
 425
 426     // Read the parameters.
 427     scop->parameter_type = OSL_TYPE_STRING;
 428     if (osl_util_read_int(file, NULL) > 0) {
 429       interface = osl_strings_interface();
 430       start = osl_util_skip_blank_and_comments(file, buffer);
 431       scop->parameters = osl_generic_sread(start, interface);
 432       osl_interface_free(interface);
 433     }
 434
 435     //
 436     // III. STATEMENT PART
 437     //
 438
 439     // Read the number of statements.
 440     nb_statements = osl_util_read_int(file, NULL);
 441
 442     for (i = 0; i < nb_statements; i++) {
 443       // Read each statement.
 444       stmt = osl_statement_pread(file, precision);
 445       if (scop->statement == NULL)
 446         scop->statement = stmt;
 447       else
 448         prev->next = stmt;
 449       prev = stmt;
 450     }
 451
 452     //
 453     // IV. EXTENSION PART (TO THE END TAG)
 454     //
 455
 456     // Read up the end tag (if any), and store extensions.
 457     scop->extension = osl_generic_read(file, scop->registry);
 458
 459     // Add the new scop to the list.
 460     if (first) {
 461       list = scop;
 462       first = 0;
 463     }
 464     else {
 465       current->next = scop;
 466     }
 467     current = scop;
 468   }
 469
 470   if (!osl_scop_integrity_check(list))
 471     OSL_warning("scop integrity check failed");
 472
 473   return list;
 474 }
 475
 476
 477 /**
 478  * osl_scop_read function:
 479  * this function is equivalent to osl_scop_pread() except that
 480  * the precision corresponds to the precision environment variable or
 481  * to the highest available precision if it is not defined.
 482  * \see{osl_scop_pread}
 483  */
 484 osl_scop_p osl_scop_read(FILE * foo) {
 485   int precision = osl_util_get_precision();
 486   return osl_scop_pread(foo, precision);
 487 }
 488
 489
 490 /*+***************************************************************************
 491  *                   Memory allocation/deallocation functions                *
 492  *****************************************************************************/
 493
 494
 495 /**
 496  * osl_scop_malloc function:
 497  * this function allocates the memory space for a osl_scop_t structure and
 498  * sets its fields with default values. Then it returns a pointer to the
 499  * allocated space.
 500  * \return A pointer to an empty scop with fields set to default values.
 501  */
 502 osl_scop_p osl_scop_malloc() {
 503   osl_scop_p scop;
 504
 505   OSL_malloc(scop, osl_scop_p, sizeof(osl_scop_t));
 506   scop->version        = 1;
 507   scop->language       = NULL;
 508   scop->context        = NULL;
 509   scop->parameter_type = OSL_UNDEFINED;
 510   scop->parameters     = NULL;
 511   scop->statement      = NULL;
 512   scop->registry       = NULL;
 513   scop->extension      = NULL;
 514   scop->usr            = NULL;
 515   scop->next           = NULL;
 516
 517   return scop;
 518 }
 519
 520
 521 /**
 522  * osl_scop_free function:
 523  * This function frees the allocated memory for a osl_scop_t structure.
 524  * \param scop The pointer to the scop we want to free.
 525  */
 526 void osl_scop_free(osl_scop_p scop) {
 527   osl_scop_p tmp;
 528
 529   while (scop != NULL) {
 530     if (scop->language != NULL)
 531       free(scop->language);
 532     osl_generic_free(scop->parameters);
 533     osl_relation_free(scop->context);
 534     osl_statement_free(scop->statement);
 535     osl_interface_free(scop->registry);
 536     osl_generic_free(scop->extension);
 537
 538     tmp = scop->next;
 539     free(scop);
 540     scop = tmp;
 541   }
 542 }
 543
 544
 545 /*+***************************************************************************
 546  *                            Processing functions                           *
 547  *****************************************************************************/
 548
 549
 550 /**
 551  * osl_scop_register_default_extensions function:
 552  * this function registers the default OpenScop Library extensions to an
 553  * existing scop.
 554  * \param scop The scop for which default options have to be registered.
 555  */
 556 void osl_scop_register_default_extensions(osl_scop_p scop) {
 557
 558   osl_interface_add(&(scop->registry), osl_textual_interface());
 559   osl_interface_add(&(scop->registry), osl_comment_interface());
 560   osl_interface_add(&(scop->registry), osl_arrays_interface());
 561   osl_interface_add(&(scop->registry), osl_lines_interface());
 562   osl_interface_add(&(scop->registry), osl_irregular_interface());
 563 }
 564
 565
 566 /**
 567  * osl_scop_clone function:
 568  * This functions builds and returns a "hard copy" (not a pointer copy)
 569  * of a osl_statement_t data structure provided as parameter.
 570  * Note that the usr field is not touched by this function.
 571  * \param statement The pointer to the scop we want to clone.
 572  * \return A pointer to the full clone of the scop provided as parameter.
 573  */
 574 osl_scop_p osl_scop_clone(osl_scop_p scop) {
 575   osl_scop_p clone = NULL, node, previous = NULL;
 576   int first = 1;
 577
 578   while (scop != NULL) {
 579     node                 = osl_scop_malloc();
 580     node->version        = scop->version;
 581     if (scop->language != NULL)
 582       node->language     = strdup(scop->language);
 583     node->context        = osl_relation_clone(scop->context);
 584     node->parameter_type = scop->parameter_type;
 585     node->parameters     = osl_generic_clone(scop->parameters);
 586     node->statement      = osl_statement_clone(scop->statement);
 587     node->registry       = osl_interface_clone(scop->registry);
 588     node->extension      = osl_generic_clone(scop->extension);
 589
 590     if (first) {
 591       first = 0;
 592       clone = node;
 593       previous = node;
 594     }
 595     else {
 596       previous->next = node;
 597       previous = previous->next;
 598     }
 599
 600     scop = scop->next;
 601   }
 602
 603   return clone;
 604 }
 605
 606
 607 /**
 608  * osl_scop_equal function:
 609  * this function returns true if the two scops are the same, false
 610  * otherwise (the usr field is not tested).
 611  * \param s1 The first scop.
 612  * \param s2 The second scop.
 613  * \return 1 if s1 and s2 are the same (content-wise), 0 otherwise.
 614  */
 615 int osl_scop_equal(osl_scop_p s1, osl_scop_p s2) {
 616
 617   while ((s1 != NULL) && (s2 != NULL)) {
 618     if (s1 == s2)
 619       return 1;
 620
 621     if (s1->version != s2->version) {
 622       OSL_info("versions are not the same");
 623       return 0;
 624     }
 625
 626     if (strcmp(s1->language, s2->language) != 0) {
 627       OSL_info("languages are not the same");
 628       return 0;
 629     }
 630
 631     if (!osl_relation_equal(s1->context, s2->context)) {
 632       OSL_info("contexts are not the same");
 633       return 0;
 634     }
 635
 636     if (s1->parameter_type != s2->parameter_type) {
 637       OSL_info("parameter types are not the same");
 638       return 0;
 639     }
 640
 641     if (!osl_generic_equal(s1->parameters, s2->parameters)) {
 642       OSL_info("parameters are not the same");
 643       return 0;
 644     }
 645
 646     if (!osl_statement_equal(s1->statement, s2->statement)) {
 647       OSL_info("statements are not the same");
 648       return 0;
 649     }
 650
 651     if (!osl_interface_equal(s1->registry, s2->registry)) {
 652       OSL_info("registries are not the same");
 653       return 0;
 654     }
 655
 656     if (!osl_generic_equal(s1->extension, s2->extension)) {
 657       OSL_info("extensions are not the same");
 658       return 0;
 659     }
 660
 661     s1 = s1->next;
 662     s2 = s2->next;
 663   }
 664
 665   if (((s1 == NULL) && (s2 != NULL)) || ((s1 != NULL) && (s2 == NULL)))
 666     return 0;
 667
 668   return 1;
 669 }
 670
 671
 672 /**
 673  * osl_scop_integrity_check function:
 674  * This function checks that a scop is "well formed". It returns 0 if the
 675  * check failed or 1 if no problem has been detected.
 676  * \param scop  The scop we want to check.
 677  * \return 0 if the integrity check fails, 1 otherwise.
 678  */
 679 int osl_scop_integrity_check(osl_scop_p scop) {
 680   int expected_nb_parameters;
 681
 682
 683   while (scop != NULL) {
 684     // Check the language.
 685     if ((scop->language != NULL) &&
 686         (!strcmp(scop->language, "caml")  || !strcmp(scop->language, "Caml") ||
 687          !strcmp(scop->language, "ocaml") || !strcmp(scop->language, "OCaml")))
 688       fprintf(stderr, "[OpenScop] Alert: What ?! Caml ?! Are you sure ?!?!\n");
 689
 690     // Check the context.
 691     if (!osl_relation_integrity_check(scop->context,
 692                                       OSL_TYPE_CONTEXT,
 693                                       OSL_UNDEFINED,
 694                                       OSL_UNDEFINED,
 695                                       OSL_UNDEFINED))
 696       return 0;
 697
 698     // Get the number of parameters.
 699     if (scop->context != NULL)
 700       expected_nb_parameters = scop->context->nb_parameters;
 701     else
 702       expected_nb_parameters = OSL_UNDEFINED;
 703
 704     // TODO : check the number of parameter strings.
 705
 706     if (!osl_statement_integrity_check(scop->statement,
 707                                        expected_nb_parameters))
 708       return 0;
 709
 710     scop = scop->next;
 711   }
 712
 713   return 1;
 714 }
 715
 716
 717 /**
 718  * osl_scop_get_nb_parameters function:
 719  * this function returns the number of global parameters of a given SCoP.
 720  * \param scop The scop we want to know the number of global parameters.
 721  * \return The number of global parameters in the scop.
 722  */
 723 int osl_scop_get_nb_parameters(osl_scop_p scop) {
 724
 725   if (scop->context == NULL) {
 726     OSL_warning("no context domain, assuming 0 parameters");
 727     return 0;
 728   }
 729   else {
 730     return scop->context->nb_parameters;
 731   }
 732 }
 733
 734
 735 /**
 736  * osl_scop_register_extension function:
 737  * this function registers a list of extension interfaces to a scop, i.e., it
 738  * adds them to the scop registry. In addition, it will extract extensions
 739  * corresponding to those interfaces from the textual form of the extensions
 740  * (if any) and add them to the scop extension list.
 741  * \param scop      The scop for which an extension has to be registered.
 742  * \param interface The extension interface to register within the scop.
 743  */
 744 void osl_scop_register_extension(osl_scop_p scop, osl_interface_p interface) {
 745   osl_generic_p textual, new;
 746   char * extension_string;
 747
 748   if ((interface != NULL) && (scop != NULL)) {
 749     osl_interface_add(&scop->registry, interface);
 750
 751     textual = osl_generic_lookup(scop->extension, interface->URI);
 752     if (textual != NULL) {
 753       extension_string = ((osl_textual_p)textual->data)->textual;
 754       new = osl_generic_sread(extension_string, interface);
 755       osl_generic_add(&scop->extension, new);
 756     }
 757   }
 758 }
 759
 760