type_checker.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "misc.h"
#include "pipsdbm.h"
#include "resources.h"
#include "properties.h"
#include "bootstrap.h"

Include dependency graph for type_checker.c:

Go to the source code of this file.

Macros
#define	GET_TYPE(h, e)   ((basic)hash_get(h, (char*)(e)))
	type of intrinsics stuff... More...
#define	PUT_TYPE(h, e, b)   hash_put(h, (char*)(e), (char*)(b))
#define	CONCAT_OPERATOR_NAME   "//"
	ENTITY It should be added in file "ri-util.h". More...
#define	ENTITY_CONCAT_P(e)   (entity_an_operator_p(e, CONCAT))
#define	ENTITY_EXTERNAL_P(e)   (value_code_p(entity_initial(e)))
#define	ENTITY_INTRINSIC_P(e)   (value_intrinsic_p(entity_initial(e)))
#define	ENTITY_CONVERSION_P(e, name)    (strcmp(entity_local_name(e), name##_GENERIC_CONVERSION_NAME)==0)
#define	ENTITY_CONVERSION_CMPLX_P(e)   ENTITY_CONVERSION_P(e, CMPLX)
#define	ENTITY_CONVERSION_DCMPLX_P(e)   ENTITY_CONVERSION_P(e, DCMPLX)

Functions
static void	type_this_entity_if_needed (entity, type_context_p)
static basic	typing_arguments_of_user_function (call c, type_context_p context)
static basic	type_this_call (expression exp, type_context_p context)
static void	type_this_instruction (instruction i, type_context_p context)
static void	check_this_test (test t, type_context_p context)
static void	check_this_whileloop (whileloop w, type_context_p context)
bool	check_loop_range (range r, hash_table types)
	type_checker.c More...
static void	check_this_loop (loop l, type_context_p context)
static void	type_this_expression (expression e, type_context_p context)
static void	check_this_reference (reference r, type_context_p context)
static bool	stmt_flt (statement s, type_context_p context)
static void	stmt_rwt (statement s, type_context_p context)
static void	type_this_chunk (void *c, type_context_p context)
static void	put_summary (string name, type_context_p context)
void	typing_of_expressions (string name, statement s)
bool	type_checker (const string name)

Macro Definition Documentation

CONCAT_OPERATOR_NAME

#define CONCAT_OPERATOR_NAME   "//"

ENTITY It should be added in file "ri-util.h".

Definition at line 56 of file type_checker.c.

ENTITY_CONCAT_P

#define ENTITY_CONCAT_P

(

e

)

(entity_an_operator_p(e, CONCAT))

Definition at line 57 of file type_checker.c.

ENTITY_CONVERSION_CMPLX_P

#define ENTITY_CONVERSION_CMPLX_P

(

e

)

ENTITY_CONVERSION_P(e, CMPLX)

Definition at line 63 of file type_checker.c.

ENTITY_CONVERSION_DCMPLX_P

#define ENTITY_CONVERSION_DCMPLX_P

(

e

)

ENTITY_CONVERSION_P(e, DCMPLX)

Definition at line 64 of file type_checker.c.

ENTITY_CONVERSION_P

#define ENTITY_CONVERSION_P	(		e,
			name
	)		(strcmp(entity_local_name(e), name##_GENERIC_CONVERSION_NAME)==0)

Definition at line 61 of file type_checker.c.

ENTITY_EXTERNAL_P

#define ENTITY_EXTERNAL_P

(

e

)

(value_code_p(entity_initial(e)))

Definition at line 58 of file type_checker.c.

ENTITY_INTRINSIC_P

#define ENTITY_INTRINSIC_P

(

e

)

(value_intrinsic_p(entity_initial(e)))

Definition at line 59 of file type_checker.c.

GET_TYPE

#define GET_TYPE	(		h,
			e
	)		((basic)hash_get(h, (char*)(e)))

type of intrinsics stuff...

Working with hash_table of basic

Definition at line 50 of file type_checker.c.

PUT_TYPE

#define PUT_TYPE	(		h,
			e,
			b
	)		hash_put(h, (char*)(e), (char*)(b))

Definition at line 51 of file type_checker.c.

Function Documentation

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;
}

Referenced by check_this_loop(), and type_this_expression().

Here is the caller graph for this function:

check_this_loop()

static void check_this_loop ( loop  l, type_context_p  context  )

static

ok for F77, but not in F90?

Definition at line 310 of file type_checker.c.

