1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *

     4

 *  Copyright (C) 2009-2012  Mario de Sousa (msousa@fe.up.pt)

     5

 *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant

     6

 *  Copyright (C) 2012       Manuele Conti (manuele.conti@sirius-es.it)

     7

 *  Copyright (C) 2012       Matteo Facchinetti (matteo.facchinetti@sirius-es.it)

     8

 *

     9

 *  This program is free software: you can redistribute it and/or modify

    10

 *  it under the terms of the GNU General Public License as published by

    11

 *  the Free Software Foundation, either version 3 of the License, or

    12

 *  (at your option) any later version.

    13

 *

    14

 *  This program is distributed in the hope that it will be useful,

    15

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    16

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17

 *  GNU General Public License for more details.

    18

 *

    19

 *  You should have received a copy of the GNU General Public License

    20

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    21

 *

    22

 *

    23

 * This code is made available on the understanding that it will not be

    24

 * used in safety-critical situations without a full and competent review.

    25

 */

    26

    27

/*

    28

 * An IEC 61131-3 compiler.

    29

 *

    30

 * Based on the

    31

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    32

 *

    33

 */

    34

    35

#include "stage3.hh"

    36

    37

#include "flow_control_analysis.hh"

    38

#include "fill_candidate_datatypes.hh"

    39

#include "narrow_candidate_datatypes.hh"

    40

#include "forced_narrow_candidate_datatypes.hh"

    41

#include "print_datatypes_error.hh"

    42

#include "lvalue_check.hh"

    43

#include "array_range_check.hh"

    44

#include "case_elements_check.hh"

    45

#include "constant_folding.hh"

    46

#include "declaration_check.hh"

    47

#include "enum_declaration_check.hh"

    48

#include "remove_forward_dependencies.hh"

    49

    50

    51

    52

static int enum_declaration_check(symbol_c *tree_root){

    53

    enum_declaration_check_c enum_declaration_check(NULL);

    54

    tree_root->accept(enum_declaration_check);

    55

    return enum_declaration_check.get_error_count();

    56

}

    57

    58

    59

/* In order to correctly handle variable sized arrays

    60

 * declaration_safety() must only be run after constant folding!

    61

 *   NOTE that the dependency does not resides directly in declaration_check_c,

    62

 *        but rather indirectly in the call to get_datatype_info_c::is_type_equal()

    63

 *        which may in turn call get_datatype_info_c::is_arraytype_equal_relaxed()

    64

 *

    65

 * Example of a variable sized array:

    66

 *   VAR_EXTERN CONSTANT max: INT; END_VAR;

    67

 *   VAR_EXTERN xx: ARRAY [1..max] OF INT; END_VAR;

    68

 */

    69

static int declaration_safety(symbol_c *tree_root){

    70

    declaration_check_c declaration_check(tree_root);

    71

    tree_root->accept(declaration_check);

    72

    return declaration_check.get_error_count();

    73

}

    74

    75

static int flow_control_analysis(symbol_c *tree_root){

    76

    flow_control_analysis_c flow_control_analysis(tree_root);

    77

    tree_root->accept(flow_control_analysis);

    78

    return 0;

    79

}

    80

    81

    82

/* Constant folding assumes that flow control analysis has been completed!

    83

 * so be sure to call flow_control_analysis() before calling this function!

    84

 */

    85

static int constant_propagation(symbol_c *tree_root){

    86

    constant_propagation_c constant_propagation(tree_root);

    87

    tree_root->accept(constant_propagation);

    88

    return constant_propagation.get_error_count();

    89

}

    90

    91

    92

/* Type safety analysis assumes that 

    93

 *    - flow control analysis 

    94

 *    - constant folding (constant check)

    95

 * has already been completed, so be sure to call those semantic checkers

    96

 * before calling this function

    97

 */

    98

static int type_safety(symbol_c *tree_root){

    99

	fill_candidate_datatypes_c fill_candidate_datatypes(tree_root);

   100

	tree_root->accept(fill_candidate_datatypes);

   101

	narrow_candidate_datatypes_c narrow_candidate_datatypes(tree_root);

   102

	tree_root->accept(narrow_candidate_datatypes);

   103

	print_datatypes_error_c print_datatypes_error(tree_root);

   104

	tree_root->accept(print_datatypes_error);

   105

	forced_narrow_candidate_datatypes_c forced_narrow_candidate_datatypes(tree_root);

   106

	tree_root->accept(forced_narrow_candidate_datatypes);

   107

	return print_datatypes_error.get_error_count();

   108

}

   109

   110

   111

/* Left value checking assumes that data type analysis has already been completed,

   112

 * so be sure to call type_safety() before calling this function

   113

 */

   114

static int lvalue_check(symbol_c *tree_root){

   115

	lvalue_check_c lvalue_check(tree_root);

   116

	tree_root->accept(lvalue_check);

   117

	return lvalue_check.get_error_count();

   118

}

   119

   120

/* Array range check assumes that constant folding has been completed!

   121

 * so be sure to call constant_folding() before calling this function!

   122

 */

   123

static int array_range_check(symbol_c *tree_root){

   124

	array_range_check_c array_range_check(tree_root);

   125

	tree_root->accept(array_range_check);

   126

	return array_range_check.get_error_count();

   127

}

   128

   129

   130

/* Case options check assumes that constant folding has been completed!

   131

 * so be sure to call constant_folding() before calling this function!

   132

 */

   133

static int case_elements_check(symbol_c *tree_root){

   134

	case_elements_check_c case_elements_check(tree_root);

   135

	tree_root->accept(case_elements_check);

   136

	return case_elements_check.get_error_count();

   137

}

   138

   139

   140

/* Removing forward dependencies only makes sense when stage1_2 is run with the pre-parsing option.

   141

 * This algorithm has no dependencies on other stage 3 algorithms.

   142

 * Typically this is run last, just to show that the remaining algorithms also do not depend on the fact that 

   143

 * the library_c (i.e. the source code) does not contain forward dependencies.

   144

 */

   145

static int remove_forward_dependencies(symbol_c *tree_root, symbol_c **ordered_tree_root) {

   146

	if (NULL != ordered_tree_root)    *ordered_tree_root = tree_root; // by default, consider tree_root already ordered

   147

	if (!runtime_options.pre_parsing)  return 0;                      // No re-ordering necessary, just return

   148

   149

	/* We need to re-order the elements in the library, to fix any forward references! */

   150

	remove_forward_dependencies_c remove_forward_dependencies;

   151

	symbol_c *new_tree_root = remove_forward_dependencies.create_new_tree(tree_root);

   152

	if (NULL ==     new_tree_root)   ERROR;

   153

	if (NULL != ordered_tree_root)   *ordered_tree_root = new_tree_root;

   154

	return remove_forward_dependencies.get_error_count();

   155

}

   156

   157

   158

int stage3(symbol_c *tree_root, symbol_c **ordered_tree_root) {

   159

	int error_count = 0;

   160

	error_count += enum_declaration_check(tree_root);

   161

	error_count += flow_control_analysis(tree_root);

   162

	error_count += constant_propagation(tree_root);

   163

	error_count += declaration_safety(tree_root);

   164

	error_count += type_safety(tree_root);

   165

	error_count += lvalue_check(tree_root);

   166

	error_count += array_range_check(tree_root);

   167

	error_count += case_elements_check(tree_root);

   168

	error_count += remove_forward_dependencies(tree_root, ordered_tree_root);

   169

   170

	if (error_count > 0) {

   171

		fprintf(stderr, "%d error(s) found. Bailing out!\n", error_count); 

   172

		return -1;

   173

	}

   174

	return 0;

   175

}