bootstrap.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	type_context_t
	context for type checking. More...
struct	IntrinsicDescriptor
	The following data structure describes an intrinsic function: its name and its arity and its type, a function to type it (?) and a function to obtain its name if it is different from the entity user name, e.g. More...

Macros
#define	INT_LENGTH   4
	Warning! Do not modify this file that is automatically generated! More...
#define	REAL_LENGTH   4
#define	DOUBLE_LENGTH   8
#define	COMPLEX_LENGTH   8
#define	DCOMPLEX_LENGTH   16

Typedefs
typedef struct type_context_t *	type_context_p
typedef basic(*	typing_function_t) (call, type_context_p)
typedef void(*	switch_name_function) (expression, type_context_p)
typedef struct IntrinsicDescriptor	IntrinsicDescriptor
	The following data structure describes an intrinsic function: its name and its arity and its type, a function to type it (?) and a function to obtain its name if it is different from the entity user name, e.g. More...

Functions
void	CreateAreas (void)
	cproto-generated files More...
void	type_loop_range (basic, range, type_context_p)
call	convert_constant (call, basic)
expression	cast_constant (expression, basic, type_context_p)
expression	insert_cast (basic cast, basic, expression, type_context_p)
	Function in type_checker.c. More...
bool	arguments_are_compatible (call, hash_table)
type	MakeVoidResult (void)
	Move the following functions to ri-util/type.c. More...
parameter	MakeVoidParameter (void)
type	pointer_to_overloaded_type (int)
type	integer_to_overloaded_type (int)
type	longinteger_to_overloaded_type (int)
	MB. More...
type	longlonginteger_to_overloaded_type (int)
	MB. More...
type	integer_to_void_type (int)
type	void_to_overloaded_type (int)
type	overloaded_to_void_type (int)
type	void_to_integer_type (int)
typing_function_t	get_typing_function_for_intrinsic (const char *)
switch_name_function	get_switch_name_function_for_intrinsic (const char *)
entity	FindOrMakeIntrinsic (string, int, type(*)(int))
	This function creates an entity that represents an intrinsic function, if the entity does not already exist. More...
entity	FindOrMakeDefaultIntrinsic (string, int)
	Create a default intrinsic. More...
void	register_intrinsic_type_descriptor (IntrinsicDescriptor *)
	This function is called one time (at the very beginning) to create all intrinsic functions. More...
void	CreateIntrinsics (set)
bool	bootstrap (string)
value	MakeValueLitteral (void)
string	MakeFileName (char *, char *, char *)
entity	MakeIoFileArray (entity)
	This array is pointed by FILE * pointers returned or used by fopen, fclose,... More...
bool	check_loop_range (range, hash_table)
	type_checker.c More...
void	typing_of_expressions (string, statement)
bool	type_checker (const string)

Macro Definition Documentation

COMPLEX_LENGTH

#define COMPLEX_LENGTH   8

Definition at line 37 of file bootstrap.h.

DCOMPLEX_LENGTH

#define DCOMPLEX_LENGTH   16

Definition at line 38 of file bootstrap.h.

DOUBLE_LENGTH

#define DOUBLE_LENGTH   8

Definition at line 36 of file bootstrap.h.

INT_LENGTH

#define INT_LENGTH   4

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/bootstrap/bootstrap-local.h instead, to add your own modifications. header file built by cproto bootstrap-local.h should be some properties to accomodate cray codes??

Definition at line 34 of file bootstrap.h.

REAL_LENGTH

#define REAL_LENGTH   4

Definition at line 35 of file bootstrap.h.

Typedef Documentation

IntrinsicDescriptor

typedef struct IntrinsicDescriptor IntrinsicDescriptor

The following data structure describes an intrinsic function: its name and its arity and its type, a function to type it (?) and a function to obtain its name if it is different from the entity user name, e.g.

because of special characters or name collisions.

switch_name_function

typedef void(* switch_name_function) (expression, type_context_p)

Definition at line 52 of file bootstrap.h.

type_context_p

typedef struct type_context_t * type_context_p

typing_function_t

typedef basic(* typing_function_t) (call, type_context_p)

Definition at line 50 of file bootstrap.h.

Function Documentation

arguments_are_compatible()

bool arguments_are_compatible	(	call	c,
		hash_table	types
	)

First item

Next item

Parameters

types

ypes

Definition at line 1965 of file bootstrap.c.

{
  basic b1, b2;
  b1 = basic_undefined;
 
  MAP(EXPRESSION, e,
  {
    /* First item */
    if(basic_undefined_p(b1))
    {
      b1 = GET_TYPE(types, e);
    }
    /* Next item */
    else
    {
      b2 = GET_TYPE(types, e);
      if(!basic_compatible_p(b1, b2))
      {
        return false;
      }
    }
  }
      , call_arguments(c));
 
  return true;
}

References b1, b2, basic_compatible_p, basic_undefined, basic_undefined_p, call_arguments, EXPRESSION, GET_TYPE, and MAP.

Referenced by typing_of_assign().

Here is the caller graph for this function:

bootstrap()

bool bootstrap

(

string

workspace

)

Create all intrinsics, skipping user-defined one

Creates the dynamic and static areas for the super global arrays such as the logical unit array (see below).

The current entity is unknown, but for a TOP-LEVEL:TOP-LEVEL which is used to create the logical unit array for IO effects

create hidden variables to modelize the abstract states defined by the libc:

seed for random function package

heap abstract state

Create hidden variable to modelize the abstract state of : temporary arry for memmove function. Molka Becher

Create the empty label

FI: I suppress the owner filed to make the database moveable

FC: the content must be consistent with pipsdbm/methods.h

Parameters

workspace

orkspace

Definition at line 5619 of file bootstrap.c.

{
  pips_debug(1, "bootstraping in workspace %s\n", workspace);
 
  if (db_resource_p(DBR_ENTITIES, ""))
    pips_internal_error("entities already initialized");
 
  /* Create all intrinsics, skipping user-defined one */
  set module_list = set_make(set_string);
  gen_array_t ml = db_get_module_list();
  for(int i=0; i < (int) gen_array_nitems(ml); i++)
    set_add_element(module_list, module_list, (char*)gen_array_item(ml,i));
  CreateIntrinsics(module_list);
  set_free(module_list);
  gen_array_free(ml);
 
  /* Creates the dynamic and static areas for the super global
   * arrays such as the logical unit array (see below).
   */
  CreateAreas();
 
  /* The current entity is unknown, but for a TOP-LEVEL:TOP-LEVEL
   * which is used to create the logical unit array for IO effects
   */
  CreateLogicalUnits();
 
  /* create hidden variables to modelize the abstract states defined by the libc:
 
     seed for random function package
 
     heap abstract state
  */
  CreateRandomSeed();
  CreateTimeSeed();
  CreateHeapAbstractState();
  /* Create hidden variable to modelize the abstract state of :
     temporary arry for memmove function. Molka Becher
  */
  CreateMemmoveAbstractState();
 
  /* Create the empty label */
  (void) make_entity(strdup(concatenate(TOP_LEVEL_MODULE_NAME,
                                        MODULE_SEP_STRING,
                                        LABEL_PREFIX,
                                        NULL)),
                     MakeTypeStatement(),
                     make_storage_rom(),
                     make_value(is_value_constant,
                                make_constant_litteral()),
                     DEFAULT_ENTITY_KIND);
 
  /* FI: I suppress the owner filed to make the database moveable */
  /* FC: the content must be consistent with pipsdbm/methods.h */
  DB_PUT_MEMORY_RESOURCE(DBR_ENTITIES, "", (char*) entity_domain);
 
  pips_debug(1, "bootstraping done\n");
 
  return true;
}

References concatenate(), CreateAreas(), CreateHeapAbstractState(), CreateIntrinsics(), CreateLogicalUnits(), CreateMemmoveAbstractState(), CreateRandomSeed(), CreateTimeSeed(), db_get_module_list(), DB_PUT_MEMORY_RESOURCE, db_resource_p(), DEFAULT_ENTITY_KIND, entity_domain, gen_array_free(), gen_array_item(), gen_array_nitems(), int, is_value_constant, LABEL_PREFIX, make_constant_litteral(), make_entity, make_storage_rom(), make_value(), MakeTypeStatement(), MODULE_SEP_STRING, pips_debug, pips_internal_error, set_add_element(), set_free(), set_make(), set_string, strdup(), and TOP_LEVEL_MODULE_NAME.

Referenced by create_workspace().

Here is the call graph for this function:

Here is the caller graph for this function:

cast_constant()

expression cast_constant	(	expression	exp_constant,
		basic	to_basic,
		type_context_p	context
	)

Convert if necessary

Two arguments, with imagine party

One argument, no imagine party

DCOMPLEX -> COMPLEX

Conversion implicit

Conversion explicit

COMPLEX -> DCOMPLEX

Conversion implicit

Conversion explicit

Parameters

exp_constant	xp_constant
to_basic	o_basic
context	ontext

Definition at line 1343 of file bootstrap.c.

{
  entity function_called;
  call c;
  basic b = NULL;
  expression exp, exp_real, exp_imag, exp_real2, exp_imag2;
  syntax s = expression_syntax(exp_constant);
  if(syntax_call_p(s))
  {
    function_called = call_function(syntax_call(s));
    if(entity_constant_p(function_called))
    {
      /* Convert if necessary */
      c = convert_constant(syntax_call(s), to_basic);
      if (c != NULL)
      {
        context->number_of_simplication++;
        return make_expression(make_syntax(is_syntax_call, c),
                               normalized_undefined);
      }
    }
    else if(ENTITY_UNARY_MINUS_P(function_called))
    {
      exp = cast_constant(EXPRESSION(CAR(call_arguments(syntax_call(s)))),
                          to_basic, context);
      if (exp != NULL)
      {
        c = make_call(copy_entity(function_called),
                      CONS(EXPRESSION, exp, NIL));
        return make_expression(make_syntax(is_syntax_call, c),
                               normalized_undefined);
      }
    }
    else if(ENTITY_IMPLIED_CMPLX_P(function_called) ||
            ENTITY_CONVERSION_CMPLX_P(function_called) ||
            ENTITY_IMPLIED_DCMPLX_P(function_called) ||
            ENTITY_CONVERSION_DCMPLX_P(function_called))
    {
      exp_real = EXPRESSION(CAR(call_arguments(syntax_call(s))));
      /* Two arguments, with imagine party */
      if (CDR(call_arguments(syntax_call(s))) != NIL )
      {
        exp_imag = EXPRESSION(CAR(CDR(call_arguments(syntax_call(s)))));
      }
      /* One argument, no imagine party */
      else
      {
        exp_imag = NULL;
      }
      if (!basic_complex_p(to_basic))
      {
        return cast_constant(exp_real, to_basic, context);
      }
      /* DCOMPLEX -> COMPLEX */
      else if (basic_complex(to_basic) == 8 &&
               (ENTITY_IMPLIED_DCMPLX_P(function_called) ||
                ENTITY_CONVERSION_DCMPLX_P(function_called)))
      {
        b = make_basic_float(4);
        if ((exp_real2 = cast_constant(exp_real, b, context)) == NULL)
        {
          exp_real2 = exp_real;
        }
 
        if (exp_imag != NULL)
        {
          if ((exp_imag2 = cast_constant(exp_imag, b, context)) == NULL)
          {
            exp_imag2 = exp_imag;
          }
        }
        else
        {
          c =  make_call(make_constant_entity("0.0E0", is_basic_float,
                                              REAL_LENGTH),
                         NIL);
          exp_imag2 = make_expression(make_syntax(is_syntax_call, c),
                                      normalized_undefined);
        }
        /* Conversion implicit */
        if (!get_bool_property("TYPE_CHECKER_EXPLICIT_COMPLEX_CONSTANTS") &&
            ENTITY_IMPLIED_DCMPLX_P(function_called))
        {
          c = make_call(CreateIntrinsic(IMPLIED_COMPLEX_NAME),
                        CONS(EXPRESSION, exp_real2,
                             CONS(EXPRESSION, exp_imag2, NIL)));
        }
        /* Conversion explicit */
        else
        {
          c = make_call(CreateIntrinsic(CMPLX_GENERIC_CONVERSION_NAME),
                        CONS(EXPRESSION, exp_real2,
                             CONS(EXPRESSION, exp_imag2, NIL)));
        }
        return make_expression(make_syntax(is_syntax_call, c),
                               normalized_undefined);
      }
      /* COMPLEX -> DCOMPLEX */
      else if (basic_complex(to_basic) == 16 &&
               (ENTITY_IMPLIED_CMPLX_P(function_called) ||
                ENTITY_CONVERSION_CMPLX_P(function_called)))
      {
        b = make_basic_float(8);
        if ((exp_real2 = cast_constant(exp_real, b, context)) == NULL)
        {
          exp_real2 = exp_real;
        }
        if (exp_imag != NULL)
        {
          if ((exp_imag2 = cast_constant(exp_imag, b, context)) == NULL)
          {
            exp_imag2 = exp_imag;
          }
        }
        else
        {
          c =  make_call(make_constant_entity("0.0D0", is_basic_float,
                                              DOUBLE_LENGTH),
                         NIL);
          exp_imag2 = make_expression(make_syntax(is_syntax_call, c),
                                      normalized_undefined);
        }
        /* Conversion implicit */
        if (!get_bool_property("TYPE_CHECKER_EXPLICIT_COMPLEX_CONSTANTS") &&
            ENTITY_IMPLIED_CMPLX_P(function_called))
        {
          c = make_call(CreateIntrinsic(IMPLIED_DCOMPLEX_NAME),
                        CONS(EXPRESSION, exp_real2,
                             CONS(EXPRESSION, exp_imag2, NIL)));
        }
        /* Conversion explicit */
        else
        {
          c = make_call(CreateIntrinsic(DCMPLX_GENERIC_CONVERSION_NAME),
                        CONS(EXPRESSION, exp_real2,
                             CONS(EXPRESSION, exp_imag2, NIL)));
        }
        return make_expression(make_syntax(is_syntax_call, c),
                               normalized_undefined);
      }
    }
  }
  if (b != NULL)
  {
    free_basic(b);
  }
  return NULL;
}

References basic_complex, basic_complex_p, call_arguments, call_function, CAR, CDR, CMPLX_GENERIC_CONVERSION_NAME, CONS, convert_constant(), copy_entity(), CreateIntrinsic(), DCMPLX_GENERIC_CONVERSION_NAME, DOUBLE_LENGTH, entity_constant_p, ENTITY_CONVERSION_CMPLX_P, ENTITY_CONVERSION_DCMPLX_P, ENTITY_IMPLIED_CMPLX_P, ENTITY_IMPLIED_DCMPLX_P, ENTITY_UNARY_MINUS_P, exp, EXPRESSION, expression_syntax, free_basic(), get_bool_property(), IMPLIED_COMPLEX_NAME, IMPLIED_DCOMPLEX_NAME, is_basic_float, is_syntax_call, make_basic_float(), make_call(), make_constant_entity(), make_expression(), make_syntax(), NIL, normalized_undefined, REAL_LENGTH, syntax_call, and syntax_call_p.

Referenced by insert_cast(), and simplification_conversion().

Here is the call graph for this function:

Here is the caller graph for this function:

check_loop_range()

bool check_loop_range	(	range	r,
		hash_table	types
	)

type_checker.c

Parameters

types

ypes

Definition at line 292 of file type_checker.c.

{
  basic lower, upper, incr;
  lower = GET_TYPE(types, range_lower(r));
  upper = GET_TYPE(types, range_upper(r));
  incr = GET_TYPE(types, range_increment(r));
  if( (basic_int_p(lower) || basic_float_p(lower)) &&
      (basic_int_p(upper) || basic_float_p(upper)) &&
      (basic_int_p(incr) || basic_float_p(incr)))
  {
    return true;
  }
  return false;
}

References STUB_ERROR.

Referenced by check_this_loop(), and type_this_expression().

Here is the caller graph for this function:

convert_constant()

call convert_constant	(	call	c,
		basic	to_basic
	)

INT -> REAL

INT -> DOUBLE

INT -> COMPLEX

INT -> DCOMPLEX

REAL -> INT

REAL -> DOUBLE

REAL -> COMPLEX

REAL -> DCOMPLEX

DOUBLE -> INT

DOUBLE -> REAL

DOUBLE -> COMPLEX

DOUBLE -> DCOMPLEX

Parameters

to_basic

o_basic

Definition at line 1253 of file bootstrap.c.

{
  basic b;
  entity function_called = call_function(c);
  if(entity_constant_p(function_called))
  {
    b = entity_basic(function_called);
    if(basic_equal_p(b, to_basic))
    {
      //return NULL;
      return copy_call(c);
    }
    else if (basic_int_p(b))
    {
      /* INT -> REAL */
      if (basic_float_p(to_basic) && basic_float(to_basic)==4)
      {
        return convert_constant_from_int_to_real(c);
      }
      /* INT -> DOUBLE */
      if (basic_float_p(to_basic) && basic_float(to_basic)==8)
      {
        return convert_constant_from_int_to_double(c);
      }
      /* INT -> COMPLEX */
      if (basic_complex_p(to_basic) && basic_complex(to_basic)==8)
      {
        return convert_constant_from_int_to_complex(c);
      }
      /* INT -> DCOMPLEX */
      if (basic_complex_p(to_basic) && basic_complex(to_basic)==16)
      {
        return convert_constant_from_int_to_dcomplex(c);
      }
    }
    else if (basic_float_p(b) && basic_float(b)==4)
    {
      /* REAL -> INT */
      if (basic_int_p(to_basic))
      {
        return convert_constant_from_real_to_int(c);
      }
      /* REAL -> DOUBLE */
      else if (basic_float_p(to_basic) && basic_float(to_basic)==8)
      {
        return convert_constant_from_real_to_double(c);
      }
      /* REAL -> COMPLEX */
      else if (basic_complex_p(to_basic) && basic_complex(to_basic)==8)
      {
        return convert_constant_from_real_to_complex(c);
      }
      /* REAL -> DCOMPLEX */
      else if (basic_complex_p(to_basic) && basic_complex(to_basic)==16)
      {
        return convert_constant_from_real_to_dcomplex(c);
      }
    }
    else if (basic_float_p(b) && basic_float(b)==8)
    {
      /* DOUBLE -> INT */
      if (basic_int_p(to_basic))
      {
        return convert_constant_from_double_to_int(c);
      }
      /* DOUBLE -> REAL */
      else if (basic_float_p(to_basic) && basic_float(to_basic)==4)
      {
        return convert_constant_from_double_to_real(c);
      }
      /* DOUBLE -> COMPLEX */
      else if (basic_complex_p(to_basic) && basic_complex(to_basic)==8)
      {
        return convert_constant_from_double_to_complex(c);
      }
      /* DOUBLE -> DCOMPLEX */
      else if (basic_complex_p(to_basic) && basic_complex(to_basic)==16)
      {
        return convert_constant_from_double_to_dcomplex(c);
      }
    }
  }
  return NULL;
}

References basic_complex, basic_complex_p, basic_equal_p(), basic_float, basic_float_p, basic_int_p, call_function, convert_constant_from_double_to_complex(), convert_constant_from_double_to_dcomplex(), convert_constant_from_double_to_int(), convert_constant_from_double_to_real(), convert_constant_from_int_to_complex(), convert_constant_from_int_to_dcomplex(), convert_constant_from_int_to_double(), convert_constant_from_int_to_real(), convert_constant_from_real_to_complex(), convert_constant_from_real_to_dcomplex(), convert_constant_from_real_to_double(), convert_constant_from_real_to_int(), copy_call(), entity_basic(), and entity_constant_p.

Referenced by cast_constant().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateAreas()

void CreateAreas

(

void

)

cproto-generated files

bootstrap.c

Definition at line 104 of file bootstrap.c.