{
  basic ind = entity_basic(loop_index(l));
 
  /* ok for F77, but not in F90? */
  if (!basic_int_p(ind))
  {
    add_one_line_of_comment((statement) stack_head(context->stats),
                            "Obsolescent non integer loop index '%s'"
                            " (R822 ISO/IEC 1539:1991 (E))",
                            entity_local_name(loop_index(l)));
    context->number_of_error++;
  }
 
  if( !(basic_int_p(ind) || basic_float_p(ind)) )
  {
    add_one_line_of_comment((statement) stack_head(context->stats),
                            "Index '%s' must be Integer, Real or Double!",
                            entity_local_name(loop_index(l)));
    context->number_of_error++;
  }
  else if (!check_loop_range(loop_range(l), context->types))
  {
    add_one_line_of_comment((statement) stack_head(context->stats),
                    "Range of index '%s' must be Integer, Real or Double!",
                            entity_local_name(loop_index(l)));
    context->number_of_error++;
  }
  else
  {
    type_loop_range(ind, loop_range(l), context);
  }
}

References add_one_line_of_comment(), basic_float_p, basic_int_p, check_loop_range(), entity_basic(), entity_local_name(), loop_index, loop_range, stack_head(), context::stats, and type_loop_range().

Referenced by type_this_chunk().

Here is the call graph for this function:

Here is the caller graph for this function:

check_this_reference()

static void check_this_reference ( reference  r, type_context_p  context  )

static

cast expressions to INT if not already an int... ?

??? maybe should update context->types ???

and simplifies!

Definition at line 391 of file type_checker.c.

{
  MAP(EXPRESSION, ind,
  {
    /* cast expressions to INT if not already an int... ? */
    /* ??? maybe should update context->types ??? */
 
    basic b = GET_TYPE(context->types, ind);
    if (!basic_int_p(b))
    {
      basic bint = make_basic_int(4);
      insert_cast(bint, b, ind, context); /* and simplifies! */
      free_basic(bint);
    }
  },
      reference_indices(r));
}

References basic_int_p, EXPRESSION, free_basic(), GET_TYPE, insert_cast(), make_basic_int(), MAP, and reference_indices.

Referenced by type_this_chunk().

Here is the call graph for this function:

Here is the caller graph for this function:

check_this_test()

static void check_this_test ( test  t, type_context_p  context  )

static

Definition at line 262 of file type_checker.c.

{
  basic b = GET_TYPE(context->types, test_condition(t));
  if (!basic_logical_p(b))
  {
    add_one_line_of_comment((statement) stack_head(context->stats),
                            "Test condition must be a logical expression!");
    context->number_of_error++;
  }
}

References add_one_line_of_comment(), basic_logical_p, GET_TYPE, stack_head(), context::stats, and test_condition.

Referenced by type_this_chunk().

Here is the call graph for this function:

Here is the caller graph for this function:

check_this_whileloop()

static void check_this_whileloop ( whileloop  w, type_context_p  context  )

static

Definition at line 274 of file type_checker.c.

{
  basic b = GET_TYPE(context->types, whileloop_condition(w));
  if (!basic_logical_p(b))
  {
    add_one_line_of_comment((statement) stack_head(context->stats),
                            "While condition must be a logical expression!");
    context->number_of_error++;
  }
}

References add_one_line_of_comment(), basic_logical_p, GET_TYPE, stack_head(), context::stats, and whileloop_condition.

Referenced by type_this_chunk().

Here is the call graph for this function:

Here is the caller graph for this function:

put_summary()

static void put_summary ( string  name, type_context_p  context  )

static

Definition at line 477 of file type_checker.c.

{
  user_log("Type Checker Summary\n"
           "\t%d errors found\n"
           "\t%d conversions inserted\n"
           "\t%d simplifications performed\n",
           context->number_of_error,
           context->number_of_conversion,
           context->number_of_simplication);
 
  pips_user_warning("summary of '%s': "
                    "%d errors, %d convertions., %d simplifications\n",
                    name,
                    context->number_of_error,
                    context->number_of_conversion,
                    context->number_of_simplication);
 
  if (name && get_bool_property("TYPE_CHECKER_ADD_SUMMARY"))
  {
    entity module = local_name_to_top_level_entity(name);
    code c;
    char *buf;
 
    pips_assert("entity is a module", entity_module_p(module));
 
    c = value_code(entity_initial(module));
 
    asprintf( &buf,
            "!PIPS TYPER: %d errors, %d conversions, %d simplifications\n",
            context->number_of_error,
            context->number_of_conversion,
            context->number_of_simplication);
 
    if (!code_decls_text(c) || string_undefined_p(code_decls_text(c)))
      code_decls_text(c) = buf;
    else
    {
      string tmp = code_decls_text(c);
      code_decls_text(c) = strdup(concatenate(buf, tmp, NULL));
      free(buf);
      free(tmp);
    }
  }
}

References asprintf, buf, code_decls_text, concatenate(), entity_initial, entity_module_p(), free(), get_bool_property(), local_name_to_top_level_entity(), module, pips_assert, pips_user_warning, strdup(), string_undefined_p, user_log(), and value_code.

Referenced by typing_of_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

stmt_flt()

static bool stmt_flt ( statement  s, type_context_p  context  )

static

Definition at line 410 of file type_checker.c.

{
  stack_push(s, context->stats);
  return true;
}

References stack_push(), and context::stats.

Referenced by type_this_chunk().

Here is the call graph for this function:

Here is the caller graph for this function:

stmt_rwt()

static void stmt_rwt ( statement  s, type_context_p  context  )

static

Definition at line 417 of file type_checker.c.

{
  pips_assert("pop same push", stack_head(context->stats)==s);
  stack_pop(context->stats);
}

References pips_assert, stack_head(), stack_pop(), and context::stats.

Referenced by type_this_chunk().

Here is the call graph for this function:

Here is the caller graph for this function:

type_checker()

bool type_checker

(

const string

name

)

Used to check the language

Parameters

name

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_this_call()

static basic type_this_call ( expression  exp, type_context_p  context  )

static

Labels

Constants

User-defined functions

All intrinsics

Typing intrinsics

Simplification

lazy type entity contents...

Definition at line 148 of file type_checker.c.

{
  typing_function_t dotype;
  switch_name_function simplifier;
  call c = syntax_call(expression_syntax(exp));
  entity function_called = call_function(c);
  basic b;
  b = basic_undefined;
 
  pips_debug(2, "Call to %s; Its type is %s \n", entity_name(function_called),
             type_to_string(entity_type(function_called)));
 
  /* Labels */
  if (entity_label_p(function_called))
  {
    b = make_basic_overloaded();
  }
 
  /* Constants */
  else if (entity_constant_p(function_called))
  {
    b = basic_of_call(c, true, true);
  }
 
  /* User-defined functions */
  else if (ENTITY_EXTERNAL_P(function_called))
  {
    b = typing_arguments_of_user_function(c, context);
  }
 
  /* All intrinsics */
  else if (ENTITY_INTRINSIC_P(function_called))
  {
    /* Typing intrinsics */
    dotype = get_typing_function_for_intrinsic(
                                   entity_local_name(function_called));
    if (dotype != 0)
    {
      b = dotype(c, context);
    }
 
    /* Simplification */
    simplifier = get_switch_name_function_for_intrinsic(
                                   entity_local_name(function_called));
    if (simplifier != 0)
    {
      simplifier(exp, context);
    }
  }
  else if (value_symbolic_p(entity_initial(function_called)))
  {
    /* lazy type entity contents... */
    type_this_entity_if_needed(function_called, context);
    b = GET_TYPE(context->types,
       symbolic_expression(value_symbolic(entity_initial(function_called))));
    b = copy_basic(b);
  }
 
  pips_debug(7, "Call to %s typed as %s\n", entity_name(function_called),
             basic_to_string(b));
 
  return b;
}

References basic_of_call(), basic_to_string(), basic_undefined, call_function, copy_basic(), entity_constant_p, ENTITY_EXTERNAL_P, entity_initial, ENTITY_INTRINSIC_P, entity_label_p(), entity_local_name(), entity_name, entity_type, exp, expression_syntax, get_switch_name_function_for_intrinsic(), GET_TYPE, get_typing_function_for_intrinsic(), make_basic_overloaded(), pips_debug, symbolic_expression, syntax_call, type_this_entity_if_needed(), type_to_string(), typing_arguments_of_user_function(), value_symbolic, and value_symbolic_p.

Referenced by type_this_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

type_this_chunk()

static void type_this_chunk ( void *  c, type_context_p  context  )

static

Definition at line 423 of file type_checker.c.

{
  gen_context_multi_recurse
    (c, context,
     statement_domain, stmt_flt, stmt_rwt,
     instruction_domain, gen_true, type_this_instruction,
     test_domain, gen_true, check_this_test,
     whileloop_domain, gen_true, check_this_whileloop,
     loop_domain, gen_true, check_this_loop,
     expression_domain, gen_true, type_this_expression,
     reference_domain, gen_true, check_this_reference,
     NULL);
}

References check_this_loop(), check_this_reference(), check_this_test(), check_this_whileloop(), expression_domain, gen_context_multi_recurse(), gen_true(), instruction_domain, loop_domain, reference_domain, statement_domain, stmt_flt(), stmt_rwt(), test_domain, type_this_expression(), type_this_instruction(), and whileloop_domain.

Referenced by type_this_entity_if_needed(), and typing_of_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

type_this_entity_if_needed()

static void type_this_entity_if_needed ( entity  e, type_context_p  context  )

static

??? TODO: type->variable->dimensions->dimension->expression

type as "e = s"

Definition at line 437 of file type_checker.c.

{
  value v = entity_initial(e);
 
  /* ??? TODO: type->variable->dimensions->dimension->expression */
 
  if (value_symbolic_p(v))
  {
    symbolic sy = value_symbolic(v);
    expression s = symbolic_expression(sy);
    basic b1, b2;
 
    if (hash_defined_p(context->types, s))
      return;
 
    type_this_chunk((void *) s, context);
 
    /* type as "e = s" */
    b1 = entity_basic(e);
    b2 = GET_TYPE(context->types, s);
 
    if (!basic_compatible_p(b1, b2))
    {
      add_one_line_of_comment((statement) stack_head(context->stats),
                   "%s parameter '%s' definition from incompatible type %s",
                              basic_to_string(b1),
                              entity_local_name(e),
                              basic_to_string(b2));
      context->number_of_error++;
      return;
    }
 
    if (!basic_equal_p(b1, b2))
    {
      symbolic_expression(sy) = insert_cast(b1, b2, s, context);
      PUT_TYPE(context->types, symbolic_expression(sy), copy_basic(b1));
    }
}
}

References add_one_line_of_comment(), b1, b2, basic_compatible_p, basic_equal_p(), basic_to_string(), copy_basic(), entity_basic(), entity_initial, entity_local_name(), GET_TYPE, hash_defined_p(), insert_cast(), PUT_TYPE, stack_head(), context::stats, symbolic_expression, type_this_chunk(), value_symbolic, and value_symbolic_p.

Referenced by type_this_call().

Here is the call graph for this function:

Here is the caller graph for this function:

type_this_expression()

static void type_this_expression ( expression  e, type_context_p  context  )

static

Specify the basic of the expression e

PDSon: For the range alone (not in loop), I only check lower, upper and step, they must be all INT, REAL or DBLE

Push the basic in hash table "types"

Definition at line 349 of file type_checker.c.

{
  syntax s = expression_syntax(e);
  basic b = basic_undefined;
 
  /* Specify the basic of the expression e  */
  switch (syntax_tag(s))
  {
  case is_syntax_call:
    b = type_this_call(e, context);
    break;
 
  case is_syntax_reference:
    b = copy_basic(entity_basic(reference_variable(syntax_reference(s))));
    pips_debug(2,"Reference: %s; Type: %s\n",
               entity_name(reference_variable(syntax_reference(s))),
               basic_to_string(b));
    break;
 
  case is_syntax_range:
    /* PDSon: For the range alone (not in loop),
     * I only check lower, upper and step, they must be all INT, REAL or DBLE
     */
    if (!check_loop_range(syntax_range(s), context->types))
    {
      add_one_line_of_comment((statement)stack_head(context->stats),
                              "Range must be INT, REAL or DBLE!");
      context->number_of_error++;
    }
    break;
 
  default:
    pips_internal_error("unexpected syntax tag (%d)", syntax_tag(s));
  }
 
  /* Push the basic in hash table "types" */
  if (!basic_undefined_p(b))
  {
    PUT_TYPE(context->types, e, b);
  }
}

References add_one_line_of_comment(), basic_to_string(), basic_undefined, basic_undefined_p, check_loop_range(), copy_basic(), entity_basic(), entity_name, expression_syntax, is_syntax_call, is_syntax_range, is_syntax_reference, pips_debug, pips_internal_error, PUT_TYPE, reference_variable, stack_head(), context::stats, syntax_range, syntax_reference, syntax_tag, and type_this_call().

Referenced by type_this_chunk().

Here is the call graph for this function:

Here is the caller graph for this function:

type_this_instruction()

static void type_this_instruction ( instruction  i, type_context_p  context  )

static

type check a SUBROUTINE call.

Count the number of errors

