This file is indexed.

/usr/include/cloog/domain.h is in libcloog-isl-dev 0.18.4-2.

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
166
167
168
169
170
171
172
173
174
175
176
   /**-------------------------------------------------------------------**
    **                               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;
struct osl_relation;


/**
 * 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                            *
 ******************************************************************************/
CloogDomain *cloog_domain_from_osl_relation(CloogState *,
                                            struct osl_relation *);
CloogScattering *cloog_scattering_from_osl_relation(CloogState *,
                                                    struct osl_relation *);
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);
CloogDomain * cloog_domain_add_stride_constraint(CloogDomain *domain,
					CloogStride *stride);
int           cloog_domain_can_unroll(CloogDomain *domain, int level,
				cloog_int_t *n, CloogConstraint **lb);
CloogDomain * cloog_domain_fixed_offset(CloogDomain *domain, int level,
				CloogConstraint *lb, cloog_int_t offset);
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 */