libpcp/pcp_c.h

   1 /* Copyright (C) 2009 Free Software Foundation, Inc.
   2    Contributed by Jan Sjodin <jan.sjodin@amd.com>.
   3
   4    This file is part of the Polyhedral Compilation Package Library (libpcp).
   5
   6    Libpcp is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU Lesser General Public License as published by
   8    the Free Software Foundation; either version 2.1 of the License, or
   9    (at your option) any later version.
  10
  11    Libpcp is distributed in the hope that it will be useful, but WITHOUT ANY
  12    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13    FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
  14    more details.
  15
  16    You should have received a copy of the GNU Lesser General Public License
  17    along with libpcp; see the file COPYING.LIB.  If not, write to the
  18    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 /* As a special exception, if you link this library with other files, some
  22    of which are compiled with GCC, to produce an executable, this library
  23    does not by itself cause the resulting executable to be covered by the
  24    GNU General Public License.  This exception does not however invalidate
  25    any other reasons why the executable file might be covered by the GNU
  26    General Public License.  */
  27
  28 #ifndef _PCP_C_INTERFACE_H_
  29 #define _PCP_C_INTERFACE_H_
  30
  31 #ifdef __cplusplus
  32 extern "C" {
  33 #endif
  34
  35 /* PCP Object */
  36 #ifdef __cplusplus
  37   typedef PcpObject pcp_object;
  38   typedef PcpAnnot pcp_annot;
  39   typedef PcpAnnotTerm pcp_annot_term;
  40   typedef PcpAnnotInt pcp_annot_int;
  41   typedef PcpAnnotString pcp_annot_string;
  42   typedef PcpAnnotObject pcp_annot_object;
  43   typedef PcpAnnotTermBuilder pcp_annot_term_builder;
  44   typedef PcpArrayType pcp_array_type;
  45   typedef PcpArrayTypeBuilder pcp_array_type_builder;
  46   typedef PcpExpr pcp_expr;
  47   typedef PcpArith pcp_arith;
  48   typedef PcpArithBuilder pcp_arith_builder;
  49   typedef PcpConstant pcp_constant;
  50   typedef PcpIv pcp_iv;
  51   typedef PcpParameter pcp_parameter;
  52   typedef PcpBoolArith pcp_bool_arith;
  53   typedef PcpBoolArithBuilder pcp_bool_arith_builder;
  54   typedef PcpVariable pcp_variable;
  55   typedef PcpArrayAccess pcp_array_access;
  56   typedef PcpArrayAccessBuilder pcp_array_access_builder;
  57   typedef PcpStmt pcp_stmt;
  58   typedef PcpCopy pcp_copy;
  59   typedef PcpUserStmt pcp_user_stmt;
  60   typedef PcpUserStmtBuilder pcp_user_stmt_builder;
  61   typedef PcpSequence pcp_sequence;
  62   typedef PcpSequenceBuilder pcp_sequence_builder;
  63   typedef PcpGuard pcp_guard;
  64   typedef PcpLoop pcp_loop;
  65   typedef PcpScop pcp_scop;
  66   typedef PcpScopBuilder pcp_scop_builder;
  67   typedef PcpCompare pcp_compare;
  68   typedef PcpBoolExpr pcp_bool_expr;
  69   typedef PcpAnnotSet pcp_annot_set;
  70 #else
  71   typedef int bool;
  72   typedef struct pcp_object pcp_object;
  73   typedef struct pcp_annot pcp_annot;
  74   typedef struct pcp_annot_term pcp_annot_term;
  75   typedef struct pcp_annot_int pcp_annot_int;
  76   typedef struct pcp_annot_string pcp_annot_string;
  77   typedef struct pcp_annot_object pcp_annot_object;
  78   typedef struct pcp_annot_term_builder pcp_annot_term_builder;
  79   typedef struct pcp_array_type pcp_array_type;
  80   typedef struct pcp_array_type_builder pcp_array_type_builder;
  81   typedef struct pcp_expr pcp_expr;
  82   typedef struct pcp_arith pcp_arith;
  83   typedef struct pcp_arith_builder pcp_arith_builder;
  84   typedef struct pcp_constant pcp_constant;
  85   typedef struct pcp_iv pcp_iv;
  86   typedef struct pcp_parameter pcp_parameter;
  87   typedef struct pcp_bool_arith pcp_bool_arith;
  88   typedef struct pcp_bool_arith_builder pcp_bool_arith_builder;
  89   typedef struct pcp_variable pcp_variable;
  90   typedef struct pcp_array_access pcp_array_access;
  91   typedef struct pcp_array_access_builder pcp_array_access_builder;
  92   typedef struct pcp_stmt pcp_stmt;
  93   typedef struct pcp_copy pcp_copy;
  94   typedef struct pcp_user_stmt pcp_user_stmt;
  95   typedef struct pcp_user_stmt_builder pcp_user_stmt_builder;
  96   typedef struct pcp_sequence pcp_sequence;
  97   typedef struct pcp_sequence_builder pcp_sequence_builder;
  98   typedef struct pcp_guard pcp_guard;
  99   typedef struct pcp_loop pcp_loop;
 100   typedef struct pcp_scop pcp_scop;
 101   typedef struct pcp_scop_builder pcp_scop_builder;
 102   typedef struct pcp_compare pcp_compare;
 103   typedef struct pcp_bool_expr pcp_bool_expr;
 104   typedef struct pcp_annot_set pcp_annot_set;
 105 #endif
 106
 107 typedef enum pcp_object_kind
 108 {
 109   pcp_object_kind_array_type,
 110   pcp_object_kind_expr,
 111   pcp_object_kind_bool_expr,
 112   pcp_object_kind_variable,
 113   pcp_object_kind_array_access,
 114   pcp_object_kind_stmt,
 115   pcp_object_kind_scop
 116 } pcp_object_kind;
 117
 118 typedef enum pcp_annot_kind
 119 {
 120   pcp_annot_kind_int,
 121   pcp_annot_kind_string,
 122   pcp_annot_kind_object,
 123   pcp_annot_kind_term
 124 } pcp_annot_kind;
 125
 126 typedef enum pcp_expr_kind
 127 {
 128   pcp_expr_kind_parameter,
 129   pcp_expr_kind_constant,
 130   pcp_expr_kind_iv,
 131   pcp_expr_kind_arith
 132 } pcp_expr_kind;
 133
 134 typedef enum pcp_arith_operator
 135 {
 136   pcp_arith_operator_unknown,
 137   pcp_arith_operator_add,
 138   pcp_arith_operator_multiply,
 139   pcp_arith_operator_min,
 140   pcp_arith_operator_max,
 141   pcp_arith_operator_subtract,
 142   pcp_arith_operator_floor,
 143   pcp_arith_operator_ceiling
 144 } pcp_arith_operator;
 145
 146 typedef enum pcp_bool_expr_kind
 147 {
 148   pcp_bool_expr_compare,
 149   pcp_bool_expr_arith
 150 } pcp_bool_expr_kind;
 151
 152 typedef enum pcp_compare_operator
 153 {
 154   pcp_compare_operator_unknown,
 155   pcp_compare_operator_equal,
 156   pcp_compare_operator_greater_equal
 157 } pcp_compare_operator;
 158
 159 typedef enum pcp_bool_arith_operator
 160 {
 161   pcp_bool_arith_operator_unknown,
 162   pcp_bool_arith_operator_and,
 163   pcp_bool_arith_operator_or
 164 } pcp_bool_arith_operator;
 165
 166 typedef enum pcp_array_operator
 167 {
 168   pcp_array_operator_unknown,
 169   pcp_array_operator_use,
 170   pcp_array_operator_def,
 171   pcp_array_operator_maydef
 172 } pcp_array_operator;
 173
 174 typedef enum pcp_stmt_kind
 175 {
 176   pcp_stmt_kind_unknown,
 177   pcp_stmt_kind_copy,
 178   pcp_stmt_kind_user,
 179   pcp_stmt_kind_loop,
 180   pcp_stmt_kind_guard,
 181   pcp_stmt_kind_sequence
 182 } pcp_stmt_kind;
 183
 184 void pcp_object_set_name(pcp_object* object, const char* name);
 185 const char* pcp_object_get_name(pcp_object* object);
 186 pcp_annot_set* pcp_object_get_annots(pcp_object* object);
 187 bool pcp_object_contains_annot_with_tag(pcp_object* object, const char* tag);
 188 void pcp_object_add_annot(pcp_object* object, pcp_annot_term* annot);
 189
 190 bool pcp_object_is_array_type(pcp_object* object);
 191 bool pcp_object_is_expr(pcp_object* object);
 192 bool pcp_object_is_bool_expr(pcp_object* object);
 193 bool pcp_object_is_variable(pcp_object* object);
 194 bool pcp_object_is_array_access(pcp_object* object);
 195 bool pcp_object_is_stmt(pcp_object* object);
 196 bool pcp_object_is_scop(pcp_object* object);
 197
 198 bool pcp_object_is_iv(pcp_object* object);
 199 bool pcp_object_is_parameter(pcp_object* object);
 200
 201 /* PCP Annot Set*/
 202
 203 int pcp_annot_set_get_num_annots(pcp_annot_set* annot_set);
 204 pcp_annot_term* pcp_annot_set_get_annot(pcp_annot_set* annot_set, int index);
 205
 206 /* PCP Annot */
 207
 208 pcp_annot_kind pcp_annot_get_kind(pcp_annot* annot);
 209
 210 bool pcp_annot_is_annot_int(pcp_annot* annot);
 211 bool pcp_annot_is_annot_string(pcp_annot* annot);
 212 bool pcp_annot_is_annot_object(pcp_annot* annot);
 213 bool pcp_annot_is_annot_term(pcp_annot* annot);
 214
 215 /* PCP Annot Int */
 216
 217 pcp_annot* pcp_annot_int_to_annot(pcp_annot_int* annot_int);
 218 int pcp_annot_int_get_value(pcp_annot_int* annot_int);
 219 pcp_annot_int* pcp_annot_int_create(int value);
 220
 221 /* PCP Annot String */
 222
 223 pcp_annot* pcp_annot_string_to_annot(pcp_annot_string* annot_string);
 224 const char* pcp_annot_string_get_string(pcp_annot_string* annot_string);
 225 pcp_annot_string* pcp_annot_string_create(const char* string);
 226
 227 /* PCP Annot Object */
 228
 229 pcp_annot* pcp_annot_object_to_annot(pcp_annot_object* annot_object);
 230 pcp_object* pcp_annot_object_get_object(pcp_annot_object* annot_object);
 231 pcp_annot_object* pcp_annot_object_create(pcp_object* object);
 232
 233 /* PCP Annot Term */
 234
 235 pcp_annot* pcp_annot_term_to_annot(pcp_annot_term* annot_term);
 236 const char* pcp_annot_term_get_tag(pcp_annot_term* annot_term);
 237 int pcp_annot_term_get_num_arguments(pcp_annot_term* annot_term);
 238 pcp_annot* pcp_annot_term_get_argument(pcp_annot_term* annot_term,
 239                                         int index);
 240
 241 /* PCP Annot Term Builder */
 242
 243 void pcp_annot_term_builder_set_tag(pcp_annot_term_builder* builder,
 244                                      const char* tag);
 245 void pcp_annot_term_builder_add_argument(pcp_annot_term_builder* builder,
 246                                           pcp_annot* argument);
 247 pcp_annot_term_builder* pcp_annot_term_builder_create(void);
 248 pcp_annot_term* pcp_annot_term_builder_create_annot(pcp_annot_term_builder*
 249                                                      builder);
 250
 251 pcp_annot_int* pcp_annot_to_annot_int(pcp_annot* annot);
 252 pcp_annot_string* pcp_annot_to_annot_string(pcp_annot* annot);
 253 pcp_annot_object* pcp_annot_to_annot_object(pcp_annot* annot);
 254 pcp_annot_term* pcp_annot_to_annot_term(pcp_annot* annot);
 255
 256 /* Array Type */
 257
 258 pcp_object* pcp_array_type_to_object(pcp_array_type* );
 259 int pcp_array_type_get_num_dimensions(pcp_array_type* );
 260 pcp_expr* pcp_array_type_get_dimension(pcp_array_type* , int);
 261
 262 /* Array Type Builder */
 263
 264 pcp_array_type_builder* pcp_array_type_builder_create(void);
 265 void pcp_array_type_builder_add_dimension(pcp_array_type_builder* ,
 266                                            pcp_expr* );
 267 void pcp_array_type_builder_add_int_dimension(pcp_array_type_builder*,
 268                                                int);
 269 pcp_array_type* pcp_array_type_builder_create_type(pcp_array_type_builder* );
 270
 271 /* PCP Linear Expr */
 272
 273 pcp_object* pcp_expr_to_object(pcp_expr* expr);
 274 pcp_expr_kind pcp_expr_get_kind(pcp_expr* expr);
 275
 276 bool pcp_expr_is_parameter(pcp_expr* );
 277 bool pcp_expr_is_constant(pcp_expr* );
 278 bool pcp_expr_is_iv(pcp_expr* );
 279 bool pcp_expr_is_subtract(pcp_expr* );
 280 bool pcp_expr_is_arith(pcp_expr* );
 281
 282
 283 /* PCP Arith */
 284
 285 pcp_object* pcp_arith_to_object(pcp_arith* arith);
 286 pcp_expr* pcp_arith_to_expr(pcp_arith* arith);
 287 pcp_arith_operator pcp_arith_get_operator(pcp_arith* arith);
 288 int pcp_arith_get_num_operands(pcp_arith* arith);
 289 pcp_expr* pcp_arith_get_operand(pcp_arith* arith, int index);
 290
 291 pcp_arith* pcp_arith_binary_create(pcp_arith_operator oper,
 292                                             pcp_expr* lhs,
 293                                             pcp_expr* rhs);
 294 /* PCP Arith builder.  */
 295
 296 void pcp_arith_builder_set_operator(pcp_arith_builder* builder,
 297                                          pcp_arith_operator oper);
 298 void pcp_arith_builder_add_operand(pcp_arith_builder* builder,
 299                                         pcp_expr* operand);
 300 pcp_arith*
 301 pcp_arith_builder_create_arith(pcp_arith_builder* builder);
 302 pcp_arith_builder* pcp_arith_builder_create(void);
 303
 304 /* PCP Constant */
 305
 306 pcp_object* pcp_constant_to_object(pcp_constant* constant);
 307 pcp_expr* pcp_constant_to_expr(pcp_constant* constant);
 308 int pcp_constant_get_value(pcp_constant* );
 309 pcp_constant* pcp_constant_create(int);
 310
 311 /* PCP Induction Variable */
 312
 313 pcp_object* pcp_iv_to_object(pcp_iv* iv);
 314 pcp_expr* pcp_iv_to_expr(pcp_iv* iv);
 315 const char* pcp_iv_get_name(pcp_iv* iv);
 316 pcp_iv* pcp_iv_create(const char* name);
 317
 318 /* PCP Parameter */
 319
 320 pcp_object* pcp_parameter_to_object(pcp_parameter* parameter);
 321 pcp_expr* pcp_parameter_to_expr(pcp_parameter* parameter);
 322 const char* pcp_parameter_get_name(pcp_parameter* );
 323 pcp_parameter* pcp_parameter_create(const char* );
 324
 325 pcp_parameter* pcp_expr_to_parameter(pcp_expr* );
 326 pcp_arith* pcp_expr_to_arith(pcp_expr* );
 327 pcp_constant* pcp_expr_to_constant(pcp_expr* );
 328 pcp_iv* pcp_expr_to_iv(pcp_expr* );
 329
 330 /* PCP Bool Expr */
 331
 332
 333 pcp_object* pcp_bool_expr_to_object(pcp_bool_expr* bool_expr);
 334 pcp_bool_expr_kind pcp_bool_expr_get_kind(pcp_bool_expr* bool_expr);
 335 bool pcp_bool_expr_is_compare(pcp_bool_expr* bool_expr);
 336 bool pcp_bool_expr_is_bool_arith(pcp_bool_expr* bool_expr);
 337
 338 /* PCP Compare */
 339
 340 pcp_bool_expr* pcp_compare_to_bool_expr(pcp_compare* compare);
 341 pcp_compare_operator pcp_compare_get_operator(pcp_compare* compare);
 342 pcp_expr* pcp_compare_get_lhs(pcp_compare* compare);
 343 pcp_expr* pcp_compare_get_rhs(pcp_compare* compare);
 344 pcp_compare* pcp_compare_create(pcp_compare_operator oper,
 345                                  pcp_expr* lhs,
 346                                  pcp_expr* rhs);
 347
 348
 349 /* PCP Bool Arith */
 350
 351 pcp_object* pcp_bool_arith_to_object(pcp_bool_arith* bool_arith);
 352 pcp_bool_expr* pcp_bool_arith_to_bool_expr(pcp_bool_arith* bool_arith);
 353 pcp_bool_arith_operator
 354 pcp_bool_arith_get_operator(pcp_bool_arith* bool_arith);
 355 int pcp_bool_arith_get_num_operands(pcp_bool_arith* bool_arith);
 356 pcp_bool_expr* pcp_bool_arith_get_operand(pcp_bool_arith* bool_arith,
 357                                            int index);
 358 pcp_bool_arith* pcp_bool_arith_binary_create(pcp_bool_arith_operator oper,
 359                                               pcp_bool_expr* lhs,
 360                                               pcp_bool_expr* rhs);
 361
 362
 363 void pcp_bool_arith_builder_set_operator(pcp_bool_arith_builder* builder,
 364                                           pcp_bool_arith_operator oper);
 365 pcp_bool_arith_builder* pcp_bool_arith_builder_create(void);
 366 pcp_bool_arith* pcp_bool_arith_builder_create_bool_arith(pcp_bool_arith_builder* builder);
 367 void pcp_bool_arith_builder_add_operand(pcp_bool_arith_builder* builder,
 368                                          pcp_bool_expr* operand);
 369
 370 pcp_compare* pcp_bool_expr_to_compare(pcp_bool_expr* bool_expr);
 371 pcp_bool_arith* pcp_bool_expr_to_bool_arith(pcp_bool_expr* bool_expr);
 372
 373 /* PCP Variable */
 374
 375 pcp_object* pcp_variable_to_object(pcp_variable* var);
 376 void pcp_variable_set_is_input(pcp_variable* var, bool is_input);
 377 bool pcp_variable_get_is_input(pcp_variable* var);
 378 void pcp_variable_set_is_output(pcp_variable* var, bool is_output);
 379 bool pcp_variable_get_is_output(pcp_variable* var);
 380 pcp_array_type* pcp_variable_get_type(pcp_variable* );
 381 const char* pcp_variable_get_name(pcp_variable* );
 382 pcp_variable* pcp_variable_create(pcp_array_type* type, const char* name);
 383
 384 /* PCP Array Access */
 385
 386 pcp_object* pcp_array_access_to_object(pcp_array_access* access);
 387 pcp_array_operator pcp_array_access_get_operator(pcp_array_access* access);
 388 pcp_variable* pcp_array_access_get_base(pcp_array_access* access);
 389 int pcp_array_access_get_num_subscripts(pcp_array_access* access);
 390 pcp_expr* pcp_array_access_get_subscript(pcp_array_access* access,
 391                                           int index);
 392
 393 bool pcp_array_access_is_use(pcp_array_access* );
 394 bool pcp_array_access_is_def(pcp_array_access* );
 395 bool pcp_array_access_is_maydef(pcp_array_access* );
 396
 397 /* PCP Array Access Builder */
 398
 399 void pcp_array_access_builder_set_operator(pcp_array_access_builder*
 400                                             builder,
 401                                             pcp_array_operator oper);
 402 pcp_array_access_builder* pcp_array_access_builder_create(pcp_variable*
 403                                                            base);
 404 pcp_array_access
 405  * pcp_array_access_builder_create_access(pcp_array_access_builder*
 406                                             builder);
 407 void pcp_array_access_builder_add_subscript(pcp_array_access_builder*
 408                                              builder, pcp_expr* subscript);
 409
 410 /* PCP Stmt */
 411
 412 pcp_object* pcp_stmt_to_object(pcp_stmt* stmt);
 413 pcp_stmt_kind pcp_stmt_get_kind(pcp_stmt* );
 414
 415 bool pcp_stmt_is_copy(pcp_stmt* );
 416 bool pcp_stmt_is_user_stmt(pcp_stmt* );
 417 bool pcp_stmt_is_guard(pcp_stmt* );
 418 bool pcp_stmt_is_loop(pcp_stmt* );
 419 bool pcp_stmt_is_sequence(pcp_stmt* );
 420
 421 /* PCP Copy Stmt */
 422
 423 pcp_object* pcp_copy_to_object(pcp_copy* copy);
 424 pcp_stmt* pcp_copy_to_stmt(pcp_copy* copy);
 425 pcp_array_access* pcp_copy_get_src(pcp_copy* copy);
 426 pcp_array_access* pcp_copy_get_dest(pcp_copy* copy);
 427 pcp_copy* pcp_copy_create(pcp_array_access* dest, pcp_array_access* src);
 428
 429 /* PCP User Stmt */
 430
 431 pcp_object* pcp_user_stmt_to_object(pcp_user_stmt* user_stmt);
 432 pcp_stmt* pcp_user_stmt_to_stmt(pcp_user_stmt* user_stmt);
 433 const char* pcp_user_stmt_get_name(pcp_user_stmt* user_stmt);
 434 int pcp_user_stmt_get_num_accesses(pcp_user_stmt* user_stmt);
 435 pcp_array_access* pcp_user_stmt_get_array_access(pcp_user_stmt* user_stmt,
 436                                                   int index);
 437
 438 /* PCP User Stmt Builder */
 439
 440 void pcp_user_stmt_builder_set_name(pcp_user_stmt_builder* builder,
 441                                      const char* name);
 442 void pcp_user_stmt_builder_add_access(pcp_user_stmt_builder* builder,
 443                                        pcp_array_access* access);
 444 pcp_user_stmt_builder* pcp_user_stmt_builder_create(void);
 445 pcp_user_stmt* pcp_user_stmt_builder_create_user_stmt(pcp_user_stmt_builder*
 446                                                        builder);
 447
 448 /* PCP Sequence */
 449
 450 pcp_stmt* pcp_sequence_to_stmt(pcp_sequence* sequence);
 451 int pcp_sequence_get_num_stmts(pcp_sequence* sequence);
 452 pcp_stmt* pcp_sequence_get_stmt(pcp_sequence* sequence, int index);
 453
 454 /* PCP Sequence Builder */
 455
 456 void pcp_sequence_builder_add(pcp_sequence_builder* builder,
 457                                pcp_stmt* stmt);
 458 pcp_sequence_builder* pcp_sequence_builder_create(void);
 459 pcp_sequence* pcp_sequence_builder_create_sequence(pcp_sequence_builder*
 460                                                     builder);
 461
 462 /* PCP Guard */
 463
 464 pcp_object* pcp_guard_to_object(pcp_guard* guard);
 465 pcp_stmt* pcp_guard_to_stmt(pcp_guard* guard);
 466 pcp_bool_expr* pcp_guard_get_condition(pcp_guard* guard);
 467 pcp_stmt* pcp_guard_get_body(pcp_guard* guard);
 468 pcp_guard* pcp_guard_create(pcp_bool_expr* condition, pcp_stmt* body);
 469
 470
 471 /* PCP Loop */
 472
 473 pcp_object* pcp_loop_to_object(pcp_loop* loop);
 474 pcp_stmt* pcp_loop_to_stmt(pcp_loop* loop);
 475 pcp_iv* pcp_loop_get_iv(pcp_loop* loop);
 476 pcp_expr* pcp_loop_get_start(pcp_loop* loop);
 477 pcp_bool_expr* pcp_loop_get_condition(pcp_loop* loop);
 478 pcp_constant* pcp_loop_get_stride(pcp_loop* loop);
 479 pcp_stmt* pcp_loop_get_body(pcp_loop* loop);
 480 pcp_loop* pcp_loop_create(pcp_iv* iv, pcp_expr* start, pcp_bool_expr* condition,
 481                            pcp_constant* stride, pcp_stmt* body);
 482
 483 pcp_copy* pcp_stmt_to_copy(pcp_stmt* stmt);
 484 pcp_user_stmt* pcp_stmt_to_user_stmt(pcp_stmt* stmt);
 485 pcp_guard* pcp_stmt_to_guard(pcp_stmt* stmt);
 486 pcp_loop* pcp_stmt_to_loop(pcp_stmt* stmt);
 487 pcp_sequence* pcp_stmt_to_sequence(pcp_stmt* stmt);
 488
 489
 490 /* PCP Scop */
 491
 492 pcp_object* pcp_scop_to_object(pcp_scop* scop);
 493 int pcp_scop_get_num_variables(pcp_scop* scop);
 494 int pcp_scop_get_num_parameters(pcp_scop* scop);
 495 pcp_variable* pcp_scop_get_variable(pcp_scop* scop, int index);
 496 pcp_parameter* pcp_scop_get_parameter(pcp_scop* scop, int index);
 497 pcp_stmt* pcp_scop_get_body(pcp_scop* scop);
 498
 499
 500 /* PCP Scop Builder */
 501
 502 void pcp_scop_builder_add_variable(pcp_scop_builder* builder,
 503                                     pcp_variable* variable);
 504 void pcp_scop_builder_add_parameter(pcp_scop_builder* builder,
 505                                      pcp_parameter* parameter);
 506 void pcp_scop_builder_set_body(pcp_scop_builder* builder, pcp_stmt* body);
 507
 508 pcp_scop_builder* pcp_scop_builder_create(void);
 509 pcp_scop* pcp_scop_builder_create_scop(pcp_scop_builder* builder);
 510
 511 /* PCP Object casts */
 512 pcp_annot* pcp_object_to_annot(pcp_object* object);
 513 pcp_array_type* pcp_object_to_array_type(pcp_object* object);
 514 pcp_expr* pcp_object_to_expr(pcp_object* object);
 515 pcp_iv* pcp_object_to_iv(pcp_object* object);
 516 pcp_bool_expr* pcp_object_to_bool_expr(pcp_object* object);
 517 pcp_variable* pcp_object_to_variable(pcp_object* object);
 518 pcp_array_access* pcp_object_to_array_access(pcp_object* object);
 519 pcp_stmt* pcp_object_to_stmt(pcp_object* object);
 520 pcp_scop* pcp_object_to_scop(pcp_object* object);
 521 pcp_parameter* pcp_object_to_parameter(pcp_object* object);
 522 #ifdef __cplusplus
 523 }
 524 #endif
 525 #endif /* __PCP_C_INTERFACE_H_ */