35 #include "pips_config.h"
62 return "undefined type";
423 list cfl1 = fl1, cfl2 = fl2;
424 for(;equal_p && !
ENDP(cfl1);
POP(cfl1),
POP(cfl2)) {
439 list cfl1 = fl1, cfl2 = fl2;
440 for(;equal_p && !
ENDP(cfl1);
POP(cfl1),
POP(cfl2)) {
446 equal_p = strcmp(n1, n2)==0;
686 bool equal_p =
false;
776 bool equal_p =
false;
808 for (; ld1;
POP(ld1),
POP(ld2))
935 bool compare_p =
false;
984 bool qualifier_p,
hash_table structural_table)
1017 bool qualifier_p,
hash_table structural_table)
1192 while (pc != NULL && --i > 0)
1211 bool finished =
false;
1234 "Check gcc warnings about typing.\n");
1491 pips_debug(1,
"function %s has no initial value.\n"
1492 " Maybe it has not been parsed yet.\n",
1532 pips_user_error(
"A subroutine or void returning function is used as an expression\n");
1673 "Please use gcc to check that your source code is legal\n");
1765 type call_type, return_type;
1767 debug(7,
"basic_of_constant",
"Constant call\n");
1851 pips_debug(7,
"Tags: tag exp1 = %d, tag exp2 = %d\n",
2144 pips_assert(
"Dereferencing of a non-pointer expression : it must be an array\n", !
ENDP(cd));
2164 pips_assert(
"Two arguments for POINT_TO or FIELD \n",
2205 bool minus_c_pointer_arithmetic =
false;
2228 pips_user_warning(
"Non matching pointed types in pointer arithmetic expressions.\n");
2240 minus_c_pointer_arithmetic =
true;
2245 if (! minus_c_pointer_arithmetic )
2283 pips_debug(9,
"different number of dimensions\n");
2284 pips_assert(
"pointer arithmetic with array name, first element must be the address expression",
2340 pips_debug(1,
"function %s has no initial value.\n"
2341 " Maybe it has not been parsed yet.\n",
2378 "we iterate over the indices if any \n");
2380 while (!
ENDP(l_inds))
2391 pips_debug(9,
"poping one type dimension and one index\n");
2397 pips_debug(9,
"going through pointer dimension. \n");
2402 " pointer or struct expected\n",
2428 pips_assert(
"The subscript expression is a reference",
2561 while (!
ENDP(l_inds))
2746 "(tag %td) isn't that simple\n",
basic_tag(b));
2748 fprintf(stderr,
"string: value tag = %d\n",
2879 bool is_char =
false;
2885 is_char = (i==1)||(i==11);
2974 bool return_val =
false;
2995 bool pointer_p =
false;
3013 bool pointer_p =
false;
3123 bool struct_p =
false;
3135 bool struct_p =
false;
3153 bool union_p =
false;
3174 bool enum_p =
false;
3210 pips_debug(8,
"Old basic size: %d, new size : %d\n",i,10*(i/10)+size);
3219 user_warning(
"Parse error",
"Standard integer types\n");
3229 bool long_p =
false;
3248 bool default_complex_p =
false;
3260 return default_complex_p;
3265 bool float_p =
false;
3278 bool long_p =
false;
3343 user_warning(
"Parse error",
"Standard long integer types\n");
3408 static size_t holder_iter = 0;
3420 static type holder[8] = {
3431 holder_iter = 7 & ( 1 + holder_iter );
3437 holder[holder_iter]=nt;
3495 #define BCTYPES_TABLE_INIT_SIZE 10
3719 while(!res && !
ENDP(l_fields))
3766 bool compatible_p =
true;
3780 compatible_p =
false;
3783 compatible_p =
false;
3785 return compatible_p;
3793 type compatible = t;
3912 for(ce = el; !
ENDP(ce);
POP(ce)) {
3952 for(ce = el; !
ENDP(ce);
POP(ce)) {
4039 for(cm = ml; !
ENDP(cm);
POP(cm)) {
4364 bool declarable_p =
true;
4369 declarable_p =
false;
4374 return declarable_p;
4430 for(cm = ml; !
ENDP(cm);
POP(cm)) {
4797 bool finished_p =
false;
5238 bool overloaded_p =
true;
5244 overloaded_p =
false;
5249 return overloaded_p;
5370 pips_assert(
"input type is a struct union, or enum\n",
5455 bool const_p =
false;
5468 bool restrict_p =
false;
5485 bool qualifier_p =
false;
5625 for(i=1; i<n && !
ENDP(dims); i++,
POP(dims))
5627 if(i==n && !
ENDP(dims))
5767 bool void_star_p =
false;
5776 bool char_star_p =
false;
5789 bool char_star_p =
false;
5851 bool dependent_p =
false;
5874 bool dependent_p =
false;
constant make_constant(enum constant_utype tag, void *val)
basic make_basic_derived(entity _field_)
parameter make_parameter(type a1, mode a2, dummy a3)
mode make_mode(enum mode_utype tag, void *val)
type make_type_variable(variable _field_)
basic make_basic(enum basic_utype tag, void *val)
value make_value_constant(constant _field_)
mode make_mode_reference(void)
type copy_type(type p)
TYPE.
basic copy_basic(basic p)
BASIC.
basic make_basic_overloaded(void)
basic make_basic_int(intptr_t _field_)
type make_type_void(list _field_)
basic make_basic_pointer(type _field_)
expression copy_expression(expression p)
EXPRESSION.
value make_value(enum value_utype tag, void *val)
constant make_constant_int(intptr_t _field_)
dimension make_dimension(expression a1, expression a2, list a3)
variable make_variable(basic a1, list a2, list a3)
basic make_basic_string(value _field_)
reference copy_reference(reference p)
REFERENCE.
dummy make_dummy_unknown(void)
mode make_mode_value(void)
bool type_consistent_p(type p)
string type_tag_as_string(enum type_utype tag)
type make_type(enum type_utype tag, void *val)
struct paramStruct params
static reference ref
Current stmt (an integer)
bool entity_is_argument_p(entity e, cons *args)
void const char const char const int
struct _newgen_struct_type_ * type
int dummy
A dummy file, to prevent empty libraries from breaking builds.
#define gen_chunk_undefined_p(c)
#define gen_context_recurse(start, ctxt, domain_number, flt, rwt)
void gen_full_free_list(list l)
void * gen_chunk_identity(gen_chunk x)
bool gen_true2(__attribute__((unused)) gen_chunk *u1, __attribute__((unused)) void *u2)
#define ENDP(l)
Test if a list is empty.
list gen_nreverse(list cp)
reverse a list in place
#define POP(l)
Modify a list pointer to point on the next element of the list.
#define NIL
The empty list (nil in Lisp)
size_t gen_length(const list l)
void gen_list_and_not(list *a, const list b)
Compute A = A inter non B:
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
#define CAR(pcons)
Get the value of the first element of a list.
void gen_free_list(list l)
free the spine of the list
list gen_last(list l)
Return the last element of a list.
bool gen_in_list_p(const void *vo, const list lx)
tell whether vo belongs to lx
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
#define CDR(pcons)
Get the list less its first element.
list gen_nthcdr(int n, const list lx)
caution: the first item is 0! was: return( (n<=0) ? l : gen_nthcdr( n-1, CDR( l ))) ; if n>gen_length...
#define MAPL(_map_list_cp, _code, _l)
Apply some code on the addresses of all the elements of a list.
void * gen_find(const void *item, const list seq, gen_filter2_func_t test, gen_extract_func_t extract)
list gen_append(list l1, const list l2)
gen_chunk gen_nth(int n, const list l)
to be used as ENTITY(gen_nth(3, l))...
#define list_undefined
Undefined list definition :-)
#define MAP(_map_CASTER, _map_item, _map_code, _map_list)
Apply/map an instruction block on all the elements of a list (old fashioned)
list gen_full_copy_list(list l)
Copy a list structure with element copy.
bool gen_equals(const list l0, const list l1, gen_eq_func_t equals)
compares two lists using the functor given in parameters returns true if for all n,...
hash_table hash_table_make(hash_key_type key_type, size_t size)
void * hash_get(const hash_table htp, const void *key)
this function retrieves in the hash table pointed to by htp the couple whose key is equal to key.
void hash_put(hash_table htp, const void *key, const void *val)
This functions stores a couple (key,val) in the hash table pointed to by htp.
void hash_table_free(hash_table htp)
this function deletes a hash table that is no longer useful.
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_user_warning
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define pips_internal_error
#define user_warning(fn,...)
void debug(const int the_expected_debug_level, const char *calling_function_name, const char *a_message_format,...)
ARARGS0.
string bool_to_string(bool)
#define HASH_FOREACH(key_type, k, value_type, v, ht)
#define hash_table_undefined_p(h)
#define hash_table_undefined
Value of an undefined hash_table.
#define same_string_p(s1, s2)
bool set_belong_p(const set, const void *)
#define set_undefined_p(s)
set set_make(set_type)
Create an empty set of any type but hash_private.
set set_add_element(set, const set, const void *)
bool(* gen_filter2_func_t)(const void *, const void *)
bool(* gen_eq_func_t)(const void *, const void *)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
int f2(int off1, int off2, int w, int n, float r[n], float a[n], float b[n])
static hash_table pl
properties are stored in this hash table (string -> property) for fast accesses.
list lparams
Array bounds.
#define DEFAULT_LOGICAL_TYPE_SIZE
#define DEFAULT_SIGNED_TYPE_SIZE
#define DBLE_GENERIC_CONVERSION_NAME
#define DEFAULT_LONG_LONG_INTEGER_TYPE_SIZE
#define ENTITY_ASSIGN_P(e)
#define DCMPLX_GENERIC_CONVERSION_NAME
#define ENTITY_COMMA_P(e)
#define ENTITY_DEREFERENCING_P(e)
#define DEFAULT_LONGDOUBLECOMPLEX_TYPE_SIZE
#define DEFAULT_INTEGER_TYPE_SIZE
#define DEFAULT_REAL_TYPE_SIZE
The standard C integer types are represented as follow char = 1 short_int = 2 int = 4 long_int = 6 lo...
#define ENTITY_POINT_TO_P(e)
#define DEFAULT_COMPLEX_TYPE_SIZE
#define ENTITY_BRACE_INTRINSIC_P(e)
C initialization expression.
#define DEFAULT_DOUBLECOMPLEX_TYPE_SIZE
#define DEFAULT_UNSIGNED_TYPE_SIZE
#define ENTITY_CONDITIONAL_P(e)
#define DEFAULT_LONG_INTEGER_TYPE_SIZE
#define DEFAULT_QUADPRECISION_TYPE_SIZE
#define DEFAULT_CHARACTER_TYPE_SIZE
Default type sizes.
#define CMPLX_GENERIC_CONVERSION_NAME
#define ENTITY_FIELD_P(e)
C data structure and pointer management.
#define ENTITY_MINUS_C_P(e)
#define INT_GENERIC_CONVERSION_NAME
generic conversion names.
#define DEFAULT_POINTER_TYPE_SIZE
#define ENTITY_ADDRESS_OF_P(e)
#define REAL_GENERIC_CONVERSION_NAME
#define DEFAULT_DOUBLEPRECISION_TYPE_SIZE
const char * entity_user_name(entity e)
Since entity_local_name may contain PIPS special characters such as prefixes (label,...
bool entity_struct_p(entity e)
Is entity e the entity corresponding to a struct declaration?
bool same_entity_p(entity e1, entity e2)
predicates on entities
bool arithmetic_intrinsic_p(entity e)
true if e is an arithmetic instrinsic
bool entity_enum_p(entity e)
bool typedef_entity_p(entity e)
basic entity_basic(entity e)
return the basic associated to entity e if it's a function/variable/constant basic_undefined otherwis...
void print_entities(list l)
entity find_enum_of_member(entity m)
entity entity_intrinsic(const char *name)
FI: I do not understand this function name (see next one!).
bool entity_union_p(entity e)
Is entity e an entity representing the union declaration?
value EvalExpression(expression e)
Evaluate statically an expression.
bool expression_integer_value(expression e, intptr_t *pval)
expression normalize_integer_constant_expression(expression e)
Allocate a new expression equivalent to e, but constant expressions are evaluated.
expression make_unbounded_expression()
bool expression_equal_p(expression e1, expression e2)
Syntactic equality e1==e2.
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
bool reference_equal_p(reference r1, reference r2)
bool unbounded_dimension_p(dimension dim)
bool unbounded_dimension_p(dim) input : a dimension of an array entity.
bool expression_reference_p(expression e)
Test if an expression is a reference.
reference expression_reference(expression e)
Short cut, meaningful only if expression_reference_p(e) holds.
bool extended_expression_constant_p(expression exp)
Returns true if the value of the expression does not depend syntactically on the current store.
type ultimate_array_type(type t)
basic basic_of_expressions(list expressions, bool skip_overloaded)
bool array_pointer_string_type_equal_p(type t1, type t2)
Assume that a pointer to type x is equal to a 1-D array of x.
bool type_void_star_p(type t)
basic simple_basic_dup(basic b)
int number_of_items(type t)
Same as above, but arrays in struct are taken into account.
bool array_type_p(type t)
type make_standard_long_integer_type(type t)
bool type_fundamental_basic_p(type t)
list derived_type_fields(type t)
size_t maximal_type_depth(type t)
Number of steps to access the lowest leave of type t without a recursive test.
static list recursive_type_supporting_references(list srl, type t)
Compute the list of references implied in the definition of a type.
bool qualifiers_const_p(list ql)
Check that a qualifier list contains the const qualifier.
bool qualifiers_equal_p(list dims1, list dims2)
bool qualifiers_restrict_p(list ql)
Check that a qualifier list contains the restrict qualifier.
list symbolic_supporting_references(list srl, symbolic s)
bool type_with_const_qualifier_p(type t)
Is there a const qualifier associated to type t.
bool type_union_variable_p(type t)
basic MakeBasicOverloaded()
bool same_type_name_p(const type t0, const type t1) {
static bool generic_type_equal_p(type t1, type t2, bool strict_p, bool qualifier_p, hash_table structural_table)
Warning: the lengths of string basics are not checked!!! string_type_size() could be used but it is p...
parameter MakeDoubleprecisionParameter()
basic expression_basic(expression expr)
int string_type_size(basic b)
static basic basic_and_indices_to_basic(basic b, list indices, bool ultimate_p)
BEGIN_EOLE.
list derived_type_to_fields(type t)
bool generic_parameter_equal_p(parameter p1, parameter p2, bool strict_p, bool qualifier_p, hash_table structural_table)
type call_to_type(call c)
list constant_expression_supporting_references(list srl, expression e)
Only applicable to C expressions.
parameter MakeOverloadedParameter()
type expression_to_type(expression exp)
For an array declared as int a[10][20], the type returned for a[i] is int [20].
type make_scalar_overloaded_type()
basic basic_of_any_expression(expression exp, bool apply_p)
list dimensions_to_normalized_dimensions(list dl)
evaluate constant expressions appearing in dimensions of list dl
static size_t generic_basic_depth(basic b, set vt)
bool signed_type_p(type t)
static list recursive_type_supporting_types(list stl, set vt, type t)
Compute the list of types implied in the definition of a type.
bool char_star_constant_function_type_p(type t)
Beware of typedefs.
type array_type_to_pointer_type(type t)
Allocate a new type that is the type of an array constant.
dimension FindIthDimension(entity e, int i)
type MakeTypeOverloaded()
int variable_dimension_number(variable v)
bool type_pointer_on_struct_variable_p(type t)
list ldimensions_dup(list l)
bool unsigned_type_p(type t)
Predicates on types.
type subscripted_type_to_type(type t, expression se)
Returns the type of an object of type t subscripted by expression se.
parameter MakeDoublecomplexParameter()
entity find_field_in_field_list(entity f, list fl)
To deal with fields declared in different C files.
parameter MakeRealParameter()
list recursive_functional_type_supporting_entities(list sel, set vt, functional f)
bool basic_equal_p(basic b1, basic b2)
int effect_basic_depth(basic b)
type expression_to_uncasted_type(expression exp)
If the expression is casted, return its type before cast.
list fortran_type_supporting_entities(list srl, type t)
bool concrete_array_pointer_type_equal_p(type t1, type t2)
Same as above, but resolve typedefs first.
type intrinsic_call_to_type(call c)
END_EOLE.
type type_to_array_type(type t)
convert a type "t" into a newly allocated array type "at" whose elements are of type "t",...
parameter MakeUnsignedIntegerParameter()
bool dependent_type_p(type t)
A type is dependent in many ways according to definitions given in Wikipedia.
void entity_basic_concrete_types_init()
bool derived_type_p(type t)
Returns true if t is of type struct, union or enum.
type MakeDoubleprecisionResult()
bool area_equal_p(area a1, area a2)
basic basic_of_reference(reference r)
Retrieves the basic of a reference in a newly allocated basic object.
bool standard_long_integer_type_p(type t)
Used to encode the long keyword in the parser.
type MakeVoidPointerResult()
type MakeUnsignedIntegerResult()
list dependence_of_dependent_type(type t)
similar to dependent_type_p but return a list of reference on which the type depend.
type MakeAnyScalarResult(tag t, _int size)
dimension find_ith_dimension(list dims, int n)
This function returns the ith dimension of a list of dimensions.
list struct_type_to_fields(type lt)
bool qualifier_equal_p(qualifier q1, qualifier q2)
bool logical_type_p(type t)
static type private_ultimate_type(type t, bool arrays_only)
FI: there are different notions of "ultimate" types in C.
type expression_to_concrete_type(expression e)
A new type is allocated.
parameter MakeLongIntegerParameter()
bool generic_basic_equal_p(basic b1, basic b2, bool strict_p, bool qualifier_p, hash_table structural_table)
bool same_basic_p(basic b1, basic b2)
check if two basics are similar.
list make_unbounded_dimensions(int d)
Minimal information to build a d-dimensional array type.
bool basic_type_p(type t)
Safer than the other implementation? bool pointer_type_p(type t) { bool is_pointer = false;.
static list recursive_functional_type_supporting_types(list stl, set vt, functional f)
bool typedef_type_p(type t)
Returns true if t is a typedefED type.
bool type_equal_up_to_qualifiers_p(type t1, type t2)
bool char_type_p(type t)
return true whether ‘t’ is a char or an unsigned char
bool type_equal_p(type t1, type t2)
bool variable_equal_p(variable v1, variable v2)
parameter MakeCharacterParameter()
type make_standard_integer_type(type t, int size)
basic basic_of_external(call c)
basic basic_of_external(call c): returns the basic of the result given by the call to an external fun...
type reference_to_type(reference ref)
parameter MakeLongDoublecomplexParameter()
MB.
parameter MakeAnyScalarParameter(tag t, _int size)
For Fortran.
bool ultimate_type_equal_p(type t1, type t2)
list generic_constant_expression_supporting_entities(list sel, set vt, expression e, bool language_c_p)
bool same_type_p(type t1, type t2)
Type equality and equivalence.
#define BCTYPES_TABLE_INIT_SIZE
basic_concrete_types
bool type_equal_up_to_typedefs_and_qualifiers_p(type t1, type t2)
bool string_type_p(type t)
bool dimension_equal_p(dimension d1, dimension d2)
bool generic_variable_equal_p(variable v1, variable v2, bool strict_p, bool qualifier_p, hash_table structural_table)
type call_to_functional_type(call c, bool ultimate_p)
The function called can have a functional type, or a typedef type or a pointer type to a functional t...
bool scalar_integer_type_p(type t)
bool array_of_derived_type_p(type t)
string safe_type_to_string(const type t)
bool declarable_type_p(type t, list pdl)
Are all types necessary to define fully type "t" listed in list "pdl"?
list constant_expression_supporting_entities(list sel, set vt, expression e)
C version.
type type_to_pointed_type(type t)
returns t if t is not a pointer type, and the pointed type if t is a pointer type.
basic some_basic_of_any_expression(expression exp, bool apply_p, bool ultimate_p)
basic basic_of_any_expression(expression exp, bool apply_p): Makes a basic of the same basic as the e...
parameter MakeIntegerParameter()
type MakeCharacterResult()
static set supporting_types
Compute the list of entities implied in the definition of a type.
void entity_basic_concrete_types_reset()
parameter MakeLogicalParameter()
static type subscripted_field_list_to_type(list fl, expression se)
returns the type associated to se.
list enum_supporting_entities(list sel, set vt, entity e)
list basic_supporting_entities(list sel, set vt, basic b)
bool functional_equal_p(functional f1, functional f2)
type array_type_to_sub_array_type(type t)
Allocate a new type, the sub-array type of "t".
type call_compatible_type(type t)
returns the type necessary to generate or check a call to an object of type t.
type pointed_type(type t)
returns the type pointed by the input type if it is a pointer or an array of pointers
type make_scalar_char_pointer_type()
Allocate a char * pointer type.
basic basic_union(expression exp1, expression exp2)
basic basic_union(expression exp1 exp2): returns the basic of the expression which has the most globa...
type array_type_projection(type t)
T is assumed to be an array type.
type type_to_returned_type(type t)
returns t if t is not a functoional type, and the returned type if t is a functional type.
parameter MakeLongLongIntegerParameter()
MB.
bool char_star_type_p(type t)
Beware of typedefs.
type type_to_final_pointed_type(type t)
returns t if t is not a pointer type, and the first indirectly pointed type that is not a pointer if ...
bool is_inferior_basic(basic b1, basic b2)
bool is_inferior_basic(basic1, basic2) return true if basic1 is less complex than basic2 ex: int is l...
type entity_basic_concrete_type(entity e)
retrieves or computes and then returns the basic concrete type of an entity
basic basic_of_any_reference(reference r, bool apply_p, bool ultimate_p)
Retrieves the basic of a reference in a newly allocated basic object.
string type_to_string(const type t)
type.c
bool fixed_length_array_type_p(type t)
list generic_symbolic_supporting_entities(list sel, set vt, symbolic s, bool language_c_p)
int number_of_fields(type t)
Recursive number of fields in a data structure...
list symbolic_supporting_entities(list sel, set vt, symbolic s)
C version.
type make_char_array_type(int n)
type array_type_to_element_type(type t)
returns the type of the elements of an array type, as a newly allocated type.
string qualifier_to_string(qualifier q)
bool variable_length_array_type_p(type t)
Is this equivalent to dependent_type_p()?
type MakeTypeArray(basic b, cons *ld)
functions on types
bool dimensions_equal_p(list dims1, list dims2)
static list dependence_of_dependent_basic(basic b)
bool pointer_type_p(type t)
Check for scalar pointers.
list enum_supporting_references(list srl, entity e)
bool concrete_type_equal_p(type t1, type t2)
Expand typedefs before the type comparison.
type MakeLongDoublecomplexResult()
MB.
static bool generic_field_list_equal_p(list fl1, list fl2, bool strict_p, bool qualifier_p, hash_table structural_table)
This function is only used for structural type equality.
basic basic_of_constant(call c)
basic basic_of_constant(call c): returns the basic of the call to a constant.
bool mode_equal_p(mode m1, mode m2)
type MakeQuadprecisionResult()
MB.
bool basic_concrete_type_leads_to_pointer_p(type bct)
returns true when the input type successors may be pointers
list type_supporting_types(type t)
Return the list of types used to define type t.
type ultimate_type(type t)
bool union_type_p(type t)
Returns true if t is of type derived and if the derived type is a union.
int basic_type_size(basic b)
See also SizeOfElements()
static bool generic_field_list_names_equal_p(list fl1, list fl2)
In case you are not protected against recursivity, check field names only.
bool array_element_type_p(type at, type et)
is "et" the type of an element of an array of type "at"?
parameter MakeVoidPointerParameter()
type MakeOverloadedResult()
this function creates a default fortran operator result, i.e.
bool enum_type_p(type t)
Returns true if t is of type derived and if the derived type is a enum.
bool integer_type_p(type t)
list recursive_type_supporting_entities(list sel, set vt, type t)
list type_supporting_references(list srl, type t)
bool check_C_function_type(entity f, list args)
Check that an effective parameter list is compatible with a function type.
list functional_type_supporting_references(list srl, functional f)
type C_type_to_pointed_type(type t)
returns a copy of t if t is not a pointer type, and the pointed type if t is a pointer type or.
bool generic_functional_equal_p(functional f1, functional f2, bool strict_p, bool qualifier_p, hash_table structural_table)
bool default_complex_type_p(type t)
bool float_type_p(type t)
type make_scalar_integer_type(_int n)
bool scalar_type_p(type t)
bool overloaded_type_p(type t)
Returns true if t is a variable type with a basic overloaded.
type MakeLongIntegerResult()
MB.
list variable_type_supporting_entities(list sel, set vt, variable v)
type MakeDoublecomplexResult()
basic basic_maximum(basic fb1, basic fb2)
bool type_structurally_equal_p(type t1, type t2)
Type t1 and t2 are equal if their basic concrete components are equal.
list basic_supporting_references(list srl, basic b)
unsigned int array_type_dimension(type t)
parameter MakePointerParameter()
bool compatible_basic_p(basic b1, basic b2)
check if two basics are similar.
list functional_type_supporting_types(functional f)
FI: I'm not sure this function is of any use.
basic basic_of_expression(expression exp)
basic basic_of_expression(expression exp): Makes a basic of the same basic as the expression "exp".
list fortran_constant_expression_supporting_entities(list sel, expression e)
Fortran version.
bool FILE_star_type_p(type t)
basic basic_of_intrinsic(call c, bool apply_p, bool ultimate_p)
basic basic_of_intrinsic(call c): returns the basic of the result given by call to an intrinsic funct...
bool type_struct_variable_p(type t)
bool C_pointer_type_p(type t)
Returns OK for "char[]" as well as for "char *".
static list basic_supporting_types(list stl, set vt, basic b)
parameter MakeComplexParameter()
bool struct_type_p(type t)
Returns true if t is of type derived and if the derived type is a struct.
basic basic_of_call(call c, bool apply_p, bool ultimate_p)
basic basic_of_call(call c): returns the basic of the result given by the call "c".
size_t type_depth(type t)
Number of steps to access the lowest leave of type t without dereferencing.
list type_supporting_entities(list sel, type t)
int effect_type_depth(type t)
Number of steps to access the lowest leave of type t.
bool array_pointer_type_equal_p(type t1, type t2)
assume that a pointer to type x is equal to a 1-D array of x
static bool compare_basic_p(basic b1, basic b2, bool same_p)
Used to implement the next two functions.
bool array_of_struct_type_p(type t)
type MakeLongLongIntegerResult()
MB.
list variable_type_supporting_references(list srl, variable v)
static bool dependent_basic_p(basic b)
type make_scalar_complex_type(_int n)
type type_to_pointer_type(type t)
allocate a new type "pt" which includes directly "t".
basic basic_ultimate(basic b)
get the ultimate basic from a basic typedef
static size_t generic_type_depth(type t, set vt)
bool parameter_equal_p(parameter p1, parameter p2)
type MakeTypeVariable(basic b, cons *ld)
BEGIN_EOLE.
static list variable_type_supporting_types(list stl, set vt, variable v)
bool overloaded_parameters_p(list lparams)
dimension dimension_dup(dimension d)
entity basic_to_generic_conversion(basic b)
returns the corresponding generic conversion entity, if any.
list functional_type_supporting_entities(list sel, functional f)
static hash_table entity_types_to_bctypes
basic MakeBasic(int the_tag)
END_EOLE.
bool call_compatible_type_p(type t)
end of basic_concrete_types
type expression_to_user_type(expression e)
Preserve typedef'ed types when possible.
type compute_basic_concrete_type(type t)
computes a new type which is the basic concrete type of the input type (this new type is not stored i...
static void reference_dependence_variable_check_and_add(reference ref, list *dependence_list)
parameter MakeQuadprecisionParameter()
MB.
bool unsigned_basic_p(basic b)
bool array_of_pointers_type_p(type t)
bool const_variable_p(entity)
bool NumberOfElements(basic, list, int *)
_int SizeOfElements(basic)
This function returns the length in bytes of the Fortran or C type represented by a basic,...
bool symbolic_constant_entity_p(entity)
BEGIN_EOLE.
#define type_functional_p(x)
#define dummy_identifier(x)
#define syntax_reference_p(x)
#define qualifier_const_p(x)
#define functional_result(x)
#define REFERENCE(x)
REFERENCE.
#define parameter_dummy(x)
#define basic_complex_p(x)
#define parameter_type(x)
#define value_constant(x)
#define syntax_reference(x)
#define type_unknown_p(x)
#define QUALIFIER(x)
QUALIFIER.
#define reference_variable(x)
#define basic_typedef_p(x)
#define SIZEOFEXPRESSION(x)
SIZEOFEXPRESSION.
#define sizeofexpression_type(x)
#define sizeofexpression_expression(x)
#define type_functional(x)
#define syntax_application(x)
#define parameter_undefined
#define dimension_lower(x)
#define parameter_mode(x)
#define basic_pointer_p(x)
#define basic_derived_p(x)
#define syntax_va_arg_p(x)
#define type_statement_p(x)
#define syntax_sizeofexpression_p(x)
@ is_syntax_sizeofexpression
#define range_increment(x)
#define value_constant_p(x)
#define basic_overloaded_p(x)
#define value_symbolic(x)
#define qualifier_restrict_p(x)
#define basic_undefined_p(x)
#define EXPRESSION(x)
EXPRESSION.
#define cast_expression(x)
#define application_arguments(x)
#define subscript_indices(x)
#define type_undefined_p(x)
#define reference_domain
newgen_range_domain_defined
#define constant_int_p(x)
#define value_symbolic_p(x)
#define functional_parameters(x)
#define variable_undefined
#define PARAMETER(x)
PARAMETER.
#define dimension_upper(x)
#define reference_indices(x)
#define syntax_sizeofexpression(x)
#define sizeofexpression_type_p(x)
#define dimension_undefined
#define variable_qualifiers(x)
#define syntax_application_p(x)
#define type_varargs_p(x)
#define subscript_array(x)
#define application_function(x)
#define variable_dimensions(x)
#define syntax_subscript(x)
#define call_arguments(x)
#define syntax_range_p(x)
#define dimension_qualifiers(x)
#define basic_string_p(x)
#define expression_syntax(x)
#define dummy_identifier_p(x)
#define type_variable_p(x)
#define symbolic_expression(x)
#define functional_undefined
#define constant_undefined
#define variable_basic(x)
#define basic_logical_p(x)
#define entity_initial(x)
#define syntax_subscript_p(x)
Value b1
booleen indiquant quel membre est en cours d'analyse
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.
struct cons * cdr
The pointer to the next element.
static int depth
la sequence de nids
#define exp
Avoid some warnings from "gcc -Wshadow".