/usr/include/cloog/domain.h is in libcloog-ppl-dev 0.16.1-6.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 | /**-------------------------------------------------------------------**
** CLooG **
**-------------------------------------------------------------------**
** domain.h **
**-------------------------------------------------------------------**
** First version: october 28th 2001 **
**-------------------------------------------------------------------**/
/******************************************************************************
* CLooG : the Chunky Loop Generator (experimental) *
******************************************************************************
* *
* Copyright (C) 2001-2005 Cedric Bastoul *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public *
* License as published by the Free Software Foundation; either *
* version 2.1 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 51 Franklin Street, Fifth Floor, *
* Boston, MA 02110-1301 USA *
* *
* CLooG, the Chunky Loop Generator *
* Written by Cedric Bastoul, Cedric.Bastoul@inria.fr *
* *
******************************************************************************/
#ifndef CLOOG_DOMAIN_H
#define CLOOG_DOMAIN_H
#if defined(__cplusplus)
extern "C"
{
#endif
struct cloogdomain;
typedef struct cloogdomain CloogDomain ;
struct cloogscattering;
typedef struct cloogscattering CloogScattering;
/**
* CloogDomainList structure:
* this structure reprensents a node of a linked list of CloogDomain structures.
*/
struct cloogdomainlist {
CloogDomain *domain; /**< An element of the list. */
struct cloogdomainlist *next;/**< Pointer to the next element of the list.*/
} ;
typedef struct cloogdomainlist CloogDomainList;
/**
* CloogScatteringList structure:
* this structure reprensents a node of a linked list of CloogScattering structures.
*/
struct cloogscatteringlist {
CloogScattering *scatt; /**< An element of the list. */
struct cloogscatteringlist *next;/**< Pointer to the next element of the list.*/
} ;
typedef struct cloogscatteringlist CloogScatteringList;
/******************************************************************************
* PolyLib interface *
******************************************************************************/
void cloog_domain_print_constraints(FILE *, CloogDomain *,
int print_number);
void cloog_scattering_print_constraints(FILE *, CloogScattering *);
void cloog_domain_free(CloogDomain *) ;
void cloog_scattering_free(CloogScattering *);
CloogDomain * cloog_domain_copy(CloogDomain *) ;
CloogDomain * cloog_domain_convex(CloogDomain * Pol) ;
CloogDomain * cloog_domain_simple_convex(CloogDomain * domain);
CloogDomain * cloog_domain_simplify(CloogDomain *, CloogDomain *) ;
CloogDomain * cloog_domain_union(CloogDomain *, CloogDomain *) ;
CloogDomain * cloog_domain_intersection(CloogDomain *, CloogDomain *) ;
CloogDomain * cloog_domain_difference(CloogDomain *, CloogDomain *) ;
void cloog_domain_sort(CloogDomain**,unsigned,unsigned,int *);
int cloog_domain_follows(CloogDomain *dom1, CloogDomain *dom2, unsigned level);
CloogDomain * cloog_domain_empty(CloogDomain *model);
int cloog_domain_is_bounded(CloogDomain *dim, unsigned level);
CloogDomain *cloog_domain_bound_splitter(CloogDomain *dom, int level);
/******************************************************************************
* Structure display function *
******************************************************************************/
void cloog_domain_print_structure(FILE *file, CloogDomain *domain, int level,
const char *name);
/******************************************************************************
* Memory deallocation function *
******************************************************************************/
void cloog_domain_list_free(CloogDomainList *);
void cloog_scattering_list_free(CloogScatteringList *);
/*+****************************************************************************
* Reading function *
******************************************************************************/
CloogDomain * cloog_domain_read_context(CloogState *state, FILE * foo);
CloogDomain * cloog_domain_union_read(CloogState *state, FILE *foo, int nb_par);
CloogScattering *cloog_domain_read_scattering(CloogDomain *domain, FILE *foo);
CloogDomain * cloog_domain_from_cloog_matrix(CloogState *state,
CloogMatrix *matrix, int nb_par);
CloogScattering * cloog_scattering_from_cloog_matrix(CloogState *state,
CloogMatrix *matrix, int nb_scat, int nb_par);
/******************************************************************************
* Processing functions *
******************************************************************************/
CloogConstraintSet *cloog_domain_constraints(CloogDomain *);
int cloog_domain_isempty(CloogDomain *) ;
CloogDomain * cloog_domain_universe(CloogState *state, unsigned dim);
CloogDomain * cloog_domain_project(CloogDomain *, int);
CloogDomain * cloog_domain_extend(CloogDomain *, int);
int cloog_domain_never_integral(CloogDomain *) ;
void cloog_domain_stride(CloogDomain *, int, cloog_int_t *, cloog_int_t *);
int cloog_domain_can_stride(CloogDomain *domain, int level);
int cloog_domain_is_otl(CloogDomain *domain, int level);
CloogDomain * cloog_domain_stride_lower_bound(CloogDomain *domain, int level,
CloogStride *stride);
int cloog_domain_lazy_disjoint(CloogDomain *, CloogDomain *) ;
int cloog_domain_lazy_equal(CloogDomain *, CloogDomain *) ;
int cloog_scattering_lazy_block(CloogScattering *, CloogScattering *,
CloogScatteringList *, int);
int cloog_scattering_lazy_isscalar(CloogScattering *, int,
cloog_int_t *);
int cloog_domain_lazy_isconstant(CloogDomain *domain, int dimension,
cloog_int_t *value);
int cloog_scattering_list_lazy_same(CloogScatteringList *);
CloogDomain * cloog_domain_cut_first(CloogDomain *domain, CloogDomain **rest);
CloogDomain * cloog_domain_simplify_union(CloogDomain *domain);
CloogScattering * cloog_scattering_erase_dimension(CloogScattering *, int);
int cloog_domain_dimension(CloogDomain *) ;
int cloog_domain_parameter_dimension(CloogDomain *domain);
int cloog_scattering_dimension(CloogScattering *, CloogDomain *);
int cloog_domain_isconvex(CloogDomain *) ;
CloogDomain * cloog_domain_cube(CloogState *state,
int dim, cloog_int_t min, cloog_int_t max);
CloogDomain * cloog_domain_from_context(CloogDomain *context);
CloogDomain * cloog_domain_scatter(CloogDomain *domain, CloogScattering *scatt);
int cloog_scattering_fully_specified(CloogScattering *scattering,
CloogDomain *domain);
CloogStride *cloog_domain_list_stride(CloogDomainList *list, int level);
#if defined(__cplusplus)
}
#endif
#endif /* define _H */
|