{
  make_entity(AddPackageToName(TOP_LEVEL_MODULE_NAME,
                               DYNAMIC_AREA_LOCAL_NAME),
              make_type(is_type_area, make_area(0, NIL)),
              make_storage(is_storage_rom, UU),
              make_value(is_value_unknown, UU),
          ABSTRACT_LOCATION|ENTITY_DYNAMIC_AREA);
 
 
  make_entity(AddPackageToName(TOP_LEVEL_MODULE_NAME,
                               STATIC_AREA_LOCAL_NAME),
              make_type(is_type_area, make_area(0, NIL)),
              make_storage(is_storage_rom, UU),
              make_value(is_value_unknown, UU),
          ABSTRACT_LOCATION|ENTITY_STATIC_AREA);
}

References ABSTRACT_LOCATION, AddPackageToName(), DYNAMIC_AREA_LOCAL_NAME, ENTITY_DYNAMIC_AREA, ENTITY_STATIC_AREA, is_storage_rom, is_type_area, is_value_unknown, make_area(), make_entity, make_storage(), make_type(), make_value(), NIL, STATIC_AREA_LOCAL_NAME, TOP_LEVEL_MODULE_NAME, and UU.

Referenced by bootstrap().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateIntrinsics()

void CreateIntrinsics

(

set

module_list

)

The table of intrinsic functions. this table is used at the begining of linking to create Fortran operators, commands and intrinsic functions.

Functions with a variable number of arguments are declared with INT_MAX arguments.

Nga Nguyen 27/06/2003 Fuse the tables of intrinsics for C and Fortran. Since there are differences between some kind of operators, such as in Fortran, "+" is only applied to arithmetic numbers, in C, "+" is also applied to pointer, the typing functions are different. So in some cases, we have to rename the operators

Pragma can be represented in the pips IR as a list of expression so new functions/intrinsics are needed. For exmaple to represent OMP pragmas, following intrinscs are needed: 1 - omp, parallel and for which are constant so with 0 argument, 2 - the colom poperator (for reduction) that takes two arguments 3 - private and reduction that takes a variable number of arguments.

internal inverse operator...

FORTRAN IO statement

Control statement

Arnauld Leservot, code CEA

(0.,1.) -> switched to a function call...

Bit manipulation functions : ISO/IEC 1539

These operators are used within the OPTIMIZE transformation in order to manipulate operators such as n-ary add and multiply or multiply-add operators ( JZ - sept 98)

integer combined multiply add or sub - FC oct 2005

Here are C intrinsics arranged in the order of the standard ISO/IEC 9899:TC2. MB

ISO 6.5.2.3 structure and union members

ISO 6.5.2.4 postfix increment and decrement operators, real or pointer type operand

ISO 6.5.3.1 prefix increment and decrement operators, real or pointer type operand

ISO 6.5.3.2 address and indirection operators, add pointer type

ISO 6.5.3.3 unary arithmetic operators

Unuary minus : ALREADY EXIST (FORTRAN) {UNARY_MINUS_OPERATOR_NAME, 1, default_intrinsic_type, typing_arithmetic_operator, 0},

ISO 6.5.5 multiplicative operators : ALREADY EXIST (FORTRAN) {MULTIPLY_OPERATOR_NAME, 2, default_intrinsic_type, typing_arithmetic_operator, 0}, {DIVIDE_OPERATOR_NAME, 2, default_intrinsic_type, typing_arithmetic_operator, 0},

ISO 6.5.6 additive operators, arithmetic types or pointer + integer type

ISO 6.5.7 bitwise shift operators

ISO 6.5.8 relational operators,arithmetic or pointer types

ISO 6.5.9 equality operators, return 0 or 1

ISO 6.5.10 bitwise AND operator

ISO 6.5.11 bitwise exclusive OR operator

ISO 6.5.12 bitwise inclusive OR operator

ISO 6.5.13 logical AND operator

ISO 6.5.14 logical OR operator

ISO 6.5.15 conditional operator

ISO 6.5.16.1 simple assignment : ALREADY EXIST (FORTRAN) {ASSIGN_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0},

ISO 6.5.16.2 compound assignments

ISO 6.5.17 comma operator

intrinsic to handle C initialization

include <assert.h>

does not return

include <complex.h>

include <ctype.h>

End ctype.h

Real type is void -> unsigned short int **

include <errno.h>

{"errno", 0, overloaded_to_integer_type, 0, 0},

bits/errno.h

include <fenv.h>

include <float.h>

{"__flt_rounds", 1, void_to_integer_type, 0, 0},

include <inttypes.h>

include <iso646.h>

{"_sysconf", 1, integer_to_integer_type, 0, 0},

{"localeconv", 1, default_intrinsic_type, 0, 0}, {"dcgettext", 3, default_intrinsic_type, 0, 0}, {"dgettext", 2, default_intrinsic_type, 0, 0}, {"gettext", 1, default_intrinsic_type, 0, 0}, {"textdomain", 1, default_intrinsic_type, 0, 0}, {"bindtextdomain", 2, default_intrinsic_type, 0, 0}, {"wdinit", 1, void_to_integer_type, 0 ,0}, {"wdchkind", 1, overloaded_to_integer_type, 0 ,0}, {"wdbindf", 3, overloaded_to_integer_type, 0 ,0}, {"wddelim", 3, default_intrinsic_type, 0, 0}, {"mcfiller", 1, void_to_overloaded_type, 0, 0}, {"mcwrap", 1, void_to_integer_type, 0 ,0},

include <limits.h>

include <locale.h>

include <math.h>

GNU C Library

End math.h

same name in stdlib {"ecvt", 4, default_intrinsic_type, 0, 0}, {"fcvt", 4, default_intrinsic_type, 0, 0}, {"gcvt", 3, default_intrinsic_type, 0, 0}, {"strtod", 2, overloaded_to_double_type, 0, 0},

include <setjmp.h>

include <signal.h>

include <stdarg.h>

include <stdbool.h>

include <stddef.h>

include <stdint.h>

include <stdio.h>

same name in stdlib {"getopt", 3, overloaded_to_integer_type, 0, 0}, {"getsubopt", 3, default_intrinsic_type, 0, 0},

C IO system functions in man -S 2. The typing could be refined. See unistd.h

2 or 3 arguments

returns ssize_t

{FCNTL_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},

2 or 3 arguments of various types

located with fcntl.h

include <stdlib.h>

void -> long int

include <string.h>

include <tgmath.h>

include <time.h>

include <wchar.h>

include <wctype.h>

netdb.h

include <fcntl.h>

OMP

BSD <err.h>

F95

F2003

PIPS run-time support for C code generation

Source code located in validation/Hyperplane/run_time.src for the time being.

assembly function

PIPS intrinsics to simulate various effects

PIRE

PI necessary calls

Parameters

module_list

odule_list

Definition at line 4417 of file bootstrap.c.

{
    /* The table of intrinsic functions. this table is used at the begining
       of linking to create Fortran operators, commands and intrinsic functions.
 
       Functions with a variable number of arguments are declared with INT_MAX
       arguments.
       */
 
    /* Nga Nguyen 27/06/2003 Fuse the tables of intrinsics for C and Fortran.
       Since there are differences between some kind of operators, such as in
       Fortran, "+" is only applied to arithmetic numbers, in C, "+" is also applied
       to pointer, the typing functions are different. So in some cases, we have to
       rename the operators */
    /* Pragma can be represented in the pips IR as a list of expression so new
     * functions/intrinsics are needed. For exmaple to represent OMP pragmas,
     * following intrinscs are needed:
     *    1 - omp, parallel and for which are constant so with 0 argument,
     *    2 - the colom poperator (for reduction) that takes two arguments
     *    3 - private and reduction that takes a variable number of arguments.
     */
    /*
     * IntrinsicDescriptor need:
     * {Name, Nbr_arg, Type, Type_Function, switch_name_function}
     * \Name                            Name of the intrinsic operator/function
     * \Nbr_arg                         Number of argument than the intrinsic operator/function need
     * \Type                            is a pointer of function, that expect to have 1 arg (\Nbr_arg) and return a type of kind functional
     * \Type_Function
     * \switch_name_function
     */
    static IntrinsicDescriptor IntrinsicTypeDescriptorTable[] =
    {
        {PLUS_OPERATOR_NAME, 2, default_intrinsic_type, typing_arithmetic_operator, 0},
        {MINUS_OPERATOR_NAME, 2, default_intrinsic_type, typing_arithmetic_operator, 0},
        {DIVIDE_OPERATOR_NAME, 2, default_intrinsic_type, typing_arithmetic_operator, 0},
        {MULTIPLY_OPERATOR_NAME, 2, default_intrinsic_type, typing_arithmetic_operator, 0},
        {UNARY_MINUS_OPERATOR_NAME, 1, default_intrinsic_type, typing_arithmetic_operator, 0}, // unary minus
        {POWER_OPERATOR_NAME, 2, default_intrinsic_type, typing_power_operator, 0},
 
        /* internal inverse operator... */
        { INVERSE_OPERATOR_NAME, 1, real_to_real_type,
            typing_function_RealDoubleComplex_to_RealDoubleComplex, 0},
 
        {ASSIGN_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0},
 
        {EQUIV_OPERATOR_NAME, 2, overloaded_to_logical_type, typing_logical_operator, 0},
        {NON_EQUIV_OPERATOR_NAME, 2, overloaded_to_logical_type, typing_logical_operator, 0},
 
        {OR_OPERATOR_NAME, 2, logical_to_logical_type, typing_logical_operator, 0},
        {AND_OPERATOR_NAME, 2, logical_to_logical_type, typing_logical_operator, 0},
        {NOT_OPERATOR_NAME, 1, logical_to_logical_type, typing_logical_operator, 0},
 
        {LESS_THAN_OPERATOR_NAME, 2, overloaded_to_logical_type, typing_relational_operator, 0},
        {GREATER_THAN_OPERATOR_NAME, 2, overloaded_to_logical_type, typing_relational_operator, 0},
        {LESS_OR_EQUAL_OPERATOR_NAME, 2, overloaded_to_logical_type, typing_relational_operator, 0},
        {GREATER_OR_EQUAL_OPERATOR_NAME, 2, overloaded_to_logical_type, typing_relational_operator, 0},
        {EQUAL_OPERATOR_NAME, 2, overloaded_to_logical_type, typing_relational_operator, 0},
        {NON_EQUAL_OPERATOR_NAME, 2, overloaded_to_logical_type, typing_relational_operator, 0},
 
        {CONCATENATION_FUNCTION_NAME, 2, character_to_character_type, typing_concat_operator, 0},
 
        /* FORTRAN IO statement */
        {WRITE_FUNCTION_NAME, (INT_MAX), default_intrinsic_type, check_read_write, 0},
        {REWIND_FUNCTION_NAME, (INT_MAX), default_intrinsic_type, check_rewind, 0},
        {BACKSPACE_FUNCTION_NAME, (INT_MAX), default_intrinsic_type, check_backspace, 0},
        {OPEN_FUNCTION_NAME, (INT_MAX), default_intrinsic_type, check_open, 0},
        {CLOSE_FUNCTION_NAME, (INT_MAX), default_intrinsic_type, check_close, 0},
        {READ_FUNCTION_NAME, (INT_MAX), default_intrinsic_type, check_read_write, 0},
        {BUFFERIN_FUNCTION_NAME, (INT_MAX), default_intrinsic_type, typing_buffer_inout, 0},
        {BUFFEROUT_FUNCTION_NAME, (INT_MAX), default_intrinsic_type, typing_buffer_inout, 0},
        {ENDFILE_FUNCTION_NAME, (INT_MAX), default_intrinsic_type, check_endfile, 0},
        {IMPLIED_DO_NAME, (INT_MAX), default_intrinsic_type, typing_implied_do, 0},
        {REPEAT_VALUE_NAME, 2, default_intrinsic_type, no_typing, 0},
        {STATIC_INITIALIZATION_FUNCTION_NAME, (INT_MAX) , default_intrinsic_type, no_typing, 0},
        {DATA_LIST_FUNCTION_NAME, (INT_MAX) , default_intrinsic_type, no_typing, 0},
        {FORMAT_FUNCTION_NAME, 1, default_intrinsic_type, check_format, 0},
        {INQUIRE_FUNCTION_NAME, (INT_MAX), default_intrinsic_type, check_inquire, 0},
 
        {SUBSTRING_FUNCTION_NAME, 3, substring_type, typing_substring, 0},
        {ASSIGN_SUBSTRING_FUNCTION_NAME, 4, assign_substring_type, typing_assign_substring, 0},
 
        /* Control statement */
        {CONTINUE_FUNCTION_NAME, 0, default_intrinsic_type, statement_without_argument, 0},
        {"ENDDO", 0, default_intrinsic_type, 0, 0}, // Why do we need this one?
        {PAUSE_FUNCTION_NAME, 1, default_intrinsic_type,
            statement_with_at_most_one_integer_or_character, 0},
        {RETURN_FUNCTION_NAME, 0, default_intrinsic_type,
            statement_with_at_most_one_expression_integer, 0},
        {STOP_FUNCTION_NAME, 0, default_intrinsic_type,
            statement_with_at_most_one_integer_or_character, 0},
        {END_FUNCTION_NAME, 0, default_intrinsic_type, statement_without_argument, 0}, // Is it useful?
 
 
        {INT_GENERIC_CONVERSION_NAME, 1, overloaded_to_integer_type,
            typing_function_conversion_to_integer, simplification_int},
        {IFIX_GENERIC_CONVERSION_NAME, 1, real_to_integer_type, typing_function_real_to_int,
            simplification_int},
        {IDINT_GENERIC_CONVERSION_NAME, 1, double_to_integer_type, typing_function_double_to_int,
            simplification_int},
        {REAL_GENERIC_CONVERSION_NAME, 1, overloaded_to_real_type, typing_function_conversion_to_real,
            simplification_real},
        {FLOAT_GENERIC_CONVERSION_NAME, 1, overloaded_to_real_type, typing_function_conversion_to_real,
            simplification_real},
        {DFLOAT_GENERIC_CONVERSION_NAME, 1, overloaded_to_double_type,
            typing_function_conversion_to_double, simplification_double},
        {SNGL_GENERIC_CONVERSION_NAME, 1, overloaded_to_real_type, typing_function_conversion_to_real,
            simplification_real},
        {DBLE_GENERIC_CONVERSION_NAME, 1, overloaded_to_double_type,
            typing_function_conversion_to_double, simplification_double},
        {DREAL_GENERIC_CONVERSION_NAME, 1, overloaded_to_double_type, /* Arnauld Leservot, code CEA */
            typing_function_conversion_to_double, simplification_double},
        {CMPLX_GENERIC_CONVERSION_NAME, (INT_MAX), overloaded_to_complex_type,
            typing_function_conversion_to_complex, simplification_complex},
 
        {DCMPLX_GENERIC_CONVERSION_NAME, (INT_MAX), overloaded_to_doublecomplex_type,
            typing_function_conversion_to_dcomplex, simplification_dcomplex},
 
        /* (0.,1.) -> switched to a function call... */
        { IMPLIED_COMPLEX_NAME, 2, overloaded_to_complex_type,
            typing_function_constant_complex, switch_specific_cmplx },
        { IMPLIED_DCOMPLEX_NAME, 2, overloaded_to_doublecomplex_type,
            typing_function_constant_dcomplex, switch_specific_dcmplx },
 
        {CHAR_TO_INT_CONVERSION_NAME, 1, default_intrinsic_type, typing_function_char_to_int, 0},
        {INT_TO_CHAR_CONVERSION_NAME, 1, default_intrinsic_type, typing_function_int_to_char, 0},
 
        {AINT_CONVERSION_NAME, 1, real_to_real_type,
            typing_function_RealDouble_to_RealDouble, switch_specific_aint},
        {DINT_CONVERSION_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {ANINT_CONVERSION_NAME, 1, real_to_real_type,
            typing_function_RealDouble_to_RealDouble, switch_specific_anint},
        {DNINT_CONVERSION_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {NINT_CONVERSION_NAME, 1, real_to_integer_type,
            typing_function_RealDouble_to_Integer, switch_specific_nint},
        {IDNINT_CONVERSION_NAME, 1, double_to_integer_type, typing_function_double_to_int, 0},
 
        //Fortran
        {IABS_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {ABS_OPERATOR_NAME, 1, real_to_real_type,
            typing_function_IntegerRealDoubleComplex_to_IntegerRealDoubleReal,
            switch_specific_abs},
        {DABS_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {CABS_OPERATOR_NAME, 1, complex_to_real_type, typing_function_complex_to_real, 0},
        {CDABS_OPERATOR_NAME, 1, doublecomplex_to_double_type,
            typing_function_dcomplex_to_double, 0},
 
        {MODULO_OPERATOR_NAME, 2, default_intrinsic_type,
            typing_function_IntegerRealDouble_to_IntegerRealDouble,
            switch_specific_mod},
        {REAL_MODULO_OPERATOR_NAME, 2, real_to_real_type, typing_function_real_to_real, 0},
        {DOUBLE_MODULO_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
 
        {ISIGN_OPERATOR_NAME, 2, integer_to_integer_type, typing_function_int_to_int, 0},
        {SIGN_OPERATOR_NAME, 2, default_intrinsic_type,
            typing_function_IntegerRealDouble_to_IntegerRealDouble,
            switch_specific_sign},
        {DSIGN_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
 
        {IDIM_OPERATOR_NAME, 2, integer_to_integer_type, typing_function_int_to_int, 0},
        {DIM_OPERATOR_NAME, 2, default_intrinsic_type,
            typing_function_IntegerRealDouble_to_IntegerRealDouble,
            switch_specific_dim},
        {DDIM_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
 
        {DPROD_OPERATOR_NAME, 2, real_to_double_type, typing_function_real_to_double, 0},
 
        {MAX_OPERATOR_NAME, (INT_MAX), default_intrinsic_type,
            typing_function_IntegerRealDouble_to_IntegerRealDouble,
            switch_specific_max},
        {MAX0_OPERATOR_NAME, (INT_MAX), integer_to_integer_type,
            typing_function_int_to_int, 0},
        {AMAX1_OPERATOR_NAME, (INT_MAX), real_to_real_type, typing_function_real_to_real, 0},
        {DMAX1_OPERATOR_NAME, (INT_MAX), double_to_double_type,
            typing_function_double_to_double, 0},
        {AMAX0_OPERATOR_NAME, (INT_MAX), integer_to_real_type,
            typing_function_int_to_real, 0},
        {MAX1_OPERATOR_NAME, (INT_MAX), real_to_integer_type, typing_function_real_to_int, 0},
 
        {MIN_OPERATOR_NAME, (INT_MAX), default_intrinsic_type,
            typing_function_IntegerRealDouble_to_IntegerRealDouble,
            switch_specific_min},
        {MIN0_OPERATOR_NAME, (INT_MAX), integer_to_integer_type,
            typing_function_int_to_int, 0},
        {AMIN1_OPERATOR_NAME, (INT_MAX), real_to_real_type, typing_function_real_to_real, 0},
        {DMIN1_OPERATOR_NAME, (INT_MAX), double_to_double_type,
            typing_function_double_to_double, 0},
        {AMIN0_OPERATOR_NAME, (INT_MAX), integer_to_real_type,
            typing_function_int_to_real, 0},
        {MIN1_OPERATOR_NAME, (INT_MAX), real_to_integer_type, typing_function_real_to_int, 0},
 
        {LENGTH_OPERATOR_NAME, 1, character_to_integer_type, typing_function_char_to_int, 0},
        {INDEX_OPERATOR_NAME, 2, character_to_integer_type, typing_function_char_to_int, 0},
 
        {AIMAG_CONVERSION_NAME, 1, complex_to_real_type, typing_function_complex_to_real, 0},
        {DIMAG_CONVERSION_NAME, 1, doublecomplex_to_double_type,
            typing_function_dcomplex_to_double, 0},
 
        {CONJG_OPERATOR_NAME, 1, complex_to_complex_type,
            typing_function_complex_to_complex, 0},
        {DCONJG_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type,
            typing_function_dcomplex_to_dcomplex, 0},
 
        {SQRT_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDoubleComplex_to_RealDoubleComplex,
            switch_specific_sqrt},
        {DSQRT_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {CSQRT_OPERATOR_NAME, 1, complex_to_complex_type,
            typing_function_complex_to_complex, 0},
        {CDSQRT_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type,
            typing_function_dcomplex_to_dcomplex, 0},
 
        {EXP_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDoubleComplex_to_RealDoubleComplex,
            switch_specific_exp},
        {DEXP_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {CEXP_OPERATOR_NAME, 1, complex_to_complex_type,
            typing_function_complex_to_complex, 0},
        {CDEXP_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type,
            typing_function_dcomplex_to_dcomplex, 0},
 
        {LOG_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDoubleComplex_to_RealDoubleComplex,
            switch_specific_log},
        {ALOG_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {DLOG_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {CLOG_OPERATOR_NAME, 1, complex_to_complex_type,
            typing_function_complex_to_complex, 0},
        {CDLOG_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type,
            typing_function_dcomplex_to_dcomplex, 0},
 
        {LOG10_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDouble_to_RealDouble, switch_specific_log10},
        {ALOG10_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {DLOG10_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
 
        {SIN_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDoubleComplex_to_RealDoubleComplex,
            switch_specific_sin},
        {DSIN_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {CSIN_OPERATOR_NAME, 1, complex_to_complex_type,
            typing_function_complex_to_complex, 0},
        {CDSIN_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type,
            typing_function_dcomplex_to_dcomplex, 0},
 
        {COS_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDoubleComplex_to_RealDoubleComplex,
            switch_specific_cos},
        {DCOS_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {CCOS_OPERATOR_NAME, 1, complex_to_complex_type,
            typing_function_complex_to_complex, 0},
        {CDCOS_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type,
            typing_function_dcomplex_to_dcomplex, 0},
 
        {TAN_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDouble_to_RealDouble, switch_specific_tan},
        {DTAN_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
 
        {ASIN_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDouble_to_RealDouble, switch_specific_asin},
        {DASIN_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
 
        {ACOS_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDouble_to_RealDouble, switch_specific_acos},
        {DACOS_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
 
        {ATAN_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDouble_to_RealDouble, switch_specific_atan},
        {DATAN_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {ATAN2_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDouble_to_RealDouble, switch_specific_atan2},
        {DATAN2_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
 
        {SINH_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDouble_to_RealDouble, switch_specific_sinh},
        {DSINH_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
 
        {COSH_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDouble_to_RealDouble, switch_specific_cosh},
        {DCOSH_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
 
        {TANH_OPERATOR_NAME, 1, default_intrinsic_type,
            typing_function_RealDouble_to_RealDouble, switch_specific_tanh},
        {DTANH_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
 
        {LGE_OPERATOR_NAME, 2, character_to_logical_type, typing_function_char_to_logical, 0},
        {LGT_OPERATOR_NAME, 2, character_to_logical_type, typing_function_char_to_logical, 0},
        {LLE_OPERATOR_NAME, 2, character_to_logical_type, typing_function_char_to_logical, 0},
        {LLT_OPERATOR_NAME, 2, character_to_logical_type, typing_function_char_to_logical, 0},
 
        {LIST_DIRECTED_FORMAT_NAME, 0, default_intrinsic_type,
            typing_function_format_name, 0},
        {UNBOUNDED_DIMENSION_NAME, 0, default_intrinsic_type,
            typing_function_overloaded, 0},
 
        /* Bit manipulation functions : ISO/IEC 1539 */
        {ISHFT_OPERATOR_NAME, 2, integer_to_integer_type, typing_function_int_to_int, 0},
        {ISHFTC_OPERATOR_NAME, 3,integer_to_integer_type, typing_function_int_to_int, 0},
        {IBITS_OPERATOR_NAME, 3, integer_to_integer_type, typing_function_int_to_int, 0},
        {MVBITS_OPERATOR_NAME, 5,integer_to_integer_type, typing_function_int_to_int, 0},
        {BTEST_OPERATOR_NAME, 2,integer_to_logical_type, typing_function_int_to_logical, 0},
        {IBSET_OPERATOR_NAME, 2,integer_to_integer_type, typing_function_int_to_int, 0},
        {IBCLR_OPERATOR_NAME, 2,integer_to_integer_type, typing_function_int_to_int, 0},
        {BIT_SIZE_OPERATOR_NAME, 2,integer_to_integer_type, typing_function_int_to_int, 0},
        {IAND_OPERATOR_NAME, 2,integer_to_integer_type, typing_function_int_to_int, 0},
        {IEOR_OPERATOR_NAME, 2,integer_to_integer_type, typing_function_int_to_int, 0},
        {IOR_OPERATOR_NAME, 2,integer_to_integer_type, typing_function_int_to_int, 0},
 
        /* These operators are used within the OPTIMIZE transformation in
           order to manipulate operators such as n-ary add and multiply or
           multiply-add operators ( JZ - sept 98) */
        {EOLE_SUM_OPERATOR_NAME, (INT_MAX), default_intrinsic_type ,
            typing_arithmetic_operator, 0},
        {EOLE_PROD_OPERATOR_NAME, (INT_MAX), default_intrinsic_type ,
            typing_arithmetic_operator, 0},
        {EOLE_FMA_OPERATOR_NAME, 3, default_intrinsic_type ,
            typing_arithmetic_operator, 0},
        {EOLE_FMS_OPERATOR_NAME, 3, default_intrinsic_type ,
            typing_arithmetic_operator, 0},
 
        /* integer combined multiply add or sub - FC oct 2005 */
        { IMA_OPERATOR_NAME, 3, integer_to_integer_type,
            typing_function_int_to_int, 0 },
        { IMS_OPERATOR_NAME, 3, integer_to_integer_type,
            typing_function_int_to_int, 0 },
 
        /* Here are C intrinsics arranged in the order of the standard ISO/IEC 9899:TC2. MB */
 
        /* ISO 6.5.2.3 structure and union members */
        {FIELD_OPERATOR_NAME, 2, default_intrinsic_type, 0, 0},
        {POINT_TO_OPERATOR_NAME, 2, default_intrinsic_type, 0, 0},
        /* ISO 6.5.2.4 postfix increment and decrement operators, real or pointer type operand */
        {POST_INCREMENT_OPERATOR_NAME, 1, default_intrinsic_type, 0, 0},
        {POST_DECREMENT_OPERATOR_NAME, 1, default_intrinsic_type, 0, 0},
        /* ISO 6.5.3.1 prefix increment and decrement operators, real or pointer type operand */
        {PRE_INCREMENT_OPERATOR_NAME, 1, default_intrinsic_type, 0, 0},
        {PRE_DECREMENT_OPERATOR_NAME, 1, default_intrinsic_type, 0, 0},
        /* ISO 6.5.3.2 address and indirection operators, add pointer type */
        // this definition must be more precise but cause a type issue
        // {ADDRESS_OF_OPERATOR_NAME, 1, pointer_to_overloaded_type, 0, 0},
        {ADDRESS_OF_OPERATOR_NAME, 1, default_intrinsic_type, 0, 0},
        {DEREFERENCING_OPERATOR_NAME, 1, default_intrinsic_type, 0, 0},
        /* ISO 6.5.3.3 unary arithmetic operators */
        {UNARY_PLUS_OPERATOR_NAME, 1, default_intrinsic_type, typing_arithmetic_operator, 0},
        /* Unuary minus : ALREADY EXIST (FORTRAN)
           {UNARY_MINUS_OPERATOR_NAME, 1, default_intrinsic_type, typing_arithmetic_operator, 0},*/
        {BITWISE_NOT_OPERATOR_NAME, 1, integer_to_overloaded_type, typing_arithmetic_operator, 0},
        {C_NOT_OPERATOR_NAME, 1, overloaded_to_integer_type, 0, 0},
        /* ISO 6.5.5 multiplicative operators : ALREADY EXIST (FORTRAN)
           {MULTIPLY_OPERATOR_NAME, 2, default_intrinsic_type, typing_arithmetic_operator, 0},
           {DIVIDE_OPERATOR_NAME, 2, default_intrinsic_type, typing_arithmetic_operator, 0},*/
        {C_MODULO_OPERATOR_NAME, 2, integer_to_overloaded_type, typing_arithmetic_operator, 0},
        /* ISO 6.5.6 additive operators, arithmetic types or pointer + integer type*/
        {PLUS_C_OPERATOR_NAME, 2, default_intrinsic_type, 0, 0},
        {MINUS_C_OPERATOR_NAME, 2, default_intrinsic_type, 0, 0},
        /* ISO 6.5.7 bitwise shift operators*/
        {LEFT_SHIFT_OPERATOR_NAME, 2, integer_to_overloaded_type, 0, 0},
        {RIGHT_SHIFT_OPERATOR_NAME, 2, integer_to_overloaded_type, 0, 0},
        /* ISO 6.5.8 relational operators,arithmetic or pointer types */
        {C_LESS_THAN_OPERATOR_NAME, 2, overloaded_to_integer_type, 0, 0},
        {C_GREATER_THAN_OPERATOR_NAME, 2, overloaded_to_integer_type, 0, 0},
        {C_LESS_OR_EQUAL_OPERATOR_NAME, 2, overloaded_to_integer_type, 0, 0},
        {C_GREATER_OR_EQUAL_OPERATOR_NAME, 2, overloaded_to_integer_type, 0, 0},
        /* ISO 6.5.9 equality operators, return 0 or 1*/
        {C_EQUAL_OPERATOR_NAME, 2, overloaded_to_integer_type, 0, 0},
        {C_NON_EQUAL_OPERATOR_NAME, 2, overloaded_to_integer_type, 0, 0},
        /* ISO 6.5.10 bitwise AND operator */
        {BITWISE_AND_OPERATOR_NAME, 2, integer_to_integer_type, typing_arithmetic_operator, 0},
        /* ISO 6.5.11 bitwise exclusive OR operator */
        {BITWISE_XOR_OPERATOR_NAME, 2, integer_to_integer_type, typing_arithmetic_operator, 0},
        /* ISO 6.5.12 bitwise inclusive OR operator */
        {BITWISE_OR_OPERATOR_NAME, 2, integer_to_integer_type, typing_arithmetic_operator, 0},
        /* ISO 6.5.13 logical AND operator */
        {C_AND_OPERATOR_NAME, 2, overloaded_to_integer_type, 0, 0},
        /* ISO 6.5.14 logical OR operator */
        {C_OR_OPERATOR_NAME, 2, overloaded_to_integer_type, 0, 0},
        /* ISO 6.5.15 conditional operator */
        {CONDITIONAL_OPERATOR_NAME, 3, default_intrinsic_type, 0, 0},
        /* ISO 6.5.16.1 simple assignment : ALREADY EXIST (FORTRAN)
           {ASSIGN_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0}, */
        /* ISO 6.5.16.2 compound assignments*/
        {MULTIPLY_UPDATE_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0},
        {DIVIDE_UPDATE_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0},
        {MODULO_UPDATE_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0},
        {PLUS_UPDATE_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0},
        {MINUS_UPDATE_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0},
        {LEFT_SHIFT_UPDATE_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0},
        {RIGHT_SHIFT_UPDATE_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0},
        {BITWISE_AND_UPDATE_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0},
        {BITWISE_XOR_UPDATE_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0},
        {BITWISE_OR_UPDATE_OPERATOR_NAME, 2, default_intrinsic_type, typing_of_assign, 0},
        /* ISO 6.5.17 comma operator */
        {COMMA_OPERATOR_NAME, (INT_MAX), default_intrinsic_type, 0, 0},
 
        {BREAK_FUNCTION_NAME, 0, default_intrinsic_type, 0, 0},
        {CASE_FUNCTION_NAME, 0, default_intrinsic_type, 0, 0},
        {DEFAULT_FUNCTION_NAME, 0, default_intrinsic_type, 0, 0},
        {C_RETURN_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
 
        /* intrinsic to handle C initialization */
        {BRACE_INTRINSIC, (INT_MAX) , default_intrinsic_type, no_typing, 0},
 
        /* #include <assert.h> */
        {ASSERT_FUNCTION_NAME, 3, overloaded_to_void_type,0,0},
        {ASSERT_FAIL_FUNCTION_NAME, 4, overloaded_to_void_type,0,0}, /* does not return */
 
        /* #include <complex.h> */
 
        {CACOS_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CACOSF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CACOSL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {CASIN_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CASINF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CASINL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {CATAN_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CATANF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CATANL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {C_CCOS_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CCOSF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CCOSL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {C_CSIN_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CSINF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CSINL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {CTAN_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CTANF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CTANL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {CACOSH_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CACOSHF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CACOSHL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {CASINH_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CASINHF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CASINHL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {CATANH_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CATANHF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CATANHL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {CCOSH_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CCOSHF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CCOSHL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {CSINH_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CSINHF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CSINHL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {CTANH_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CTANHF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CTANHL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {C_CEXP_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CEXPF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CEXPL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {C_CLOG_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CLOGF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CLOGL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {C_CABS_OPERATOR_NAME, 1, doublecomplex_to_double_type, typing_function_dcomplex_to_double, 0},
        {CABSF_OPERATOR_NAME, 1, complex_to_real_type, typing_function_complex_to_real, 0},
        {CABSL_OPERATOR_NAME, 1, longdoublecomplex_to_longdouble_type, typing_function_longdcomplex_to_longdouble, 0},
        {CPOW_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CPOWF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CPOWL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {C_CSQRT_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CSQRTF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CSQRTL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {CARG_OPERATOR_NAME, 1, doublecomplex_to_double_type, typing_function_dcomplex_to_double, 0},
        {CARGF_OPERATOR_NAME, 1, complex_to_real_type, typing_function_complex_to_real, 0},
        {CARGL_OPERATOR_NAME, 1, longdoublecomplex_to_longdouble_type, typing_function_longdcomplex_to_longdouble, 0},
        {CIMAG_OPERATOR_NAME, 1, doublecomplex_to_double_type, typing_function_dcomplex_to_double, 0},
        {GCC_CIMAG_OPERATOR_NAME, 1, doublecomplex_to_double_type, typing_function_dcomplex_to_double, 0},
        {CIMAGF_OPERATOR_NAME, 1, complex_to_real_type, typing_function_complex_to_real, 0},
        {CIMAGL_OPERATOR_NAME, 1, longdoublecomplex_to_longdouble_type, typing_function_longdcomplex_to_longdouble, 0},
        {CONJ_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CONJF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CONJL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {CPROJ_OPERATOR_NAME, 1, doublecomplex_to_doublecomplex_type, typing_function_dcomplex_to_dcomplex, 0},
        {CPROJF_OPERATOR_NAME, 1, complex_to_complex_type, typing_function_complex_to_complex, 0},
        {CPROJL_OPERATOR_NAME, 1, longdoublecomplex_to_longdoublecomplex_type, typing_function_longdcomplex_to_longdcomplex, 0},
        {CREAL_OPERATOR_NAME, 1, doublecomplex_to_double_type, typing_function_dcomplex_to_double, 0},
        {GCC_CREAL_OPERATOR_NAME, 1, doublecomplex_to_double_type, typing_function_dcomplex_to_double, 0},
        {CREALF_OPERATOR_NAME, 1,  complex_to_real_type, typing_function_complex_to_real, 0},
        {CREALL_OPERATOR_NAME, 1, longdoublecomplex_to_longdouble_type, typing_function_longdcomplex_to_longdouble, 0},
 
        /* #include <ctype.h> */
 
        {ISALNUM_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {ISALPHA_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {ISBLANK_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {ISCNTRL_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {ISDIGIT_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {ISGRAPH_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {ISLOWER_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {ISPRINT_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {ISPUNCT_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {ISSPACE_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {ISUPPER_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {ISXDIGIT_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {TOLOWER_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {TOUPPER_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        /* End ctype.h */
        //not found in standard C99 (in GNU C Library)
        {ISASCII_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {TOASCII_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {_TOLOWER_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {_TOUPPER_OPERATOR_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
 
        /* Real type is void -> unsigned short int ** */
        {CTYPE_B_LOC_OPERATOR_NAME, 0, integer_to_integer_type, 0, 0},
 
        /* #include <errno.h> */
        /*  {"errno", 0, overloaded_to_integer_type, 0, 0}, */
        /* bits/errno.h */
        {__ERRNO_LOCATION_OPERATOR_NAME, 0, default_intrinsic_type, 0, 0},
 
 
        /* #include <fenv.h> */
        {FECLEAREXCEPT_FUNCTION_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {FERAISEEXCEPT_FUNCTION_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {FESETEXCEPTFLAG_FUNCTION_NAME, 2,  overloaded_to_integer_type, 0, 0},
        {FETESTEXCEPT_FUNCTION_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {FEGETROUND_FUNCTION_NAME, 1, void_to_integer_type, 0, 0},
        {FESETROUND_FUNCTION_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        // fenv_t *
        //{FESETENV_FUNCTION_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        //{FEUPDATEENV_FUNCTION_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
 
 
        /* #include <float.h> */
        /* {"__flt_rounds", 1, void_to_integer_type, 0, 0}, */
 
        /* #include <inttypes.h> */
        {IMAXABS_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {IMAXDIV_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
 
        /* #include <iso646.h> */
 
        /* {"_sysconf", 1, integer_to_integer_type, 0, 0},
 
           {"localeconv", 1, default_intrinsic_type, 0, 0},
           {"dcgettext", 3, default_intrinsic_type, 0, 0},
           {"dgettext", 2, default_intrinsic_type, 0, 0},
           {"gettext", 1, default_intrinsic_type, 0, 0},
           {"textdomain", 1, default_intrinsic_type, 0, 0},
           {"bindtextdomain", 2, default_intrinsic_type, 0, 0},
           {"wdinit", 1, void_to_integer_type, 0 ,0},
           {"wdchkind", 1, overloaded_to_integer_type, 0 ,0},
           {"wdbindf", 3, overloaded_to_integer_type, 0 ,0},
           {"wddelim", 3, default_intrinsic_type, 0, 0},
           {"mcfiller", 1, void_to_overloaded_type, 0, 0},
           {"mcwrap", 1, void_to_integer_type, 0 ,0},*/
 
        /* #include <limits.h> */
 
        /* #include <locale.h> */
        {SETLOCALE_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
 
        /* #include <math.h> */
 
        {FPCLASSIFY_OPERATOR_NAME, 1, double_to_integer_type,typing_function_double_to_int, 0},
        {ISFINITE_OPERATOR_NAME, 1, double_to_integer_type, typing_function_double_to_int, 0},
        {ISINF_OPERATOR_NAME, 1, double_to_integer_type, typing_function_double_to_int, 0},
        {ISNAN_OPERATOR_NAME, 1, double_to_integer_type, typing_function_double_to_int, 0},
        {ISNANL_OPERATOR_NAME, 1, double_to_integer_type, typing_function_real_to_int, 0},
        {ISNANF_OPERATOR_NAME, 1, real_to_integer_type, typing_function_real_to_int, 0},
        {ISNORMAL_OPERATOR_NAME, 1, double_to_integer_type, typing_function_double_to_int, 0},
        {SIGNBIT_OPERATOR_NAME, 1, double_to_integer_type,typing_function_double_to_int, 0},
        {C_ACOS_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double , 0},
        {ACOSF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {ACOSL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {C_ASIN_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {ASINF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {ASINL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0}, 
        {C_ATAN_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {ATANF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {ATANL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0}, 
        {C_ATAN2_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
        {ATAN2F_OPERATOR_NAME, 2, real_to_real_type, typing_function_real_to_real, 0},
        {ATAN2L_OPERATOR_NAME, 2, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0}, 
        {C_COS_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {COSF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {COSL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0}, 
        {C_SIN_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {SINF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {SINL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0}, 
        {C_TAN_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {TANF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {TANL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {C_ACOSH_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {ACOSHF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {ACOSHL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {C_ASINH_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {ASINHF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {ASINHL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {C_ATANH_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {ATANHF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {ATANHL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {C_COSH_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {COSHF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {COSHL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {C_SINH_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {SINHF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {SINHL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {C_TANH_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {TANHF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {TANHL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {C_EXP_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {EXPF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {EXPL_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {EXP2_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {EXP2F_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {EXP2L_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {EXPM1_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {EXPM1F_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {EXPM1L_OPERATOR_NAME, 1, longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},    
        {FREXP_OPERATOR_NAME, 2, overloaded_to_double_type, 0, 0},/*?*/
        {ILOGB_OPERATOR_NAME, 1, double_to_integer_type, typing_function_double_to_int, 0},
        {ILOGBF_OPERATOR_NAME, 1, double_to_integer_type, typing_function_double_to_int, 0},
        {ILOGBL_OPERATOR_NAME, 1, longdouble_to_integer_type, typing_function_longdouble_to_int, 0},    
        {LDEXP_OPERATOR_NAME, 2, overloaded_to_double_type, 0, 0},
        {LDEXPF_OPERATOR_NAME, 2, overloaded_to_real_type, 0, 0},
        {LDEXPL_OPERATOR_NAME, 2, overloaded_to_longdouble_type, 0, 0},
        {C_LOG_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {LOGF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {LOGL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0}, 
        {C_LOG10_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {LOG10F_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {LOG10L_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0}, 
        {LOG1P_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {LOG1PF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {LOG1PL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0}, 
        {LOG2_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {LOG2F_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {LOG2L_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0}, 
        {LOGB_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {LOGBF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {LOGBL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0}, 
        {MODF_OPERATOR_NAME, 2, overloaded_to_double_type, 0, 0},
        {MODFF_OPERATOR_NAME, 2, overloaded_to_real_type, 0, 0},
        {SCALBN_OPERATOR_NAME, 2, overloaded_to_double_type, 0, 0},
        {SCALBNF_OPERATOR_NAME, 2, overloaded_to_real_type, 0, 0},
        {SCALBNL_OPERATOR_NAME, 2, overloaded_to_longdouble_type, 0, 0}, 
        {SCALB_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0}, //POSIX.1-2001
        {SCALBLN_OPERATOR_NAME, 2, overloaded_to_double_type, 0, 0},
        {SCALBLNF_OPERATOR_NAME, 2, overloaded_to_real_type, 0, 0},
        {SCALBLNL_OPERATOR_NAME, 2, overloaded_to_longdouble_type, 0, 0},
        {CBRT_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {CBRTF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {CBRTL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0}, 
        {FABS_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {FABSF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {FABSL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {HYPOT_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
        {HYPOTF_OPERATOR_NAME, 2, real_to_real_type, typing_function_real_to_real, 0},
        {HYPOTL_OPERATOR_NAME, 2,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {POW_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
        {POWF_OPERATOR_NAME, 2, real_to_real_type, typing_function_real_to_real, 0},
        {POWL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {C_SQRT_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {SQRTF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {SQRTL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {ERF_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {ERFF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {ERFL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {ERFC_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {ERFCF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {ERFCL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {GAMMA_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0}, /* GNU C Library */
        {LGAMMA_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {LGAMMAF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {LGAMMAL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {TGAMMA_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {TGAMMAF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {CEIL_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {CEILF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {CEILL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {FLOOR_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {FLOORF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {FLOORL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},   
        {NEARBYINT_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {NEARBYINTF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {NEARBYINTL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},  
        {RINT_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {RINTF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {RINTL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},   
        {LRINT_OPERATOR_NAME, 1,  double_to_longinteger_type, typing_function_double_to_longint, 0}, 
        {LRINTF_OPERATOR_NAME, 1,  real_to_longinteger_type, typing_function_real_to_longint, 0},         
        {LRINTL_OPERATOR_NAME, 1,  longdouble_to_longinteger_type, typing_function_longdouble_to_longint, 0},
        {LLRINT_OPERATOR_NAME, 1,  double_to_longlonginteger_type, typing_function_double_to_longlongint, 0},
        {LLRINTF_OPERATOR_NAME, 1,  real_to_longlonginteger_type, typing_function_real_to_longlongint, 0},
        {LLRINTL_OPERATOR_NAME, 1,  longdouble_to_longlonginteger_type, typing_function_longdouble_to_longlongint, 0},
        {ROUND_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {ROUNDF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {ROUNDL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},   
        {LROUND_OPERATOR_NAME, 1,  double_to_longinteger_type, typing_function_double_to_longint, 0},   
        {LROUNDF_OPERATOR_NAME, 1,  real_to_longinteger_type, typing_function_real_to_longint, 0},
        {LROUNDL_OPERATOR_NAME, 1,  longdouble_to_longinteger_type, typing_function_longdouble_to_longint, 0},
        {LLROUND_OPERATOR_NAME, 1,  double_to_longlonginteger_type, typing_function_double_to_longlongint, 0},   
        {LLROUNDF_OPERATOR_NAME, 1,  real_to_longlonginteger_type, typing_function_real_to_longlongint, 0},
        {LLROUNDL_OPERATOR_NAME, 1,  longdouble_to_longlonginteger_type, typing_function_longdouble_to_longlongint, 0},
        {TRUNC_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {TRUNCF_OPERATOR_NAME, 1, real_to_real_type, typing_function_real_to_real, 0},
        {TRUNCL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},   
        {FMOD_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
        {FMODF_OPERATOR_NAME, 2, real_to_real_type, typing_function_real_to_real, 0},
        {FMODL_OPERATOR_NAME, 2,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},   
        {REMAINDER_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
        {REMAINDERF_OPERATOR_NAME, 2, real_to_real_type, typing_function_real_to_real, 0},
        {REMAINDERL_OPERATOR_NAME, 1,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},   
        {COPYSIGN_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
        {COPYSIGNF_OPERATOR_NAME, 2, real_to_real_type, typing_function_real_to_real, 0},
        {COPYSIGNL_OPERATOR_NAME, 2,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},
        {NAN_OPERATOR_NAME, 1, char_pointer_to_double_type, 0, 0},
        {NANF_OPERATOR_NAME, 1, default_intrinsic_type, 0, 0},
        {NANL_OPERATOR_NAME, 1, default_intrinsic_type, 0, 0},
        {NEXTAFTER_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
        {NEXTAFTERF_OPERATOR_NAME, 2, real_to_real_type, typing_function_real_to_real, 0},
        {NEXTAFTERL_OPERATOR_NAME, 2,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},
        {NEXTTOWARD_OPERATOR_NAME, 2,  overloaded_to_double_type,0, 0},
        {NEXTTOWARDF_OPERATOR_NAME, 2,  overloaded_to_real_type, 0, 0},
        {NEXTTOWARDL_OPERATOR_NAME, 2,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},
        {FDIM_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
        {FDIMF_OPERATOR_NAME, 2, real_to_real_type, typing_function_real_to_real, 0},
        {FDIML_OPERATOR_NAME, 2,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},
        {FMAX_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
        {FMAXF_OPERATOR_NAME, 2, real_to_real_type, typing_function_real_to_real, 0},
        {FMAXL_OPERATOR_NAME, 2,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},
        {FMIN_OPERATOR_NAME, 2, double_to_double_type, typing_function_double_to_double, 0},
        {FMINF_OPERATOR_NAME, 2, real_to_real_type, typing_function_real_to_real, 0},
        {FMINL_OPERATOR_NAME, 2,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},
        {FMA_OPERATOR_NAME, 3, double_to_double_type, typing_function_double_to_double, 0},
        {FMAF_OPERATOR_NAME, 3, real_to_real_type, typing_function_real_to_real, 0},
        {FMAL_OPERATOR_NAME, 3,  longdouble_to_longdouble_type, typing_function_longdouble_to_longdouble, 0},
        {ISGREATER_OPERATOR_NAME, 2, double_to_integer_type, typing_function_double_to_int, 0},
        {ISGREATEREQUAL_OPERATOR_NAME, 2, double_to_integer_type, typing_function_double_to_int, 0},
        {ISLESS_OPERATOR_NAME, 2, double_to_integer_type, typing_function_double_to_int, 0},
        {ISLESSEQUAL_OPERATOR_NAME, 2, double_to_integer_type, typing_function_double_to_int, 0},
        {ISLESSGREATER_OPERATOR_NAME, 2, double_to_integer_type, typing_function_double_to_int, 0},
        {ISUNORDERED_OPERATOR_NAME, 2, double_to_integer_type, typing_function_double_to_int, 0},
        /* End math.h */
 
        {J0_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {J1_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {JN_OPERATOR_NAME, 2, overloaded_to_double_type, 0, 0},
 
        {Y0_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {Y1_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
        {YN_OPERATOR_NAME, 2, overloaded_to_double_type, 0, 0},
 
        {MATHERR_OPERATOR_NAME, 1, overloaded_to_integer_type, 0, 0},
        {SIGNIFICAND_OPERATOR_NAME, 1, double_to_double_type, typing_function_double_to_double, 0},
 
        {SIGFPE_OPERATOR_NAME, 2, default_intrinsic_type, 0, 0},
        {SINGLE_TO_DECIMAL_OPERATOR_NAME, 4, overloaded_to_void_type, 0, 0},
        {DOUBLE_TO_DECIMAL_OPERATOR_NAME, 4, overloaded_to_void_type, 0, 0},
        {EXTENDED_TO_DECIMAL_OPERATOR_NAME, 4, overloaded_to_void_type, 0, 0},
        {QUADRUPLE_TO_DECIMAL_OPERATOR_NAME, 4, overloaded_to_void_type, 0, 0},
        {DECIMAL_TO_SINGLE_OPERATOR_NAME, 4, overloaded_to_void_type, 0, 0},
        {DECIMAL_TO_DOUBLE_OPERATOR_NAME, 4, overloaded_to_void_type, 0, 0},
        {DECIMAL_TO_EXTENDED_OPERATOR_NAME, 4, overloaded_to_void_type, 0, 0},
        {DECIMAL_TO_QUADRUPLE_OPERATOR_NAME, 4, overloaded_to_void_type, 0, 0},
        {STRING_TO_DECIMAL_OPERATOR_NAME, 6, overloaded_to_void_type, 0, 0},
        {FUNC_TO_DECIMAL_OPERATOR_NAME, 9, overloaded_to_void_type, 0, 0},
        {FILE_TO_DECIMAL_OPERATOR_NAME, 8, overloaded_to_void_type, 0, 0},
        {SECONVERT_OPERATOR_NAME, 5, default_intrinsic_type, 0, 0},
        {SFCONVERT_OPERATOR_NAME, 5, default_intrinsic_type, 0, 0},
        {SGCONVERT_OPERATOR_NAME, 4, default_intrinsic_type, 0, 0},
        {ECONVERT_OPERATOR_NAME, 5, default_intrinsic_type, 0, 0},
        {FCONVERT_OPERATOR_NAME, 5, default_intrinsic_type, 0, 0},
        {GCONVERT_OPERATOR_NAME, 4, default_intrinsic_type, 0, 0},
        {QECONVERT_OPERATOR_NAME, 5, default_intrinsic_type, 0, 0},
        {QFCONVERT_OPERATOR_NAME, 5, default_intrinsic_type, 0, 0},
        {QGCONVERT_OPERATOR_NAME, 4, default_intrinsic_type, 0, 0},
 
 
        /* same name in stdlib
           {"ecvt", 4, default_intrinsic_type, 0, 0},
           {"fcvt", 4, default_intrinsic_type, 0, 0},
           {"gcvt", 3, default_intrinsic_type, 0, 0},
           {"strtod", 2, overloaded_to_double_type, 0, 0}, */
 
        /*#include <setjmp.h>*/
 
        {"setjmp", 1, overloaded_to_integer_type, 0, 0},
        {"__setjmp", 1, overloaded_to_integer_type, 0, 0},
        {"longjmp", 2, overloaded_to_void_type, 0, 0},
        {"__longjmp", 2, overloaded_to_void_type, 0, 0},
        {"sigsetjmp", 2, overloaded_to_integer_type, 0, 0},
        {"siglongjmp", 2, overloaded_to_void_type, 0, 0},
 
 
        /*#include <signal.h>*/
        {SIGNAL_OPERATOR_NAME, 2, default_intrinsic_type, 0, 0},
        {RAISE_FUNCTION_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
 
        /*#include <stdarg.h>*/
        /*#include <stdbool.h>*/
        /*#include <stddef.h>*/
        /*#include <stdint.h>*/
        /*#include <stdio.h>*/
 
        {REMOVE_FUNCTION_NAME, 1, overloaded_to_integer_type, 0, 0},
        {RENAME_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {TMPFILE_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {TMPNAM_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {FCLOSE_FUNCTION_NAME, 1, overloaded_to_integer_type, 0, 0},
        {FFLUSH_FUNCTION_NAME, 1, overloaded_to_integer_type, 0, 0},
        {FOPEN_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {FREOPEN_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {SETBUF_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {SETVBUF_FUNCTION_NAME, 4, overloaded_to_integer_type, 0, 0},
        {FPRINTF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {FSCANF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {ISOC99_FSCANF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {PRINTF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {SCANF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {ISOC99_SCANF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {SPRINTF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {SSCANF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {ISOC99_SSCANF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {VSCANF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {ISOC99_VSCANF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {VSSCANF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {ISOC99_VSSCANF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {VFSCANF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {ISOC99_VFSCANF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {VFPRINTF_FUNCTION_NAME, 3, overloaded_to_integer_type, 0, 0},
        {VPRINTF_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {VSPRINTF_FUNCTION_NAME, 3, overloaded_to_integer_type, 0, 0},
        {FGETC_FUNCTION_NAME, 1, overloaded_to_integer_type, 0, 0},
        {FGETS_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {FPUTC_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {FPUTS_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {GETC_FUNCTION_NAME, 1, overloaded_to_integer_type, 0, 0},
        {_IO_GETC_FUNCTION_NAME, 1, overloaded_to_integer_type, 0, 0},
        {PUTC_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {_IO_PUTC_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {GETCHAR_FUNCTION_NAME, 1, void_to_integer_type, 0, 0},
        {PUTCHAR_FUNCTION_NAME, 1, integer_to_integer_type, 0, 0},
        {GETS_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {PUTS_FUNCTION_NAME, 1, overloaded_to_integer_type, 0, 0},
        {UNGETC_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {FREAD_FUNCTION_NAME, 4, default_intrinsic_type, 0, 0},
        {FWRITE_FUNCTION_NAME, 4, default_intrinsic_type, 0, 0},
        {FGETPOS_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {FSEEK_FUNCTION_NAME, 3, overloaded_to_integer_type, 0, 0},
        {FSETPOS_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {FTELL_FUNCTION_NAME,1, default_intrinsic_type, 0, 0},
        {C_REWIND_FUNCTION_NAME,1, default_intrinsic_type, 0, 0},
        {CLEARERR_FUNCTION_NAME,1, default_intrinsic_type, 0, 0},
        {FEOF_FUNCTION_NAME, 1, overloaded_to_integer_type, 0, 0},
        {FERROR_FUNCTION_NAME, 1, overloaded_to_integer_type, 0, 0},
        {PERROR_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {__FILBUF_FUNCTION_NAME, 1, overloaded_to_integer_type, 0, 0},
        {__FILSBUF_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {SETBUFFER_FUNCTION_NAME, 3, overloaded_to_void_type, 0, 0},
        {SETLINEBUF_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {SNPRINTF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {VSNPRINTF_FUNCTION_NAME, 4, overloaded_to_integer_type, 0, 0},
        {FDOPEN_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {CTERMID_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {FILENO_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {POPEN_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {CUSERID_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {TEMPNAM_FUNCTION_NAME, 2,default_intrinsic_type, 0, 0},
        /* same name in stdlib
           {"getopt", 3, overloaded_to_integer_type, 0, 0},
           {"getsubopt", 3, default_intrinsic_type, 0, 0},*/
        {GETW_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {PUTW_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {PCLOSE_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {FSEEKO_FUNCTION_NAME, 3, overloaded_to_integer_type, 0, 0},
        {FTELLO_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {FOPEN64_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {FREOPEN64_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {TMPFILE64_FUNCTION_NAME, 1,default_intrinsic_type, 0, 0},
        {FGETPOS64_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {FSETPOS64_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {FSEEKO64_FUNCTION_NAME, 3, overloaded_to_integer_type, 0, 0},
        {FTELLO64_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
 
        /* C IO system functions in man -S 2. The typing could be refined. See unistd.h */
 
        {C_OPEN_FUNCTION_NAME,    (INT_MAX), overloaded_to_integer_type, 0, 0}, /* 2 or 3 arguments */
        {CREAT_FUNCTION_NAME,     2,         overloaded_to_integer_type, 0, 0},
        {C_CLOSE_FUNCTION_NAME,   1,         integer_to_integer_type,    0, 0},
        {C_WRITE_FUNCTION_NAME,   2,         default_intrinsic_type, 0, 0}, /* returns ssize_t */
        {C_READ_FUNCTION_NAME,    2,         default_intrinsic_type, 0, 0},
        {USLEEP_FUNCTION_NAME,    1,         default_intrinsic_type, 0, 0},
        {LINK_FUNCTION_NAME,      2,         overloaded_to_integer_type, 0, 0},
        {SYMLINK_FUNCTION_NAME,   2,         overloaded_to_integer_type, 0, 0},
        {UNLINK_FUNCTION_NAME,    1,         overloaded_to_integer_type, 0, 0},
 
        /* {FCNTL_FUNCTION_NAME,     (INT_MAX), overloaded_to_integer_type, 0, 0},*/ /* 2 or 3 arguments of various types*/ /* located with fcntl.h */
        {FSYNC_FUNCTION_NAME,     2,         integer_to_integer_type, 0, 0},
        {FDATASYNC_FUNCTION_NAME, 2,         integer_to_integer_type, 0, 0},
        {IOCTL_FUNCTION_NAME,     (INT_MAX), overloaded_to_integer_type, 0, 0},
        {SELECT_FUNCTION_NAME,    5,         overloaded_to_integer_type, 0, 0},
        {PSELECT_FUNCTION_NAME,   6,         overloaded_to_integer_type, 0, 0},
        {STAT_FUNCTION_NAME,      2,         overloaded_to_integer_type, 0, 0},
        {FSTAT_FUNCTION_NAME,     2,         overloaded_to_integer_type, 0, 0},
        {LSTAT_FUNCTION_NAME,     2,         overloaded_to_integer_type, 0, 0},
        /*#include <stdlib.h>*/
 
        {ATOF_FUNCTION_NAME, 1, char_pointer_to_double_type, 0, 0},
        {ATOI_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {ATOL_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {ATOLL_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {STRTOD_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {STRTOF_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {STRTOLD_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {STRTOL_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {STRTOLL_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {STRTOUL_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {STRTOULL_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {RAND_FUNCTION_NAME, 1,  void_to_integer_type, 0, 0},
        {SRAND_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {CALLOC_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {FREE_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {MALLOC_FUNCTION_NAME, 1, unsigned_integer_to_void_pointer_type, 0, 0},
        {REALLOC_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {ALLOCA_FUNCTION_NAME, 1, unsigned_integer_to_void_pointer_type, 0, 0},
        {ABORT_FUNCTION_NAME, 1, void_to_void_type, 0, 0},
        {ATEXIT_FUNCTION_NAME, 1, void_to_void_to_int_pointer_type, 0, 0},
        {EXIT_FUNCTION_NAME, 1, integer_to_void_type, 0, 0},
        {_EXIT_FUNCTION_NAME, 1, integer_to_void_type, 0, 0},
        {GETENV_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {SYSTEM_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {BSEARCH_FUNCTION_NAME, 5, default_intrinsic_type, 0, 0},
        {QSORT_FUNCTION_NAME, 4, default_intrinsic_type, 0, 0},
        {C_ABS_FUNCTION_NAME, 1, integer_to_integer_type, typing_function_int_to_int, 0},
        {LABS_FUNCTION_NAME, 1, longinteger_to_longinteger_type, typing_function_longint_to_longint, 0},
        {LLABS_FUNCTION_NAME, 1, longlonginteger_to_longlonginteger_type, typing_function_longlongint_to_longlongint, 0},
        {DIV_FUNCTION_NAME, 2, integer_to_overloaded_type, 0, 0},
        {LDIV_FUNCTION_NAME, 2, longinteger_to_overloaded_type, 0, 0},
        {LLDIV_FUNCTION_NAME, 2, longlonginteger_to_overloaded_type, 0, 0},
        {MBLEN_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {MBTOWC_FUNCTION_NAME, 3, overloaded_to_integer_type, 0, 0},
        {WCTOMB_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0},
        {MBSTOWCS_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {WCSTOMBS_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
 
 
        //to check
        {POSIX_MEMALIGN_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {ATOQ_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {EXITHANDLE_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {DRAND48_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {ERAND48_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {JRAND48_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {LCONG48_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {LRAND48_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {MRAND48_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {NRAND48_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {SEED48_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {SRAND48_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {PUTENV_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {SETKEY_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {SWAB_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {MKSTEMP_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {MKSTEMP64_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {A614_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {ECVT_FUNCTION_NAME, 4, default_intrinsic_type, 0, 0},
        {FCVT_FUNCTION_NAME, 4, default_intrinsic_type, 0, 0},
        {GCVT_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {GETSUBOPT_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {GRANTPT_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {INITSTATE_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {C_164A_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {MKTEMP_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {PTSNAME_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {RANDOM_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0}, /* void -> long int */
        {REALPATH_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {SETSTATE_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {SRANDOM_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {TTYSLOT_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {UNLOCKPT_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {VALLOC_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {DUP2_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {QECVT_FUNCTION_NAME, 4, default_intrinsic_type, 0, 0},
        {QFCVT_FUNCTION_NAME, 4, default_intrinsic_type, 0, 0},
        {QGCVT_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {GETCWD_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {GETEXECNAME_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {GETLOGIN_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {GETOPT_FUNCTION_NAME, 3, default_intrinsic_type, 0, 0},
        {GETOPT_LONG_FUNCTION_NAME, 5, default_intrinsic_type, 0, 0},
        {GETOPT_LONG_ONLY_FUNCTION_NAME, 5, default_intrinsic_type, 0, 0},
        {GETPASS_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {GETPASSPHRASE_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {GETPW_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {ISATTY_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {MEMALIGN_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {TTYNAME_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {LLTOSTR_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {ULLTOSTR_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
 
        /*#include <string.h>*/
 
        {MEMCPY_FUNCTION_NAME,3,default_intrinsic_type, 0, 0},
        {MEMMOVE_FUNCTION_NAME,3,default_intrinsic_type, 0, 0},
        {STRCPY_FUNCTION_NAME,2,default_intrinsic_type, 0, 0},
        {STRDUP_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {STRNCPY_FUNCTION_NAME,3,default_intrinsic_type, 0, 0},
        {STRCAT_FUNCTION_NAME,2,default_intrinsic_type, 0, 0},
        {STRNCAT_FUNCTION_NAME,3,default_intrinsic_type, 0, 0},
        {MEMCMP_FUNCTION_NAME,3,overloaded_to_integer_type, 0, 0},
        {STRCMP_FUNCTION_NAME,2,overloaded_to_integer_type, 0, 0},
        {STRCOLL_FUNCTION_NAME,2,overloaded_to_integer_type, 0, 0},
        {STRNCMP_FUNCTION_NAME,3,overloaded_to_integer_type, 0, 0},
        {STRXFRM_FUNCTION_NAME,3,overloaded_to_integer_type, 0, 0},
        {MEMCHR_FUNCTION_NAME,3,default_intrinsic_type, 0, 0},
        {STRCHR_FUNCTION_NAME,2,default_intrinsic_type, 0, 0},
        {STRCSPN_FUNCTION_NAME,2,default_intrinsic_type, 0, 0},
        {STRPBRK_FUNCTION_NAME,2,default_intrinsic_type, 0, 0},
        {STRRCHR_FUNCTION_NAME,2,default_intrinsic_type, 0, 0},
        {STRSPN_FUNCTION_NAME,2,default_intrinsic_type, 0, 0},
        {STRSTR_FUNCTION_NAME,2,default_intrinsic_type, 0, 0},
        {STRTOK_FUNCTION_NAME,2,default_intrinsic_type, 0, 0},
        {MEMSET_FUNCTION_NAME,3,default_intrinsic_type, 0, 0},
        {STRERROR_FUNCTION_NAME,1,integer_to_overloaded_type, 0, 0},
        {STRERROR_R_FUNCTION_NAME,3,default_intrinsic_type, 0, 0},
        {STRLEN_FUNCTION_NAME,1,default_intrinsic_type, 0, 0},
 
        /*#include <tgmath.h>*/
        /*#include <time.h>*/
        {TIME_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {LOCALTIME_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {DIFFTIME_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {NANOSLEEP_FUNCTION_NAME, 2, default_intrinsic_type, 0, 0},
        {GETTIMEOFDAY_FUNCTION_NAME, 2, overloaded_to_void_type, 0, 0}, // BSD-GNU
        {CLOCK_GETTIME_FUNCTION_NAME, 2, overloaded_to_integer_type, 0, 0}, // BSD-GNU
        {CLOCK_FUNCTION_NAME, 0, void_to_overloaded_type, 0, 0},
        {SECOND_FUNCTION_NAME, 0, void_to_overloaded_type, 0, 0}, //GFORTRAN
 
        /*#include <wchar.h>*/
        { FWPRINTF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        { FWSCANF_FUNCTION_NAME,  (INT_MAX), overloaded_to_integer_type, 0, 0},
        { SWPRINTF_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        { SWSCANF_FUNCTION_NAME,  (INT_MAX), overloaded_to_integer_type, 0, 0},
        { VFWPRINTF_FUNCTION_NAME,  3,       overloaded_to_integer_type, 0, 0},
        { VFWSCANF_FUNCTION_NAME,   3,       overloaded_to_integer_type, 0, 0},
        { VSWPRINTF_FUNCTION_NAME,  4,       overloaded_to_integer_type, 0, 0},
        { VSWSCANF_FUNCTION_NAME,   3,       overloaded_to_integer_type, 0, 0},
        { VWPRINTF_FUNCTION_NAME,   2,       overloaded_to_integer_type, 0, 0},
        { VWSCANF_FUNCTION_NAME,    2,       overloaded_to_integer_type, 0, 0},
        { WPRINTF_FUNCTION_NAME,  (INT_MAX), overloaded_to_integer_type, 0, 0},
        { WSCANF_FUNCTION_NAME,   (INT_MAX), overloaded_to_integer_type, 0, 0},
        { FGETWC_FUNCTION_NAME,     1,       default_intrinsic_type, 0, 0},
        { FGETWS_FUNCTION_NAME,     3,       default_intrinsic_type, 0, 0},
        { FPUTWC_FUNCTION_NAME,     2,       default_intrinsic_type, 0, 0},
        { FPUTWS_FUNCTION_NAME,     2,       default_intrinsic_type, 0, 0},
        { FWIDE_FUNCTION_NAME,      2,       overloaded_to_integer_type, 0, 0},
        { GETWC_FUNCTION_NAME,      1,       default_intrinsic_type, 0, 0},
        { GETWCHAR_FUNCTION_NAME,   0,       default_intrinsic_type, 0, 0},
        { PUTWC_FUNCTION_NAME,      2,       default_intrinsic_type, 0, 0},
        { PUTWCHAR_FUNCTION_NAME,   1,       default_intrinsic_type, 0, 0},
        { UNGETWC_FUNCTION_NAME,    2,       default_intrinsic_type, 0, 0},
        { WCSTOD_FUNCTION_NAME,     2,       overloaded_to_double_type, 0, 0},
        { WCSTOF_FUNCTION_NAME,     2,       overloaded_to_real_type, 0, 0},
        { WCSTOLD_FUNCTION_NAME,    2,       default_intrinsic_type, 0, 0},
        { WCSTOL_FUNCTION_NAME,     3,       default_intrinsic_type, 0, 0},
        { WCSTOLL_FUNCTION_NAME,    3,       default_intrinsic_type, 0, 0},
        { WCSTOUL_FUNCTION_NAME,    3,       default_intrinsic_type, 0, 0},
        { WCSTOULL_FUNCTION_NAME,   3,       default_intrinsic_type, 0, 0},
        { WCSCPY_FUNCTION_NAME,     2,       default_intrinsic_type, 0, 0},
        { WCSNCPY_FUNCTION_NAME,    3,       default_intrinsic_type, 0, 0},
        { WMEMCPY_FUNCTION_NAME,    3,       default_intrinsic_type, 0, 0},
        { WMEMMOVE_FUNCTION_NAME,   3,       default_intrinsic_type, 0, 0},
        { WCSCAT_FUNCTION_NAME,     2,       default_intrinsic_type, 0, 0},
        { WCSNCAT_FUNCTION_NAME,    3,       default_intrinsic_type, 0, 0},
        { WCSCMP_FUNCTION_NAME,     2,       overloaded_to_integer_type, 0, 0},
        { WCSCOLL_FUNCTION_NAME,    2,       overloaded_to_integer_type, 0, 0},
        { WCSNCMP_FUNCTION_NAME,    3,       overloaded_to_integer_type, 0, 0},
        { WCSXFRM_FUNCTION_NAME,    3,       default_intrinsic_type, 0, 0},
        { WMEMCMP_FUNCTION_NAME,    3,       overloaded_to_integer_type, 0, 0},
        { WCSCHR_FUNCTION_NAME,     2,       default_intrinsic_type, 0, 0},
        { WCSCSPN_FUNCTION_NAME,    2,       default_intrinsic_type, 0, 0},
        { WCSPBRK_FUNCTION_NAME,    2,       default_intrinsic_type, 0, 0},
        { WCSRCHR_FUNCTION_NAME,    2,       default_intrinsic_type, 0, 0},
        { WCSSPN_FUNCTION_NAME,     2,       default_intrinsic_type, 0, 0},
        { WCSSTR_FUNCTION_NAME,     2,       default_intrinsic_type, 0, 0},
        { WCSTOK_FUNCTION_NAME,     3,       default_intrinsic_type, 0, 0},
        { WMEMCHR_FUNCTION_NAME,    2,       default_intrinsic_type, 0, 0},
        { WCSLEN_FUNCTION_NAME,     1,       default_intrinsic_type, 0, 0},
        { WMEMSET_FUNCTION_NAME,    3,       default_intrinsic_type, 0, 0},
        { WCSFTIME_FUNCTION_NAME,   4,       default_intrinsic_type, 0, 0},
        { BTOWC_FUNCTION_NAME,      1,       default_intrinsic_type, 0, 0},
        { WCTOB_FUNCTION_NAME,      1,       overloaded_to_integer_type, 0, 0},
        { MBSINIT_FUNCTION_NAME,    1,       overloaded_to_integer_type, 0, 0},
        { MBRLEN_FUNCTION_NAME,     3,       default_intrinsic_type, 0, 0},
        { MBRTOWC_FUNCTION_NAME,    3,       default_intrinsic_type, 0, 0},
        { WCRTOMB_FUNCTION_NAME,    3,       default_intrinsic_type, 0, 0},
        { MBSRTOWCS_FUNCTION_NAME,  4,       default_intrinsic_type, 0, 0},
        { WCSRTOMBS_FUNCTION_NAME,  4,       default_intrinsic_type, 0, 0},
 
        /*#include <wctype.h>*/
 
        {ISWALNUM_OPERATOR_NAME,  1, overloaded_to_integer_type, 0, 0},
        {ISWALPHA_OPERATOR_NAME,  1, overloaded_to_integer_type, 0, 0},
        {ISWBLANK_OPERATOR_NAME,  1, overloaded_to_integer_type, 0, 0},
        {ISWCNTRL_OPERATOR_NAME,  1, overloaded_to_integer_type, 0, 0},
        {ISWDIGIT_OPERATOR_NAME,  1, overloaded_to_integer_type, 0, 0},
        {ISWGRAPH_OPERATOR_NAME,  1, overloaded_to_integer_type, 0, 0},
        {ISWLOWER_OPERATOR_NAME,  1, overloaded_to_integer_type, 0, 0},
        {ISWPRINT_OPERATOR_NAME,  1, overloaded_to_integer_type, 0, 0},
        {ISWPUNCT_OPERATOR_NAME,  1, overloaded_to_integer_type, 0, 0},
        {ISWSPACE_OPERATOR_NAME,  1, overloaded_to_integer_type, 0, 0},
        {ISWUPPER_OPERATOR_NAME,  1, overloaded_to_integer_type, 0, 0},
        {ISWXDIGIT_OPERATOR_NAME, 1, overloaded_to_integer_type, 0, 0},
        {ISWCTYPE_OPERATOR_NAME,  2, overloaded_to_integer_type, 0, 0},
        {WCTYPE_OPERATOR_NAME,    1, default_intrinsic_type, 0, 0},
        {TOWLOWER_OPERATOR_NAME,  1, default_intrinsic_type, 0, 0},
        {TOWUPPER_OPERATOR_NAME,  1, default_intrinsic_type, 0, 0},
        {TOWCTRANS_OPERATOR_NAME, 2, default_intrinsic_type, 0, 0},
        {WCTRANS_OPERATOR_NAME,   1, default_intrinsic_type, 0, 0},
 
        /* netdb.h */
        {__H_ERRNO_LOCATION_OPERATOR_NAME, 0, default_intrinsic_type, 0, 0},
 
 
        /* #include <fcntl.h>*/
 
        {FCNTL_FUNCTION_NAME,  (INT_MAX), overloaded_to_integer_type, 0, 0},
        {DIRECTIO_FUNCTION_NAME, 2,       integer_to_integer_type, 0, 0},
        {OPEN64_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {CREAT64_FUNCTION_NAME,  2,       overloaded_to_integer_type, 0, 0},
 
        /* OMP */
        {OMP_IF_FUNCTION_NAME,        1,        default_intrinsic_type, 0, 0},
        {OMP_OMP_FUNCTION_NAME,       0,        default_intrinsic_type, 0, 0},
        {OMP_FOR_FUNCTION_NAME,       0,        default_intrinsic_type, 0, 0},
        {OMP_PRIVATE_FUNCTION_NAME,(INT_MAX),   default_intrinsic_type, 0, 0},
        {OMP_PARALLEL_FUNCTION_NAME,  0,        default_intrinsic_type, 0, 0},
        {OMP_REDUCTION_FUNCTION_NAME,(INT_MAX), default_intrinsic_type, 0, 0},
 
        /* BSD <err.h> */
        {ERR_FUNCTION_NAME,   (INT_MAX), overloaded_to_void_type, 0, 0},
        {ERRX_FUNCTION_NAME,  (INT_MAX), overloaded_to_void_type, 0, 0},
        {WARN_FUNCTION_NAME,  (INT_MAX), overloaded_to_void_type, 0, 0},
        {WARNX_FUNCTION_NAME, (INT_MAX), overloaded_to_void_type, 0, 0},
        {VERR_FUNCTION_NAME,    3,         overloaded_to_void_type, 0, 0},
        {VERRX_FUNCTION_NAME,   3,         overloaded_to_void_type, 0, 0},
        {VWARN_FUNCTION_NAME,   2,         overloaded_to_void_type, 0, 0},
        {VWARNX_FUNCTION_NAME,  2,         overloaded_to_void_type, 0, 0},
 
        /* F95 */
        {ALLOCATE_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {DEALLOCATE_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {ETIME_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {DTIME_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
        {CPU_TIME_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
 
        /* F2003 */
        {C_LOC_FUNCTION_NAME, 1, default_intrinsic_type, 0, 0},
 
        /* PIPS run-time support for C code generation
         *
         * Source code located in validation/Hyperplane/run_time.src for the
         * time being.
         */
        {PIPS_C_MIN_OPERATOR_NAME, (INT_MAX), integer_to_integer_type,
            typing_function_int_to_int, 0},
        {PIPS_C_MAX_OPERATOR_NAME, (INT_MAX), integer_to_integer_type,
            typing_function_int_to_int, 0},
        {PIPS_C_DIV_OPERATOR_NAME, 2, integer_to_integer_type, 
            typing_function_int_to_int, 0},
 
        /* assembly function */
        { ASM_FUNCTION_NAME, 1, overloaded_to_void_type , 0 , 0},
        // The 2 last arg don't know for what
 
        /* PIPS intrinsics to simulate various effects */
        {PIPS_MEMORY_BARRIER_OPERATOR_NAME, 0, void_to_void_type, 0, 0},
        {PIPS_IO_BARRIER_OPERATOR_NAME, 0, void_to_void_type, 0, 0},
        /*SPIRE*/
        {SEND_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
        {RECV_FUNCTION_NAME, (INT_MAX), overloaded_to_integer_type, 0, 0},
 
        /*MPI necessary calls*/
          //since C and Fortran MPI functions are not differentiate,
          //  The Fortran version is consider for number of argument
          //  (it has 1 more argument for the error handler when the C version return it)
          {MPI_INIT_FUNCTION_NAME,      (3),  overloaded_to_integer_type, 0, 0},
          {MPI_FINALIZE_FUNCTION_NAME,  (1),  overloaded_to_integer_type, 0, 0},
          {MPI_BARRIER_FUNCTION_NAME,   (2),  overloaded_to_integer_type, 0, 0},
          {MPI_COMM_SIZE_FUNCTION_NAME, (3),  overloaded_to_integer_type, 0, 0},
          {MPI_COMM_RANK_FUNCTION_NAME, (3),  overloaded_to_integer_type, 0, 0},
          {MPI_SEND_FUNCTION_NAME,      (7),  overloaded_to_integer_type, 0, 0},
          {MPI_SSEND_FUNCTION_NAME,     (7),  overloaded_to_integer_type, 0, 0},
          {MPI_RSEND_FUNCTION_NAME,     (7),  overloaded_to_integer_type, 0, 0},
          {MPI_BSEND_FUNCTION_NAME,     (7),  overloaded_to_integer_type, 0, 0},
          {MPI_ISEND_FUNCTION_NAME,     (8),  overloaded_to_integer_type, 0, 0},
          {MPI_ISSEND_FUNCTION_NAME,    (8),  overloaded_to_integer_type, 0, 0},
          {MPI_IRSEND_FUNCTION_NAME,    (8),  overloaded_to_integer_type, 0, 0},
          {MPI_IBSEND_FUNCTION_NAME,    (8),  overloaded_to_integer_type, 0, 0},
          {MPI_RECV_FUNCTION_NAME,      (8),  overloaded_to_integer_type, 0, 0},
          {MPI_IRECV_FUNCTION_NAME,     (8),  overloaded_to_integer_type, 0, 0},
          {MPI_SENDRECV_FUNCTION_NAME,  (13), overloaded_to_integer_type, 0, 0},
 
        {NULL, 0, 0, 0, 0}
    };
    intrinsic_type_descriptor_mapping=hash_table_make(hash_string,sizeof(IntrinsicTypeDescriptorTable));
    for(IntrinsicDescriptor *p = &IntrinsicTypeDescriptorTable[0];p->name;++p) {
        if(!set_belong_p(module_list,p->name))
            register_intrinsic_type_descriptor(p);
    }
}

References __ERRNO_LOCATION_OPERATOR_NAME, __FILBUF_FUNCTION_NAME, __FILSBUF_FUNCTION_NAME, __H_ERRNO_LOCATION_OPERATOR_NAME, _EXIT_FUNCTION_NAME, _IO_GETC_FUNCTION_NAME, _IO_PUTC_FUNCTION_NAME, _TOLOWER_OPERATOR_NAME, _TOUPPER_OPERATOR_NAME, A614_FUNCTION_NAME, ABORT_FUNCTION_NAME, ABS_OPERATOR_NAME, ACOS_OPERATOR_NAME, ACOSF_OPERATOR_NAME, ACOSHF_OPERATOR_NAME, ACOSHL_OPERATOR_NAME, ACOSL_OPERATOR_NAME, ADDRESS_OF_OPERATOR_NAME, AIMAG_CONVERSION_NAME, AINT_CONVERSION_NAME, ALLOCA_FUNCTION_NAME, ALLOCATE_FUNCTION_NAME, ALOG10_OPERATOR_NAME, ALOG_OPERATOR_NAME, AMAX0_OPERATOR_NAME, AMAX1_OPERATOR_NAME, AMIN0_OPERATOR_NAME, AMIN1_OPERATOR_NAME, AND_OPERATOR_NAME, ANINT_CONVERSION_NAME, ASIN_OPERATOR_NAME, ASINF_OPERATOR_NAME, ASINHF_OPERATOR_NAME, ASINHL_OPERATOR_NAME, ASINL_OPERATOR_NAME, ASM_FUNCTION_NAME, ASSERT_FAIL_FUNCTION_NAME, ASSERT_FUNCTION_NAME, ASSIGN_OPERATOR_NAME, ASSIGN_SUBSTRING_FUNCTION_NAME, assign_substring_type(), ATAN2_OPERATOR_NAME, ATAN2F_OPERATOR_NAME, ATAN2L_OPERATOR_NAME, ATAN_OPERATOR_NAME, ATANF_OPERATOR_NAME, ATANHF_OPERATOR_NAME, ATANHL_OPERATOR_NAME, ATANL_OPERATOR_NAME, ATEXIT_FUNCTION_NAME, ATOF_FUNCTION_NAME, ATOI_FUNCTION_NAME, ATOL_FUNCTION_NAME, ATOLL_FUNCTION_NAME, ATOQ_FUNCTION_NAME, BACKSPACE_FUNCTION_NAME, BIT_SIZE_OPERATOR_NAME, BITWISE_AND_OPERATOR_NAME, BITWISE_AND_UPDATE_OPERATOR_NAME, BITWISE_NOT_OPERATOR_NAME, BITWISE_OR_OPERATOR_NAME, BITWISE_OR_UPDATE_OPERATOR_NAME, BITWISE_XOR_OPERATOR_NAME, BITWISE_XOR_UPDATE_OPERATOR_NAME, BRACE_INTRINSIC, BREAK_FUNCTION_NAME, BSEARCH_FUNCTION_NAME, BTEST_OPERATOR_NAME, BTOWC_FUNCTION_NAME, BUFFERIN_FUNCTION_NAME, BUFFEROUT_FUNCTION_NAME, C_164A_FUNCTION_NAME, C_ABS_FUNCTION_NAME, C_ACOS_OPERATOR_NAME, C_ACOSH_OPERATOR_NAME, C_AND_OPERATOR_NAME, C_ASIN_OPERATOR_NAME, C_ASINH_OPERATOR_NAME, C_ATAN2_OPERATOR_NAME, C_ATAN_OPERATOR_NAME, C_ATANH_OPERATOR_NAME, C_CABS_OPERATOR_NAME, C_CCOS_OPERATOR_NAME, C_CEXP_OPERATOR_NAME, C_CLOG_OPERATOR_NAME, C_CLOSE_FUNCTION_NAME, C_COS_OPERATOR_NAME, C_COSH_OPERATOR_NAME, C_CSIN_OPERATOR_NAME, C_CSQRT_OPERATOR_NAME, C_EQUAL_OPERATOR_NAME, C_EXP_OPERATOR_NAME, C_GREATER_OR_EQUAL_OPERATOR_NAME, C_GREATER_THAN_OPERATOR_NAME, C_LESS_OR_EQUAL_OPERATOR_NAME, C_LESS_THAN_OPERATOR_NAME, C_LOC_FUNCTION_NAME, C_LOG10_OPERATOR_NAME, C_LOG_OPERATOR_NAME, C_MODULO_OPERATOR_NAME, C_NON_EQUAL_OPERATOR_NAME, C_NOT_OPERATOR_NAME, C_OPEN_FUNCTION_NAME, C_OR_OPERATOR_NAME, C_READ_FUNCTION_NAME, C_RETURN_FUNCTION_NAME, C_REWIND_FUNCTION_NAME, C_SIN_OPERATOR_NAME, C_SINH_OPERATOR_NAME, C_SQRT_OPERATOR_NAME, C_TAN_OPERATOR_NAME, C_TANH_OPERATOR_NAME, C_WRITE_FUNCTION_NAME, CABS_OPERATOR_NAME, CABSF_OPERATOR_NAME, CABSL_OPERATOR_NAME, CACOS_OPERATOR_NAME, CACOSF_OPERATOR_NAME, CACOSH_OPERATOR_NAME, CACOSHF_OPERATOR_NAME, CACOSHL_OPERATOR_NAME, CACOSL_OPERATOR_NAME, CALLOC_FUNCTION_NAME, CARG_OPERATOR_NAME, CARGF_OPERATOR_NAME, CARGL_OPERATOR_NAME, CASE_FUNCTION_NAME, CASIN_OPERATOR_NAME, CASINF_OPERATOR_NAME, CASINH_OPERATOR_NAME, CASINHF_OPERATOR_NAME, CASINHL_OPERATOR_NAME, CASINL_OPERATOR_NAME, CATAN_OPERATOR_NAME, CATANF_OPERATOR_NAME, CATANH_OPERATOR_NAME, CATANHF_OPERATOR_NAME, CATANHL_OPERATOR_NAME, CATANL_OPERATOR_NAME, CBRT_OPERATOR_NAME, CBRTF_OPERATOR_NAME, CBRTL_OPERATOR_NAME, CCOS_OPERATOR_NAME, CCOSF_OPERATOR_NAME, CCOSH_OPERATOR_NAME, CCOSHF_OPERATOR_NAME, CCOSHL_OPERATOR_NAME, CCOSL_OPERATOR_NAME, CDABS_OPERATOR_NAME, CDCOS_OPERATOR_NAME, CDEXP_OPERATOR_NAME, CDLOG_OPERATOR_NAME, CDSIN_OPERATOR_NAME, CDSQRT_OPERATOR_NAME, CEIL_OPERATOR_NAME, CEILF_OPERATOR_NAME, CEILL_OPERATOR_NAME, CEXP_OPERATOR_NAME, CEXPF_OPERATOR_NAME, CEXPL_OPERATOR_NAME, char_pointer_to_double_type(), CHAR_TO_INT_CONVERSION_NAME, character_to_character_type(), character_to_integer_type(), character_to_logical_type(), check_backspace(), check_close(), check_endfile(), check_format(), check_inquire(), check_open(), check_read_write(), check_rewind(), CIMAG_OPERATOR_NAME, CIMAGF_OPERATOR_NAME, CIMAGL_OPERATOR_NAME, CLEARERR_FUNCTION_NAME, CLOCK_FUNCTION_NAME, CLOCK_GETTIME_FUNCTION_NAME, CLOG_OPERATOR_NAME, CLOGF_OPERATOR_NAME, CLOGL_OPERATOR_NAME, CLOSE_FUNCTION_NAME, CMPLX_GENERIC_CONVERSION_NAME, COMMA_OPERATOR_NAME, complex_to_complex_type(), complex_to_real_type(), CONCATENATION_FUNCTION_NAME, CONDITIONAL_OPERATOR_NAME, CONJ_OPERATOR_NAME, CONJF_OPERATOR_NAME, CONJG_OPERATOR_NAME, CONJL_OPERATOR_NAME, CONTINUE_FUNCTION_NAME, COPYSIGN_OPERATOR_NAME, COPYSIGNF_OPERATOR_NAME, COPYSIGNL_OPERATOR_NAME, COS_OPERATOR_NAME, COSF_OPERATOR_NAME, COSH_OPERATOR_NAME, COSHF_OPERATOR_NAME, COSHL_OPERATOR_NAME, COSL_OPERATOR_NAME, CPOW_OPERATOR_NAME, CPOWF_OPERATOR_NAME, CPOWL_OPERATOR_NAME, CPROJ_OPERATOR_NAME, CPROJF_OPERATOR_NAME, CPROJL_OPERATOR_NAME, CPU_TIME_FUNCTION_NAME, CREAL_OPERATOR_NAME, CREALF_OPERATOR_NAME, CREALL_OPERATOR_NAME, CREAT64_FUNCTION_NAME, CREAT_FUNCTION_NAME, CSIN_OPERATOR_NAME, CSINF_OPERATOR_NAME, CSINH_OPERATOR_NAME, CSINHF_OPERATOR_NAME, CSINHL_OPERATOR_NAME, CSINL_OPERATOR_NAME, CSQRT_OPERATOR_NAME, CSQRTF_OPERATOR_NAME, CSQRTL_OPERATOR_NAME, CTAN_OPERATOR_NAME, CTANF_OPERATOR_NAME, CTANH_OPERATOR_NAME, CTANHF_OPERATOR_NAME, CTANHL_OPERATOR_NAME, CTANL_OPERATOR_NAME, CTERMID_FUNCTION_NAME, CTYPE_B_LOC_OPERATOR_NAME, CUSERID_FUNCTION_NAME, DABS_OPERATOR_NAME, DACOS_OPERATOR_NAME, DASIN_OPERATOR_NAME, DATA_LIST_FUNCTION_NAME, DATAN2_OPERATOR_NAME, DATAN_OPERATOR_NAME, DBLE_GENERIC_CONVERSION_NAME, DCMPLX_GENERIC_CONVERSION_NAME, DCONJG_OPERATOR_NAME, DCOS_OPERATOR_NAME, DCOSH_OPERATOR_NAME, DDIM_OPERATOR_NAME, DEALLOCATE_FUNCTION_NAME, DECIMAL_TO_DOUBLE_OPERATOR_NAME, DECIMAL_TO_EXTENDED_OPERATOR_NAME, DECIMAL_TO_QUADRUPLE_OPERATOR_NAME, DECIMAL_TO_SINGLE_OPERATOR_NAME, DEFAULT_FUNCTION_NAME, default_intrinsic_type(), DEREFERENCING_OPERATOR_NAME, DEXP_OPERATOR_NAME, DFLOAT_GENERIC_CONVERSION_NAME, DIFFTIME_FUNCTION_NAME, DIM_OPERATOR_NAME, DIMAG_CONVERSION_NAME, DINT_CONVERSION_NAME, DIRECTIO_FUNCTION_NAME, DIV_FUNCTION_NAME, DIVIDE_OPERATOR_NAME, DIVIDE_UPDATE_OPERATOR_NAME, DLOG10_OPERATOR_NAME, DLOG_OPERATOR_NAME, DMAX1_OPERATOR_NAME, DMIN1_OPERATOR_NAME, DNINT_CONVERSION_NAME, DOUBLE_MODULO_OPERATOR_NAME, DOUBLE_TO_DECIMAL_OPERATOR_NAME, double_to_double_type(), double_to_integer_type(), double_to_longinteger_type(), double_to_longlonginteger_type(), doublecomplex_to_double_type(), doublecomplex_to_doublecomplex_type(), DPROD_OPERATOR_NAME, DRAND48_FUNCTION_NAME, DREAL_GENERIC_CONVERSION_NAME, DSIGN_OPERATOR_NAME, DSIN_OPERATOR_NAME, DSINH_OPERATOR_NAME, DSQRT_OPERATOR_NAME, DTAN_OPERATOR_NAME, DTANH_OPERATOR_NAME, DTIME_FUNCTION_NAME, DUP2_FUNCTION_NAME, ECONVERT_OPERATOR_NAME, ECVT_FUNCTION_NAME, END_FUNCTION_NAME, ENDFILE_FUNCTION_NAME, EOLE_FMA_OPERATOR_NAME, EOLE_FMS_OPERATOR_NAME, EOLE_PROD_OPERATOR_NAME, EOLE_SUM_OPERATOR_NAME, EQUAL_OPERATOR_NAME, EQUIV_OPERATOR_NAME, ERAND48_FUNCTION_NAME, ERF_OPERATOR_NAME, ERFC_OPERATOR_NAME, ERFCF_OPERATOR_NAME, ERFCL_OPERATOR_NAME, ERFF_OPERATOR_NAME, ERFL_OPERATOR_NAME, ERR_FUNCTION_NAME, ERRX_FUNCTION_NAME, ETIME_FUNCTION_NAME, EXIT_FUNCTION_NAME, EXITHANDLE_FUNCTION_NAME, EXP2_OPERATOR_NAME, EXP2F_OPERATOR_NAME, EXP2L_OPERATOR_NAME, EXP_OPERATOR_NAME, EXPF_OPERATOR_NAME, EXPL_OPERATOR_NAME, EXPM1_OPERATOR_NAME, EXPM1F_OPERATOR_NAME, EXPM1L_OPERATOR_NAME, EXTENDED_TO_DECIMAL_OPERATOR_NAME, FABS_OPERATOR_NAME, FABSF_OPERATOR_NAME, FABSL_OPERATOR_NAME, FCLOSE_FUNCTION_NAME, FCNTL_FUNCTION_NAME, FCONVERT_OPERATOR_NAME, FCVT_FUNCTION_NAME, FDATASYNC_FUNCTION_NAME, FDIM_OPERATOR_NAME, FDIMF_OPERATOR_NAME, FDIML_OPERATOR_NAME, FDOPEN_FUNCTION_NAME, FECLEAREXCEPT_FUNCTION_NAME, FEGETROUND_FUNCTION_NAME, FEOF_FUNCTION_NAME, FERAISEEXCEPT_FUNCTION_NAME, FERROR_FUNCTION_NAME, FESETEXCEPTFLAG_FUNCTION_NAME, FESETROUND_FUNCTION_NAME, FETESTEXCEPT_FUNCTION_NAME, FFLUSH_FUNCTION_NAME, FGETC_FUNCTION_NAME, FGETPOS64_FUNCTION_NAME, FGETPOS_FUNCTION_NAME, FGETS_FUNCTION_NAME, FGETWC_FUNCTION_NAME, FGETWS_FUNCTION_NAME, FIELD_OPERATOR_NAME, FILE_TO_DECIMAL_OPERATOR_NAME, FILENO_FUNCTION_NAME, FLOAT_GENERIC_CONVERSION_NAME, FLOOR_OPERATOR_NAME, FLOORF_OPERATOR_NAME, FLOORL_OPERATOR_NAME, FMA_OPERATOR_NAME, FMAF_OPERATOR_NAME, FMAL_OPERATOR_NAME, FMAX_OPERATOR_NAME, FMAXF_OPERATOR_NAME, FMAXL_OPERATOR_NAME, FMIN_OPERATOR_NAME, FMINF_OPERATOR_NAME, FMINL_OPERATOR_NAME, FMOD_OPERATOR_NAME, FMODF_OPERATOR_NAME, FMODL_OPERATOR_NAME, FOPEN64_FUNCTION_NAME, FOPEN_FUNCTION_NAME, FORMAT_FUNCTION_NAME, FPCLASSIFY_OPERATOR_NAME, FPRINTF_FUNCTION_NAME, FPUTC_FUNCTION_NAME, FPUTS_FUNCTION_NAME, FPUTWC_FUNCTION_NAME, FPUTWS_FUNCTION_NAME, FREAD_FUNCTION_NAME, FREE_FUNCTION_NAME, FREOPEN64_FUNCTION_NAME, FREOPEN_FUNCTION_NAME, FREXP_OPERATOR_NAME, FSCANF_FUNCTION_NAME, FSEEK_FUNCTION_NAME, FSEEKO64_FUNCTION_NAME, FSEEKO_FUNCTION_NAME, FSETPOS64_FUNCTION_NAME, FSETPOS_FUNCTION_NAME, FSTAT_FUNCTION_NAME, FSYNC_FUNCTION_NAME, FTELL_FUNCTION_NAME, FTELLO64_FUNCTION_NAME, FTELLO_FUNCTION_NAME, FUNC_TO_DECIMAL_OPERATOR_NAME, FWIDE_FUNCTION_NAME, FWPRINTF_FUNCTION_NAME, FWRITE_FUNCTION_NAME, FWSCANF_FUNCTION_NAME, GAMMA_OPERATOR_NAME, GCC_CIMAG_OPERATOR_NAME, GCC_CREAL_OPERATOR_NAME, GCONVERT_OPERATOR_NAME, GCVT_FUNCTION_NAME, GETC_FUNCTION_NAME, GETCHAR_FUNCTION_NAME, GETCWD_FUNCTION_NAME, GETENV_FUNCTION_NAME, GETEXECNAME_FUNCTION_NAME, GETLOGIN_FUNCTION_NAME, GETOPT_FUNCTION_NAME, GETOPT_LONG_FUNCTION_NAME, GETOPT_LONG_ONLY_FUNCTION_NAME, GETPASS_FUNCTION_NAME, GETPASSPHRASE_FUNCTION_NAME, GETPW_FUNCTION_NAME, GETS_FUNCTION_NAME, GETSUBOPT_FUNCTION_NAME, GETTIMEOFDAY_FUNCTION_NAME, GETW_FUNCTION_NAME, GETWC_FUNCTION_NAME, GETWCHAR_FUNCTION_NAME, GRANTPT_FUNCTION_NAME, GREATER_OR_EQUAL_OPERATOR_NAME, GREATER_THAN_OPERATOR_NAME, hash_string, hash_table_make(), HYPOT_OPERATOR_NAME, HYPOTF_OPERATOR_NAME, HYPOTL_OPERATOR_NAME, IABS_OPERATOR_NAME, IAND_OPERATOR_NAME, IBCLR_OPERATOR_NAME, IBITS_OPERATOR_NAME, IBSET_OPERATOR_NAME, IDIM_OPERATOR_NAME, IDINT_GENERIC_CONVERSION_NAME, IDNINT_CONVERSION_NAME, IEOR_OPERATOR_NAME, IFIX_GENERIC_CONVERSION_NAME, ILOGB_OPERATOR_NAME, ILOGBF_OPERATOR_NAME, ILOGBL_OPERATOR_NAME, IMA_OPERATOR_NAME, IMAXABS_FUNCTION_NAME, IMAXDIV_FUNCTION_NAME, IMPLIED_COMPLEX_NAME, IMPLIED_DCOMPLEX_NAME, IMPLIED_DO_NAME, IMS_OPERATOR_NAME, INDEX_OPERATOR_NAME, INITSTATE_FUNCTION_NAME, INQUIRE_FUNCTION_NAME, INT_GENERIC_CONVERSION_NAME, INT_TO_CHAR_CONVERSION_NAME, integer_to_integer_type(), integer_to_logical_type(), integer_to_overloaded_type(), integer_to_real_type(), integer_to_void_type(), intrinsic_type_descriptor_mapping, INVERSE_OPERATOR_NAME, IOCTL_FUNCTION_NAME, IOR_OPERATOR_NAME, ISALNUM_OPERATOR_NAME, ISALPHA_OPERATOR_NAME, ISASCII_OPERATOR_NAME, ISATTY_FUNCTION_NAME, ISBLANK_OPERATOR_NAME, ISCNTRL_OPERATOR_NAME, ISDIGIT_OPERATOR_NAME, ISFINITE_OPERATOR_NAME, ISGRAPH_OPERATOR_NAME, ISGREATER_OPERATOR_NAME, ISGREATEREQUAL_OPERATOR_NAME, ISHFT_OPERATOR_NAME, ISHFTC_OPERATOR_NAME, ISIGN_OPERATOR_NAME, ISINF_OPERATOR_NAME, ISLESS_OPERATOR_NAME, ISLESSEQUAL_OPERATOR_NAME, ISLESSGREATER_OPERATOR_NAME, ISLOWER_OPERATOR_NAME, ISNAN_OPERATOR_NAME, ISNANF_OPERATOR_NAME, ISNANL_OPERATOR_NAME, ISNORMAL_OPERATOR_NAME, ISOC99_FSCANF_FUNCTION_NAME, ISOC99_SCANF_FUNCTION_NAME, ISOC99_SSCANF_FUNCTION_NAME, ISOC99_VFSCANF_FUNCTION_NAME, ISOC99_VSCANF_FUNCTION_NAME, ISOC99_VSSCANF_FUNCTION_NAME, ISPRINT_OPERATOR_NAME, ISPUNCT_OPERATOR_NAME, ISSPACE_OPERATOR_NAME, ISUNORDERED_OPERATOR_NAME, ISUPPER_OPERATOR_NAME, ISWALNUM_OPERATOR_NAME, ISWALPHA_OPERATOR_NAME, ISWBLANK_OPERATOR_NAME, ISWCNTRL_OPERATOR_NAME, ISWCTYPE_OPERATOR_NAME, ISWDIGIT_OPERATOR_NAME, ISWGRAPH_OPERATOR_NAME, ISWLOWER_OPERATOR_NAME, ISWPRINT_OPERATOR_NAME, ISWPUNCT_OPERATOR_NAME, ISWSPACE_OPERATOR_NAME, ISWUPPER_OPERATOR_NAME, ISWXDIGIT_OPERATOR_NAME, ISXDIGIT_OPERATOR_NAME, J0_OPERATOR_NAME, J1_OPERATOR_NAME, JN_OPERATOR_NAME, JRAND48_FUNCTION_NAME, LABS_FUNCTION_NAME, LCONG48_FUNCTION_NAME, LDEXP_OPERATOR_NAME, LDEXPF_OPERATOR_NAME, LDEXPL_OPERATOR_NAME, LDIV_FUNCTION_NAME, LEFT_SHIFT_OPERATOR_NAME, LEFT_SHIFT_UPDATE_OPERATOR_NAME, LENGTH_OPERATOR_NAME, LESS_OR_EQUAL_OPERATOR_NAME, LESS_THAN_OPERATOR_NAME, LGAMMA_OPERATOR_NAME, LGAMMAF_OPERATOR_NAME, LGAMMAL_OPERATOR_NAME, LGE_OPERATOR_NAME, LGT_OPERATOR_NAME, LINK_FUNCTION_NAME, LIST_DIRECTED_FORMAT_NAME, LLABS_FUNCTION_NAME, LLDIV_FUNCTION_NAME, LLE_OPERATOR_NAME, LLRINT_OPERATOR_NAME, LLRINTF_OPERATOR_NAME, LLRINTL_OPERATOR_NAME, LLROUND_OPERATOR_NAME, LLROUNDF_OPERATOR_NAME, LLROUNDL_OPERATOR_NAME, LLT_OPERATOR_NAME, LLTOSTR_FUNCTION_NAME, LOCALTIME_FUNCTION_NAME, LOG10_OPERATOR_NAME, LOG10F_OPERATOR_NAME, LOG10L_OPERATOR_NAME, LOG1P_OPERATOR_NAME, LOG1PF_OPERATOR_NAME, LOG1PL_OPERATOR_NAME, LOG2_OPERATOR_NAME, LOG2F_OPERATOR_NAME, LOG2L_OPERATOR_NAME, LOG_OPERATOR_NAME, LOGB_OPERATOR_NAME, LOGBF_OPERATOR_NAME, LOGBL_OPERATOR_NAME, LOGF_OPERATOR_NAME, logical_to_logical_type(), LOGL_OPERATOR_NAME, longdouble_to_integer_type(), longdouble_to_longdouble_type(), longdouble_to_longinteger_type(), longdouble_to_longlonginteger_type(), longdoublecomplex_to_longdouble_type(), longdoublecomplex_to_longdoublecomplex_type(), longinteger_to_longinteger_type(), longinteger_to_overloaded_type(), longlonginteger_to_longlonginteger_type(), longlonginteger_to_overloaded_type(), LRAND48_FUNCTION_NAME, LRINT_OPERATOR_NAME, LRINTF_OPERATOR_NAME, LRINTL_OPERATOR_NAME, LROUND_OPERATOR_NAME, LROUNDF_OPERATOR_NAME, LROUNDL_OPERATOR_NAME, LSTAT_FUNCTION_NAME, MALLOC_FUNCTION_NAME, MATHERR_OPERATOR_NAME, MAX0_OPERATOR_NAME, MAX1_OPERATOR_NAME, MAX_OPERATOR_NAME, MBLEN_FUNCTION_NAME, MBRLEN_FUNCTION_NAME, MBRTOWC_FUNCTION_NAME, MBSINIT_FUNCTION_NAME, MBSRTOWCS_FUNCTION_NAME, MBSTOWCS_FUNCTION_NAME, MBTOWC_FUNCTION_NAME, MEMALIGN_FUNCTION_NAME, MEMCHR_FUNCTION_NAME, MEMCMP_FUNCTION_NAME, MEMCPY_FUNCTION_NAME, MEMMOVE_FUNCTION_NAME, MEMSET_FUNCTION_NAME, MIN0_OPERATOR_NAME, MIN1_OPERATOR_NAME, MIN_OPERATOR_NAME, MINUS_C_OPERATOR_NAME, MINUS_OPERATOR_NAME, MINUS_UPDATE_OPERATOR_NAME, MKSTEMP64_FUNCTION_NAME, MKSTEMP_FUNCTION_NAME, MKTEMP_FUNCTION_NAME, MODF_OPERATOR_NAME, MODFF_OPERATOR_NAME, MODULO_OPERATOR_NAME, MODULO_UPDATE_OPERATOR_NAME, MPI_BARRIER_FUNCTION_NAME, MPI_BSEND_FUNCTION_NAME, MPI_COMM_RANK_FUNCTION_NAME, MPI_COMM_SIZE_FUNCTION_NAME, MPI_FINALIZE_FUNCTION_NAME, MPI_IBSEND_FUNCTION_NAME, MPI_INIT_FUNCTION_NAME, MPI_IRECV_FUNCTION_NAME, MPI_IRSEND_FUNCTION_NAME, MPI_ISEND_FUNCTION_NAME, MPI_ISSEND_FUNCTION_NAME, MPI_RECV_FUNCTION_NAME, MPI_RSEND_FUNCTION_NAME, MPI_SEND_FUNCTION_NAME, MPI_SENDRECV_FUNCTION_NAME, MPI_SSEND_FUNCTION_NAME, MRAND48_FUNCTION_NAME, MULTIPLY_OPERATOR_NAME, MULTIPLY_UPDATE_OPERATOR_NAME, MVBITS_OPERATOR_NAME, IntrinsicDescriptor::name, NAN_OPERATOR_NAME, NANF_OPERATOR_NAME, NANL_OPERATOR_NAME, NANOSLEEP_FUNCTION_NAME, NEARBYINT_OPERATOR_NAME, NEARBYINTF_OPERATOR_NAME, NEARBYINTL_OPERATOR_NAME, NEXTAFTER_OPERATOR_NAME, NEXTAFTERF_OPERATOR_NAME, NEXTAFTERL_OPERATOR_NAME, NEXTTOWARD_OPERATOR_NAME, NEXTTOWARDF_OPERATOR_NAME, NEXTTOWARDL_OPERATOR_NAME, NINT_CONVERSION_NAME, no_typing(), NON_EQUAL_OPERATOR_NAME, NON_EQUIV_OPERATOR_NAME, NOT_OPERATOR_NAME, NRAND48_FUNCTION_NAME, OMP_FOR_FUNCTION_NAME, OMP_IF_FUNCTION_NAME, OMP_OMP_FUNCTION_NAME, OMP_PARALLEL_FUNCTION_NAME, OMP_PRIVATE_FUNCTION_NAME, OMP_REDUCTION_FUNCTION_NAME, OPEN64_FUNCTION_NAME, OPEN_FUNCTION_NAME, OR_OPERATOR_NAME, overloaded_to_complex_type(), overloaded_to_double_type(), overloaded_to_doublecomplex_type(), overloaded_to_integer_type(), overloaded_to_logical_type(), overloaded_to_longdouble_type(), overloaded_to_real_type(), overloaded_to_void_type(), PAUSE_FUNCTION_NAME, PCLOSE_FUNCTION_NAME, PERROR_FUNCTION_NAME, PIPS_C_DIV_OPERATOR_NAME, PIPS_C_MAX_OPERATOR_NAME, PIPS_C_MIN_OPERATOR_NAME, PIPS_IO_BARRIER_OPERATOR_NAME, PIPS_MEMORY_BARRIER_OPERATOR_NAME, PLUS_C_OPERATOR_NAME, PLUS_OPERATOR_NAME, PLUS_UPDATE_OPERATOR_NAME, POINT_TO_OPERATOR_NAME, POPEN_FUNCTION_NAME, POSIX_MEMALIGN_FUNCTION_NAME, POST_DECREMENT_OPERATOR_NAME, POST_INCREMENT_OPERATOR_NAME, POW_OPERATOR_NAME, POWER_OPERATOR_NAME, POWF_OPERATOR_NAME, POWL_OPERATOR_NAME, PRE_DECREMENT_OPERATOR_NAME, PRE_INCREMENT_OPERATOR_NAME, PRINTF_FUNCTION_NAME, PSELECT_FUNCTION_NAME, PTSNAME_FUNCTION_NAME, PUTC_FUNCTION_NAME, PUTCHAR_FUNCTION_NAME, PUTENV_FUNCTION_NAME, PUTS_FUNCTION_NAME, PUTW_FUNCTION_NAME, PUTWC_FUNCTION_NAME, PUTWCHAR_FUNCTION_NAME, QECONVERT_OPERATOR_NAME, QECVT_FUNCTION_NAME, QFCONVERT_OPERATOR_NAME, QFCVT_FUNCTION_NAME, QGCONVERT_OPERATOR_NAME, QGCVT_FUNCTION_NAME, QSORT_FUNCTION_NAME, QUADRUPLE_TO_DECIMAL_OPERATOR_NAME, RAISE_FUNCTION_NAME, RAND_FUNCTION_NAME, RANDOM_FUNCTION_NAME, READ_FUNCTION_NAME, REAL_GENERIC_CONVERSION_NAME, REAL_MODULO_OPERATOR_NAME, real_to_double_type(), real_to_integer_type(), real_to_longinteger_type(), real_to_longlonginteger_type(), real_to_real_type(), REALLOC_FUNCTION_NAME, REALPATH_FUNCTION_NAME, RECV_FUNCTION_NAME, register_intrinsic_type_descriptor(), REMAINDER_OPERATOR_NAME, REMAINDERF_OPERATOR_NAME, REMAINDERL_OPERATOR_NAME, REMOVE_FUNCTION_NAME, RENAME_FUNCTION_NAME, REPEAT_VALUE_NAME, RETURN_FUNCTION_NAME, REWIND_FUNCTION_NAME, RIGHT_SHIFT_OPERATOR_NAME, RIGHT_SHIFT_UPDATE_OPERATOR_NAME, RINT_OPERATOR_NAME, RINTF_OPERATOR_NAME, RINTL_OPERATOR_NAME, ROUND_OPERATOR_NAME, ROUNDF_OPERATOR_NAME, ROUNDL_OPERATOR_NAME, SCALB_OPERATOR_NAME, SCALBLN_OPERATOR_NAME, SCALBLNF_OPERATOR_NAME, SCALBLNL_OPERATOR_NAME, SCALBN_OPERATOR_NAME, SCALBNF_OPERATOR_NAME, SCALBNL_OPERATOR_NAME, SCANF_FUNCTION_NAME, SECOND_FUNCTION_NAME, SECONVERT_OPERATOR_NAME, SEED48_FUNCTION_NAME, SELECT_FUNCTION_NAME, SEND_FUNCTION_NAME, set_belong_p(), SETBUF_FUNCTION_NAME, SETBUFFER_FUNCTION_NAME, SETKEY_FUNCTION_NAME, SETLINEBUF_FUNCTION_NAME, SETLOCALE_FUNCTION_NAME, SETSTATE_FUNCTION_NAME, SETVBUF_FUNCTION_NAME, SFCONVERT_OPERATOR_NAME, SGCONVERT_OPERATOR_NAME, SIGFPE_OPERATOR_NAME, SIGN_OPERATOR_NAME, SIGNAL_OPERATOR_NAME, SIGNBIT_OPERATOR_NAME, SIGNIFICAND_OPERATOR_NAME, simplification_complex(), simplification_dcomplex(), simplification_double(), simplification_int(), simplification_real(), SIN_OPERATOR_NAME, SINF_OPERATOR_NAME, SINGLE_TO_DECIMAL_OPERATOR_NAME, SINH_OPERATOR_NAME, SINHF_OPERATOR_NAME, SINHL_OPERATOR_NAME, SINL_OPERATOR_NAME, SNGL_GENERIC_CONVERSION_NAME, SNPRINTF_FUNCTION_NAME, SPRINTF_FUNCTION_NAME, SQRT_OPERATOR_NAME, SQRTF_OPERATOR_NAME, SQRTL_OPERATOR_NAME, SRAND48_FUNCTION_NAME, SRAND_FUNCTION_NAME, SRANDOM_FUNCTION_NAME, SSCANF_FUNCTION_NAME, STAT_FUNCTION_NAME, statement_with_at_most_one_expression_integer(), statement_with_at_most_one_integer_or_character(), statement_without_argument(), STATIC_INITIALIZATION_FUNCTION_NAME, STOP_FUNCTION_NAME, STRCAT_FUNCTION_NAME, STRCHR_FUNCTION_NAME, STRCMP_FUNCTION_NAME, STRCOLL_FUNCTION_NAME, STRCPY_FUNCTION_NAME, STRCSPN_FUNCTION_NAME, STRDUP_FUNCTION_NAME, STRERROR_FUNCTION_NAME, STRERROR_R_FUNCTION_NAME, STRING_TO_DECIMAL_OPERATOR_NAME, STRLEN_FUNCTION_NAME, STRNCAT_FUNCTION_NAME, STRNCMP_FUNCTION_NAME, STRNCPY_FUNCTION_NAME, STRPBRK_FUNCTION_NAME, STRRCHR_FUNCTION_NAME, STRSPN_FUNCTION_NAME, STRSTR_FUNCTION_NAME, STRTOD_FUNCTION_NAME, STRTOF_FUNCTION_NAME, STRTOK_FUNCTION_NAME, STRTOL_FUNCTION_NAME, STRTOLD_FUNCTION_NAME, STRTOLL_FUNCTION_NAME, STRTOUL_FUNCTION_NAME, STRTOULL_FUNCTION_NAME, STRXFRM_FUNCTION_NAME, SUBSTRING_FUNCTION_NAME, substring_type(), SWAB_FUNCTION_NAME, switch_specific_abs(), switch_specific_acos(), switch_specific_aint(), switch_specific_anint(), switch_specific_asin(), switch_specific_atan(), switch_specific_atan2(), switch_specific_cmplx(), switch_specific_cos(), switch_specific_cosh(), switch_specific_dcmplx(), switch_specific_dim(), switch_specific_exp(), switch_specific_log(), switch_specific_log10(), switch_specific_max(), switch_specific_min(), switch_specific_mod(), switch_specific_nint(), switch_specific_sign(), switch_specific_sin(), switch_specific_sinh(), switch_specific_sqrt(), switch_specific_tan(), switch_specific_tanh(), SWPRINTF_FUNCTION_NAME, SWSCANF_FUNCTION_NAME, SYMLINK_FUNCTION_NAME, SYSTEM_FUNCTION_NAME, TAN_OPERATOR_NAME, TANF_OPERATOR_NAME, TANH_OPERATOR_NAME, TANHF_OPERATOR_NAME, TANHL_OPERATOR_NAME, TANL_OPERATOR_NAME, TEMPNAM_FUNCTION_NAME, TGAMMA_OPERATOR_NAME, TGAMMAF_OPERATOR_NAME, TIME_FUNCTION_NAME, TMPFILE64_FUNCTION_NAME, TMPFILE_FUNCTION_NAME, TMPNAM_FUNCTION_NAME, TOASCII_OPERATOR_NAME, TOLOWER_OPERATOR_NAME, TOUPPER_OPERATOR_NAME, TOWCTRANS_OPERATOR_NAME, TOWLOWER_OPERATOR_NAME, TOWUPPER_OPERATOR_NAME, TRUNC_OPERATOR_NAME, TRUNCF_OPERATOR_NAME, TRUNCL_OPERATOR_NAME, TTYNAME_FUNCTION_NAME, TTYSLOT_FUNCTION_NAME, typing_arithmetic_operator(), typing_assign_substring(), typing_buffer_inout(), typing_concat_operator(), typing_function_char_to_int(), typing_function_char_to_logical(), typing_function_complex_to_complex(), typing_function_complex_to_real(), typing_function_constant_complex(), typing_function_constant_dcomplex(), typing_function_conversion_to_complex(), typing_function_conversion_to_dcomplex(), typing_function_conversion_to_double(), typing_function_conversion_to_integer(), typing_function_conversion_to_real(), typing_function_dcomplex_to_dcomplex(), typing_function_dcomplex_to_double(), typing_function_double_to_double(), typing_function_double_to_int(), typing_function_double_to_longint(), typing_function_double_to_longlongint(), typing_function_format_name(), typing_function_int_to_char(), typing_function_int_to_int(), typing_function_int_to_logical(), typing_function_int_to_real(), typing_function_IntegerRealDouble_to_IntegerRealDouble(), typing_function_IntegerRealDoubleComplex_to_IntegerRealDoubleReal(), typing_function_longdcomplex_to_longdcomplex(), typing_function_longdcomplex_to_longdouble(), typing_function_longdouble_to_int(), typing_function_longdouble_to_longdouble(), typing_function_longdouble_to_longint(), typing_function_longdouble_to_longlongint(), typing_function_longint_to_longint(), typing_function_longlongint_to_longlongint(), typing_function_overloaded(), typing_function_real_to_double(), typing_function_real_to_int(), typing_function_real_to_longint(), typing_function_real_to_longlongint(), typing_function_real_to_real(), typing_function_RealDouble_to_Integer(), typing_function_RealDouble_to_RealDouble(), typing_function_RealDoubleComplex_to_RealDoubleComplex(), typing_implied_do(), typing_logical_operator(), typing_of_assign(), typing_power_operator(), typing_relational_operator(), typing_substring(), ULLTOSTR_FUNCTION_NAME, UNARY_MINUS_OPERATOR_NAME, UNARY_PLUS_OPERATOR_NAME, UNBOUNDED_DIMENSION_NAME, UNGETC_FUNCTION_NAME, UNGETWC_FUNCTION_NAME, UNLINK_FUNCTION_NAME, UNLOCKPT_FUNCTION_NAME, unsigned_integer_to_void_pointer_type(), USLEEP_FUNCTION_NAME, VALLOC_FUNCTION_NAME, VERR_FUNCTION_NAME, VERRX_FUNCTION_NAME, VFPRINTF_FUNCTION_NAME, VFSCANF_FUNCTION_NAME, VFWPRINTF_FUNCTION_NAME, VFWSCANF_FUNCTION_NAME, void_to_integer_type(), void_to_overloaded_type(), void_to_void_to_int_pointer_type(), void_to_void_type(), VPRINTF_FUNCTION_NAME, VSCANF_FUNCTION_NAME, VSNPRINTF_FUNCTION_NAME, VSPRINTF_FUNCTION_NAME, VSSCANF_FUNCTION_NAME, VSWPRINTF_FUNCTION_NAME, VSWSCANF_FUNCTION_NAME, VWARN_FUNCTION_NAME, VWARNX_FUNCTION_NAME, VWPRINTF_FUNCTION_NAME, VWSCANF_FUNCTION_NAME, WARN_FUNCTION_NAME, WARNX_FUNCTION_NAME, WCRTOMB_FUNCTION_NAME, WCSCAT_FUNCTION_NAME, WCSCHR_FUNCTION_NAME, WCSCMP_FUNCTION_NAME, WCSCOLL_FUNCTION_NAME, WCSCPY_FUNCTION_NAME, WCSCSPN_FUNCTION_NAME, WCSFTIME_FUNCTION_NAME, WCSLEN_FUNCTION_NAME, WCSNCAT_FUNCTION_NAME, WCSNCMP_FUNCTION_NAME, WCSNCPY_FUNCTION_NAME, WCSPBRK_FUNCTION_NAME, WCSRCHR_FUNCTION_NAME, WCSRTOMBS_FUNCTION_NAME, WCSSPN_FUNCTION_NAME, WCSSTR_FUNCTION_NAME, WCSTOD_FUNCTION_NAME, WCSTOF_FUNCTION_NAME, WCSTOK_FUNCTION_NAME, WCSTOL_FUNCTION_NAME, WCSTOLD_FUNCTION_NAME, WCSTOLL_FUNCTION_NAME, WCSTOMBS_FUNCTION_NAME, WCSTOUL_FUNCTION_NAME, WCSTOULL_FUNCTION_NAME, WCSXFRM_FUNCTION_NAME, WCTOB_FUNCTION_NAME, WCTOMB_FUNCTION_NAME, WCTRANS_OPERATOR_NAME, WCTYPE_OPERATOR_NAME, WMEMCHR_FUNCTION_NAME, WMEMCMP_FUNCTION_NAME, WMEMCPY_FUNCTION_NAME, WMEMMOVE_FUNCTION_NAME, WMEMSET_FUNCTION_NAME, WPRINTF_FUNCTION_NAME, WRITE_FUNCTION_NAME, WSCANF_FUNCTION_NAME, Y0_OPERATOR_NAME, Y1_OPERATOR_NAME, and YN_OPERATOR_NAME.

Referenced by bootstrap().

Here is the caller graph for this function:

FindOrMakeDefaultIntrinsic()

entity FindOrMakeDefaultIntrinsic	(	string	name,
		int	arity
	)

Create a default intrinsic.

Useful to create on-the-fly intrinsics.

It creates an intrinsic with a default type, that is with overload parameter and return types.

Parameters

name	is the name of the intrinsic
n	is the number of argument

Returns

the entity of the intrinsic

It seems it has been previously created:

Parameters

name	ame
arity	rity

Definition at line 4397 of file bootstrap.c.

{
  entity e = FindEntity(TOP_LEVEL_MODULE_NAME, name);
  if (!entity_undefined_p(e))
    /* It seems it has been previously created: */
    return e;
 
  return MakeIntrinsic(name, arity, default_intrinsic_type);
}

References default_intrinsic_type(), entity_undefined_p, FindEntity(), MakeIntrinsic(), and TOP_LEVEL_MODULE_NAME.

Here is the call graph for this function:

FindOrMakeIntrinsic()

entity FindOrMakeIntrinsic	(	string	name,
		int	arity,
		type(*)(int)	intrinsic_type
	)

This function creates an entity that represents an intrinsic function, if the entity does not already exist.

Fortran operators and basic statements are intrinsic functions.

An intrinsic function has a rom storage, an unknown initial value and a functional type whose result and arguments have an overloaded basic type. The number of arguments is given by the IntrinsicTypeDescriptorTable data structure.

Parameters

name	ame
arity	rity

Definition at line 4371 of file bootstrap.c.

{
    entity e = FindEntity(TOP_LEVEL_MODULE_NAME, name);
 
    if (entity_undefined_p(e)) {
        e = MakeIntrinsic(name, arity, intrinsic_type);
    }
 
    return e;
}

References entity_undefined_p, FindEntity(), MakeIntrinsic(), and TOP_LEVEL_MODULE_NAME.

Referenced by register_intrinsic_type_descriptor().

Here is the call graph for this function:

Here is the caller graph for this function:

get_switch_name_function_for_intrinsic()

switch_name_function get_switch_name_function_for_intrinsic

(

const char *

name

)

Parameters

name

ame

Definition at line 4338 of file bootstrap.c.

{
    return ((IntrinsicDescriptor *) hash_get(intrinsic_type_descriptor_mapping, name))->name_function;
}

References hash_get(), and intrinsic_type_descriptor_mapping.

Referenced by type_this_call().

Here is the call graph for this function:

Here is the caller graph for this function:

get_typing_function_for_intrinsic()

typing_function_t get_typing_function_for_intrinsic

(

const char *

name

)

Parameters

name

ame

Definition at line 4330 of file bootstrap.c.

{
    return ((IntrinsicDescriptor *) hash_get(intrinsic_type_descriptor_mapping, name))->type_function;
}

References hash_get(), and intrinsic_type_descriptor_mapping.

Referenced by type_this_call(), and type_this_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_cast()

expression insert_cast	(	basic	cast,
		basic	from,
		expression	exp,
		type_context_p	context
	)

Function in type_checker.c.

If exp is a constant -> Convert it e.g: 5.9 -> 5 (REAL -> INT)

If not

Count the number of conversions

Parameters

from	rom
exp	xp
context	ontext

Definition at line 1567 of file bootstrap.c.

{
  call c;
  syntax s;
  entity cast_function;
  expression exp_constant;
 
  s = expression_syntax(exp);
 
  /* If exp is a constant -> Convert it
   * e.g: 5.9 -> 5 (REAL -> INT)
   */
  if ((exp_constant = cast_constant(exp, cast, context)) != NULL)
  {
    return exp_constant;
  }
 
  /* If not */
  cast_function = get_cast_function_for_basic(cast, from);
  if (cast_function == NULL)
  {
    pips_internal_error("Cast function is not verified!");
  }
  if (cast_function == entity_undefined)
  {
    pips_internal_error("Can not convert to LOGICAL!");
  }
  c = make_call(cast_function, CONS(EXPRESSION, exp, NIL));
  s = make_syntax(is_syntax_call, c);
 
  /* Count the number of conversions */
  context->number_of_conversion++;
 
  return make_expression(s, normalized_undefined);
}

References cast_constant(), CONS, entity_undefined, exp, EXPRESSION, expression_syntax, get_cast_function_for_basic(), is_syntax_call, make_call(), make_expression(), make_syntax(), NIL, normalized_undefined, and pips_internal_error.

Referenced by check_this_reference(), type_loop_range(), type_this_entity_if_needed(), typing_arguments(), typing_of_assign(), and typing_power_operator().

Here is the call graph for this function:

Here is the caller graph for this function:

integer_to_overloaded_type()

type integer_to_overloaded_type

(

int

n

)

Definition at line 4222 of file bootstrap.c.

{
  type t = type_undefined;
  functional ft = functional_undefined;
 
  ft = make_functional(NIL, MakeOverloadedResult());
  t = make_type(is_type_functional, ft);
 
  functional_parameters(ft) =
    make_parameter_list(n, MakeIntegerParameter);
  return t;
}

References functional_parameters, functional_undefined, is_type_functional, make_functional(), make_parameter_list(), make_type(), MakeIntegerParameter(), MakeOverloadedResult(), NIL, and type_undefined.

Referenced by CreateIntrinsics().

Here is the call graph for this function:

Here is the caller graph for this function:

integer_to_void_type()

type integer_to_void_type

(

int

n

)

Definition at line 4264 of file bootstrap.c.

{
  type t = type_undefined;
  functional ft = functional_undefined;
 
  ft = make_functional(NIL, make_type_void(NIL));
  t = make_type(is_type_functional, ft);
 
  functional_parameters(ft) =
    make_parameter_list(n, MakeIntegerParameter);
  return t;
}

References functional_parameters, functional_undefined, is_type_functional, make_functional(), make_parameter_list(), make_type(), make_type_void(), MakeIntegerParameter(), NIL, and type_undefined.

Referenced by CreateIntrinsics().

Here is the call graph for this function:

Here is the caller graph for this function:

longinteger_to_overloaded_type()

type longinteger_to_overloaded_type

(

int

n

)

MB.

Definition at line 4236 of file bootstrap.c.

{
  type t = type_undefined;
  functional ft = functional_undefined;
 
  ft = make_functional(NIL, MakeOverloadedResult());
  t = make_type(is_type_functional, ft);
 
  functional_parameters(ft) =
    make_parameter_list(n, MakeLongIntegerParameter);
  return t;
}

References functional_parameters, functional_undefined, is_type_functional, make_functional(), make_parameter_list(), make_type(), MakeLongIntegerParameter(), MakeOverloadedResult(), NIL, and type_undefined.

Referenced by CreateIntrinsics().

Here is the call graph for this function:

Here is the caller graph for this function:

longlonginteger_to_overloaded_type()

type longlonginteger_to_overloaded_type

(

int

n

)

MB.

Definition at line 4250 of file bootstrap.c.

{
  type t = type_undefined;
  functional ft = functional_undefined;
 
  ft = make_functional(NIL, MakeOverloadedResult());
  t = make_type(is_type_functional, ft);
 
  functional_parameters(ft) =
    make_parameter_list(n, MakeLongLongIntegerParameter);
  return t;
}

References functional_parameters, functional_undefined, is_type_functional, make_functional(), make_parameter_list(), make_type(), MakeLongLongIntegerParameter(), MakeOverloadedResult(), NIL, and type_undefined.

Referenced by CreateIntrinsics().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeFileName()

string MakeFileName	(	char *	prefix,
		char *	base,
		char *	suffix
	)

Parameters

prefix	refix
base	ase
suffix	uffix

Definition at line 5687 of file bootstrap.c.

{
  char *s;
 
  s = (char*) malloc(strlen(prefix)+strlen(base)+strlen(suffix)+1);
 
  strcpy(s, prefix);
  strcat(s, base);
  strcat(s, suffix);
 
  return(s);
}

References base, malloc(), and prefix.

Here is the call graph for this function:

MakeIoFileArray()

entity MakeIoFileArray

(

entity

f

)

This array is pointed by FILE * pointers returned or used by fopen, fclose,...

. The argument f must be the intrinsic fopen returning a FILE * or another function also returning a FILE *. So we do not have to synthesize the type FILE.

FI: this initialization is usually performed in bootstrap.c, but it is easier to do it here because the IO_FILE type does not have to be built from scratch.

Definition at line 5705 of file bootstrap.c.

{
  entity io_files = FindOrCreateEntity(IO_EFFECTS_PACKAGE_NAME, IO_EFFECTS_IO_FILE_NAME);
 
  if(type_undefined_p(entity_type(io_files))) {
    /* FI: this initialization is usually performed in
       bootstrap.c, but it is easier to do it here because the
       IO_FILE type does not have to be built from scratch. */
    type rt = functional_result(type_functional(entity_type(f)));
    type ct = copy_type(type_to_pointed_type(rt)); // FI: no risk with typedef
    pips_assert("ct is a scalar type",
                ENDP(variable_dimensions(type_variable(ct))));
    variable_dimensions(type_variable(ct)) =
      CONS(DIMENSION,
           make_dimension(int_to_expression(0),
                          /*
                            MakeNullaryCall
                            (CreateIntrinsic(UNBOUNDED_DIMENSION_NAME))
                          */
                          int_to_expression(2000),
                          NIL),
           NIL);
    entity_type(io_files) = ct;
    entity ent = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,
                                    IO_EFFECTS_PACKAGE_NAME);
    entity_storage(io_files) =
      make_storage(is_storage_ram,
                   make_ram(ent,
                            FindEntity(IO_EFFECTS_PACKAGE_NAME,
                                       STATIC_AREA_LOCAL_NAME),
                            0, NIL));
    entity_initial(io_files) = make_value(is_value_unknown, UU);
  }
  return io_files;
}

References CONS, copy_type(), DIMENSION, ENDP, entity_initial, entity_storage, entity_type, f(), FindEntity(), FindOrCreateEntity(), functional_result, int_to_expression(), IO_EFFECTS_IO_FILE_NAME, IO_EFFECTS_PACKAGE_NAME, is_storage_ram, is_value_unknown, make_dimension(), make_ram(), make_storage(), make_value(), NIL, pips_assert, STATIC_AREA_LOCAL_NAME, TOP_LEVEL_MODULE_NAME, type_functional, type_to_pointed_type(), type_undefined_p, type_variable, UU, and variable_dimensions.

Referenced by binary_intrinsic_call_to_points_to_sinks(), and create_stub_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeValueLitteral()

value MakeValueLitteral

(

void

)

Definition at line 5680 of file bootstrap.c.

{
  return(make_value(is_value_constant,
                    make_constant(is_constant_litteral, UU)));
}

References is_constant_litteral, is_value_constant, make_constant(), make_value(), and UU.

Referenced by EvalConstant().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeVoidParameter()

parameter MakeVoidParameter

(

void

)

Definition at line 4199 of file bootstrap.c.

{
  return make_parameter(make_type(is_type_void, UU),
                        make_mode(is_mode_reference, UU),
                        make_dummy_unknown());
}

References is_mode_reference, is_type_void, make_dummy_unknown(), make_mode(), make_parameter(), make_type(), and UU.

Referenced by __attribute__(), and void_to_integer_type().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeVoidResult()

type MakeVoidResult

(

void

)

Move the following functions to ri-util/type.c.

Definition at line 4193 of file bootstrap.c.

{
    return make_type(is_type_void, UU);
}

References is_type_void, make_type(), and UU.

Referenced by overloaded_to_void_type().

Here is the call graph for this function:

Here is the caller graph for this function:

overloaded_to_void_type()

type overloaded_to_void_type

(

int

n

)

Definition at line 4292 of file bootstrap.c.

{
  type t = type_undefined;
  functional ft = functional_undefined;
 
  ft = make_functional(NIL, MakeVoidResult());
  functional_parameters(ft) =
    make_parameter_list(n, MakeOverloadedParameter);
  t = make_type(is_type_functional, ft);
 
  return t;
}

References functional_parameters, functional_undefined, is_type_functional, make_functional(), make_parameter_list(), make_type(), MakeOverloadedParameter(), MakeVoidResult(), NIL, and type_undefined.

Referenced by CreateIntrinsics().

Here is the call graph for this function:

Here is the caller graph for this function:

pointer_to_overloaded_type()

type pointer_to_overloaded_type

(

int

n

)

Definition at line 4208 of file bootstrap.c.

{
  type t = type_undefined;
  functional ft = functional_undefined;
 
  ft = make_functional(NIL, MakeOverloadedResult());
  t = make_type(is_type_functional, ft);
 
  functional_parameters(ft) =
    make_parameter_list(n, MakePointerParameter);
  return t;
}

References functional_parameters, functional_undefined, is_type_functional, make_functional(), make_parameter_list(), make_type(), MakeOverloadedResult(), MakePointerParameter(), NIL, and type_undefined.

Here is the call graph for this function:

register_intrinsic_type_descriptor()

void register_intrinsic_type_descriptor

(

IntrinsicDescriptor *

p

)

This function is called one time (at the very beginning) to create all intrinsic functions.

Definition at line 4411 of file bootstrap.c.

                                                                {
    FindOrMakeIntrinsic(p->name, p->nbargs, p->intrinsic_type);
    hash_put(intrinsic_type_descriptor_mapping,p->name,p);
}

References FindOrMakeIntrinsic(), hash_put(), IntrinsicDescriptor::intrinsic_type, intrinsic_type_descriptor_mapping, IntrinsicDescriptor::name, and IntrinsicDescriptor::nbargs.

Referenced by CreateIntrinsics(), and step_analyse_init().

Here is the call graph for this function:

Here is the caller graph for this function:

type_checker()

bool type_checker

(

const

string

)

Used to check the language

Parameters

string

ame

Definition at line 548 of file type_checker.c.

{
  statement stat;
  debug_on("TYPE_CHECKER_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", name);
 
  /* Used to check the language */
  set_current_module_entity(module_name_to_entity(name));
  stat = (statement) db_get_memory_resource(DBR_CODE, name, true);
  set_current_module_statement(stat);
 
  typing_of_expressions(name, stat);
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, name, stat);
  reset_current_module_statement();
  reset_current_module_entity();
 
  pips_debug(1, "done");
  debug_off();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, module_name_to_entity(), pips_debug, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and typing_of_expressions().

Here is the call graph for this function:

type_loop_range()

void type_loop_range	(	basic	index,
		range	r,
		type_context_p	context
	)

Parameters

index	ndex
context	ontext

Definition at line 1038 of file bootstrap.c.

{
  basic lower, upper, incr;
  lower = GET_TYPE(context->types, range_lower(r));
  upper = GET_TYPE(context->types, range_upper(r));
  incr = GET_TYPE(context->types, range_increment(r));
 
  if(!basic_equal_p(index, lower))
  {
    range_lower(r) = insert_cast(index, lower, range_lower(r), context);
  }
  if(!basic_equal_p(index, upper))
  {
    range_upper(r) = insert_cast(index, upper, range_upper(r), context);
  }
  if(!basic_equal_p(index, incr))
  {
    range_increment(r) = insert_cast(index, incr, range_increment(r), context);
  }
}

References basic_equal_p(), GET_TYPE, insert_cast(), range_increment, range_lower, and range_upper.

Referenced by check_this_loop(), and typing_implied_do().

Here is the call graph for this function:

Here is the caller graph for this function:

typing_of_expressions()

void typing_of_expressions	(	string	name,
		statement	s
	)

Bottom-up typing

Summary

Type checking ...

Parameters

name

ame

Definition at line 526 of file type_checker.c.

{
  type_context_t context;
 
  context.types = hash_table_make(hash_pointer, 0);
  context.stats = stack_make(statement_domain, 0, 0);
  context.number_of_error = 0;
  context.number_of_conversion = 0;
  context.number_of_simplication = 0;
 
  /* Bottom-up typing */
  type_this_chunk((void *) s, &context);
 
  /* Summary */
  put_summary(name, &context);
 
  /* Type checking ... */
  HASH_MAP(st, ba, free_basic(ba), context.types);
  hash_table_free(context.types);
  stack_free(&context.stats);
}

References free_basic(), HASH_MAP, hash_pointer, hash_table_free(), hash_table_make(), put_summary(), stack_free(), stack_make(), statement_domain, context::stats, and type_this_chunk().

Referenced by type_checker().

Here is the call graph for this function:

Here is the caller graph for this function:

void_to_integer_type()

type void_to_integer_type

(

int

n

)

Definition at line 4306 of file bootstrap.c.

{
  type t = type_undefined;
  functional ft = functional_undefined;
 
  ft = make_functional(NIL, MakeIntegerResult());
  functional_parameters(ft) =
    make_parameter_list(n, MakeVoidParameter);
  t = make_type(is_type_functional, ft);
 
  return t;
}

References functional_parameters, functional_undefined, is_type_functional, make_functional(), make_parameter_list(), make_type(), MakeIntegerResult(), MakeVoidParameter(), NIL, and type_undefined.

Referenced by CreateIntrinsics().

Here is the call graph for this function:

Here is the caller graph for this function:

void_to_overloaded_type()

type void_to_overloaded_type

(

int

)

Referenced by CreateIntrinsics().

Here is the caller graph for this function: