#include "local.h"

Include dependency graph for flint_walk.c:

Macros
#define	FATAL(msg, value) {fprintf(stderr,msg,value);exit(1);}
	This file contains a set of functions defined to walk through the internal representation of a module and chek different things, as the number of arguments, the compatibility of the types of these arguments, ... More...

Functions
void	flint_cons_dimension (list pc)
	The only global variable : the name of the current module. More...

dimension	flint_dimension (dimension d)

call	flint_call (call c)
	This function checks the syntax of a call and recursively. More...

range	flint_range (range r)
	This function verifies that incremented or decremented More...

reference	flint_reference (reference r)
	A reference is used when given a function the address of. More...

void	flint_syntax (syntax s)
	verification of syntaxes More...

void	flint_cons_expression (list pc)
	These two functions operate on the list of expressions More...

void	flint_cons_actual_argument (list pc)

expression	flint_expression (expression e)

loop	flint_loop (loop l)
	Recursive verification of a loop as (range)+(expression) More...

test	flint_test (test t)
	A test is taken as (expression)+(statement)+(statement) More...

instruction	flint_instruction (instruction i)
	Verification of an instruction with branching according More...

void	flint_unstructured (unstructured u)

void	flint_cons_statement (list pc)

statement	flint_statement (statement s)

Variables
statement	flint_current_statement
	cproto-generated files More...

Macro Definition Documentation

◆ FATAL

#define FATAL	(	msg,
		value
	)	{fprintf(stderr,msg,value);exit(1);}

This file contains a set of functions defined to walk through the internal representation of a module and chek different things, as the number of arguments, the compatibility of the types of these arguments, ...

There is one function for each domain. Its basic principle is to walk through the internal representation by recursive calls to functions handling sub-domains.

Laurent Aniort & Fabien Coelho 1992 Print message and exit violently from flint

Definition at line 42 of file flint_walk.c.

Function Documentation

◆ flint_call()

call flint_call ( call c )

This function checks the syntax of a call and recursively.

verifies its arguments

Definition at line 74 of file flint_walk.c.

 {
     list            la = call_arguments(c);
  
     check_the_call(c);
  
     gen_mapl((gen_iter_func_t)flint_cons_actual_argument, la);
  
     return (c);
 }

References call_arguments, check_the_call(), flint_cons_actual_argument(), and gen_mapl().

Referenced by flint_instruction(), and flint_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_cons_actual_argument()

void flint_cons_actual_argument ( list pc )

An array actual argument may have no indices

Parameters

pc c

Definition at line 158 of file flint_walk.c.

 {
     expression e = EXPRESSION(CAR(pc));
  
     /* An array actual argument may have no indices */
     if(expression_reference_p(e)) {
         reference r = expression_reference(e);
  
         if(gen_length(reference_indices(r))!=0)
             flint_expression(e);
     }
     else {
         flint_expression(e);
     }
 }

References CAR, EXPRESSION, expression_reference(), expression_reference_p(), flint_expression(), gen_length(), and reference_indices.

Referenced by flint_call().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_cons_dimension()

void flint_cons_dimension ( list pc )

The only global variable : the name of the current module.

flint_walk.c

extern char *current_module_name; unused and changed These two functions deal with the boundaries of finite
arrays, verifying their definition as expressions

Parameters

pc c

Definition at line 52 of file flint_walk.c.

 {
     flint_dimension(DIMENSION(CAR(pc)));
 }

References CAR, DIMENSION, and flint_dimension().

Here is the call graph for this function:

◆ flint_cons_expression()

void flint_cons_expression ( list pc )

These two functions operate on the list of expressions

Parameters

pc c

Definition at line 150 of file flint_walk.c.

 {
     flint_expression(EXPRESSION(CAR(pc)));
 }

References CAR, EXPRESSION, and flint_expression().

Referenced by flint_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_cons_statement()

void flint_cons_statement ( list pc )

Parameters

pc c

Definition at line 269 of file flint_walk.c.

 {
     flint_statement(STATEMENT(CAR(pc)));
 }

References CAR, flint_statement(), and STATEMENT.

Referenced by flint_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_dimension()

dimension flint_dimension ( dimension d )

Definition at line 58 of file flint_walk.c.

 {
     expression      el = dimension_lower(d);
     expression      eu = dimension_upper(d);
  
     flint_expression(el);
     flint_expression(eu);
  
     return (d);
 }

References dimension_lower, dimension_upper, and flint_expression().

Referenced by flint_cons_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_expression()

expression flint_expression ( expression e )

Definition at line 174 of file flint_walk.c.

 {
     syntax          s = expression_syntax(e);
  
     flint_syntax(s);
  
     return (e);
 }

References expression_syntax, and flint_syntax().

Referenced by flint_cons_actual_argument(), flint_cons_expression(), flint_dimension(), flint_range(), and flint_test().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_instruction()

instruction flint_instruction ( instruction i )

Verification of an instruction with branching according

to its subclass as defined in the data structure

Definition at line 217 of file flint_walk.c.

 {
     list            pc;
     test            t;
     loop            l;
     call            c;
     unstructured    u;
  
     switch (instruction_tag(i)) {
     case is_instruction_block:
         pc = instruction_block(i);
         gen_mapl((gen_iter_func_t)flint_cons_statement, pc);
         break;
     case is_instruction_test:
         t = instruction_test(i);
         flint_test(t);
         break;
     case is_instruction_loop:
         l = instruction_loop(i);
         flint_loop(l);
         break;
     case is_instruction_goto:
         break;
     case is_instruction_unstructured:
         u = instruction_unstructured(i);
         flint_unstructured(u);
         break;
     case is_instruction_call:
         c = instruction_call(i);
         (void) check_procedure(c);
         flint_call(c);
         break;
     default:
         FATAL("flint_instruction: unexpected tag %u\n", instruction_tag(i));
     }
  
     return (i);
 }

References check_procedure(), FATAL, flint_call(), flint_cons_statement(), flint_loop(), flint_test(), flint_unstructured(), gen_mapl(), instruction_block, instruction_call, instruction_loop, instruction_tag, instruction_test, instruction_unstructured, is_instruction_block, is_instruction_call, is_instruction_goto, is_instruction_loop, is_instruction_test, and is_instruction_unstructured.

Referenced by flint_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_loop()

loop flint_loop ( loop l )

Recursive verification of a loop as (range)+(expression)

Definition at line 186 of file flint_walk.c.

 {
     range           r = loop_range(l);
     statement       s = loop_body(l);
  
     flint_range(r);
     flint_statement(s);
  
     return (l);
 }

References flint_range(), flint_statement(), loop_body, and loop_range.

Referenced by flint_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_range()

range flint_range ( range r )

This function verifies that incremented or decremented

loop(for) indices do not overflow or underflow their
limits

Definition at line 90 of file flint_walk.c.

 {
     expression      el = range_lower(r);
     expression      eu = range_upper(r);
     expression      ei = range_increment(r);
  
     flint_expression(el);
     flint_expression(eu);
     flint_expression(ei);
  
     return (r);
 }

References flint_expression(), range_increment, range_lower, and range_upper.

Referenced by flint_loop(), and flint_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_reference()

reference flint_reference ( reference r )

A reference is used when given a function the address of.

an element instead of its value.

Definition at line 107 of file flint_walk.c.

 {
     list            pc = reference_indices(r);
  
     (void) check_the_reference(r);
  
     gen_mapl((gen_iter_func_t)flint_cons_expression, pc);
  
     return (r);
 }

References check_the_reference(), flint_cons_expression(), gen_mapl(), and reference_indices.

Referenced by flint_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_statement()

statement flint_statement ( statement s )

Definition at line 278 of file flint_walk.c.

 {
     instruction     
         i = statement_instruction(s);
     statement       
         saved = flint_current_statement;
     
     flint_current_statement = s;
     
     flint_instruction(i);
     
     flint_current_statement = saved;
     return (s);
 }

References flint_current_statement, flint_instruction(), and statement_instruction.

Referenced by flint_cons_statement(), flint_loop(), flint_test(), flint_unstructured(), and flinter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_syntax()

void flint_syntax ( syntax s )

verification of syntaxes

branch according to the syntax subclass

Definition at line 121 of file flint_walk.c.

 {
     reference       re;
     range           ra;
     call            c;
  
     /* branch according to the syntax subclass */
     switch (syntax_tag(s)) {
     case is_syntax_reference:
         re = syntax_reference(s);
         flint_reference(re);
         break;
     case is_syntax_range:
         ra = syntax_range(s);
         flint_range(ra);
         break;
     case is_syntax_call:
         c = syntax_call(s);
         flint_call(c);
         break;
     default:
         FATAL("flint_syntax: unexpected tag %u\n", syntax_tag(s));
     }
 }

References FATAL, flint_call(), flint_range(), flint_reference(), is_syntax_call, is_syntax_range, is_syntax_reference, syntax_call, syntax_range, syntax_reference, and syntax_tag.

Referenced by flint_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_test()

test flint_test ( test t )

A test is taken as (expression)+(statement)+(statement)

Definition at line 200 of file flint_walk.c.

 {
     expression      e = test_condition(t);
     statement       st = test_true(t);
     statement       sf = test_false(t);
  
     flint_expression(e);
     flint_statement(st);
     flint_statement(sf);
  
     return (t);
 }

References flint_expression(), flint_statement(), test_condition, test_false, and test_true.

Referenced by flint_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ flint_unstructured()

void flint_unstructured ( unstructured u )

Definition at line 257 of file flint_walk.c.

 {
     list            blocs = NIL;
  
     CONTROL_MAP(c, {
         flint_statement(control_statement(c));
     }, unstructured_control(u), blocs);
  
     gen_free_list(blocs);
 }