Typing intrinsics: Assignment, control statement, IO statement

Definition at line 217 of file type_checker.c.

{
  basic b1;
  call c;
  typing_function_t dotype;
 
  if (instruction_call_p(i))
  {
    c = instruction_call(i);
    pips_debug(1, "Call to %s; Its type is %s \n",
               entity_name(call_function(c)),
               type_to_string(entity_type(call_function(c))));
 
    /* type check a SUBROUTINE call. */
    if (ENTITY_EXTERNAL_P(call_function(c)))
    {
      b1 = typing_arguments_of_user_function(c, context);
 
      if (!basic_overloaded_p(b1))
      {
        add_one_line_of_comment((statement) stack_head(context->stats),
                                "Ignored %s value returned by '%s'",
                                basic_to_string(b1),
                                entity_local_name(call_function(c)));
        /* Count the number of errors */
        context->number_of_error++;
      }
      free_basic(b1);
 
      return;
    }
 
    /* Typing intrinsics:
     * Assignment, control statement, IO statement
     */
    dotype = get_typing_function_for_intrinsic(
                                   entity_local_name(call_function(c)));
    if (dotype != 0)
    {
      b1 = dotype(c, context);
    }
  }
}

References add_one_line_of_comment(), b1, basic_overloaded_p, basic_to_string(), call_function, ENTITY_EXTERNAL_P, entity_local_name(), entity_name, entity_type, free_basic(), get_typing_function_for_intrinsic(), instruction_call, instruction_call_p, pips_debug, stack_head(), context::stats, type_to_string(), and typing_arguments_of_user_function().

Referenced by type_this_chunk().

Here is the call graph for this function:

Here is the caller graph for this function:

typing_arguments_of_user_function()

static basic typing_arguments_of_user_function ( call  c, type_context_p  context  )

static

Here, parameter is always a variable

Subroutine

Function

Definition at line 75 of file type_checker.c.

{
  list            args = call_arguments(c);
  type            the_tp = entity_type(call_function(c));
  functional      ft = type_functional(the_tp);
  list            params = functional_parameters(ft);
  type            result = functional_result(ft);
  int             na = gen_length(args);
  int             nt = gen_length(params);
  parameter       param;
  basic b, b1;
  int argnumber = 0;
 
  if (na == nt ||
      (nt<=na &&
       type_varargs_p(parameter_type(PARAMETER(CAR(gen_last(params)))))))
  {
    while (args != NIL)
    {
      argnumber++;
      /* Here, parameter is always a variable */
      param = PARAMETER(CAR(params));
      b = variable_basic(type_variable(parameter_type(param)));
      b1 = GET_TYPE(context->types, EXPRESSION(CAR(args)));
      if (!basic_equal_p(b, b1))
      {
        add_one_line_of_comment((statement) stack_head(context->stats),
                                "invalid arg #%d to '%s', %s instead of %s!",
                                argnumber,
                                entity_local_name(call_function(c)),
                                basic_to_string(b1),
                                basic_to_string(b));
        context->number_of_error++;
      }
      args = CDR(args);
      params = CDR(params);
    }
  }
  else if (na < nt)
  {
    add_one_line_of_comment((statement) stack_head(context->stats),
                            "Too few argument(s) to '%s' (%d<%d)!",
                            entity_local_name(call_function(c)), na, nt);
    context->number_of_error++;
  }
  else
  {
    add_one_line_of_comment((statement) stack_head(context->stats),
                            "Too many argument(s) to '%s' (%d>%d)!",
                            entity_local_name(call_function(c)), na, nt);
    context->number_of_error++;
  }
 
  /* Subroutine */
  if (type_void_p(result))
  {
    pips_debug(7, "type of %s is overloaded\n", entity_name(call_function(c)));
    b = make_basic_overloaded();
  }
  /* Function */
  else
  {
    pips_debug(7, "type of %s is a function\n", entity_name(call_function(c)));
    b = copy_basic(variable_basic(type_variable(result)));
  }
  return b;
}

References add_one_line_of_comment(), b1, basic_equal_p(), basic_to_string(), call_arguments, call_function, CAR, CDR, copy_basic(), entity_local_name(), entity_name, entity_type, EXPRESSION, functional_parameters, functional_result, gen_last(), gen_length(), GET_TYPE, make_basic_overloaded(), NIL, PARAMETER, parameter_type, params, pips_debug, stack_head(), context::stats, type_functional, type_varargs_p, type_variable, type_void_p, and variable_basic.

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:

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: