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) 2012       Manuele Conti  (conti.ma@alice.it)

     6

 *

     7

 *

     8

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

     9

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

    10

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

    11

 *  (at your option) any later version.

    12

 *

    13

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

    14

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

    15

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16

 *  GNU General Public License for more details.

    17

 *

    18

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

    19

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

    20

 *

    21

 *

    22

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

    23

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

    24

 */

    25

    26

/*

    27

 * An IEC 61131-3 compiler.

    28

 *

    29

 * Based on the

    30

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

    31

 *

    32

 */

    33

    34

    35

#include "lvalue_check.hh"

    36

    37

#define FIRST_(symbol1, symbol2) (((symbol1)->first_order < (symbol2)->first_order)   ? (symbol1) : (symbol2))

    38

#define  LAST_(symbol1, symbol2) (((symbol1)->last_order  > (symbol2)->last_order)    ? (symbol1) : (symbol2))

    39

    40

#define STAGE3_ERROR(error_level, symbol1, symbol2, ...) {                                                                  \

    41

  if (current_display_error_level >= error_level) {                                                                         \

    42

    fprintf(stderr, "%s:%d-%d..%d-%d: error: ",                                                                             \

    43

            FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column,\

    44

                                                 LAST_(symbol1,symbol2) ->last_line,  LAST_(symbol1,symbol2) ->last_column);\

    45

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    46

    fprintf(stderr, "\n");                                                                                                  \

    47

    error_count++;                                                                                                     \

    48

  }                                                                                                                         \

    49

}

    50

    51

    52

#define STAGE3_WARNING(symbol1, symbol2, ...) {                                                                             \

    53

    fprintf(stderr, "%s:%d-%d..%d-%d: warning: ",                                                                           \

    54

            FIRST_(symbol1,symbol2)->first_file, FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column,\

    55

                                                 LAST_(symbol1,symbol2) ->last_line,  LAST_(symbol1,symbol2) ->last_column);\

    56

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    57

    fprintf(stderr, "\n");                                                                                                  \

    58

    warning_found = true;                                                                                                   \

    59

}

    60

    61

    62

lvalue_check_c::lvalue_check_c(symbol_c *ignore) {

    63

	error_count = 0;

    64

}

    65

    66

lvalue_check_c::~lvalue_check_c(void) {

    67

}

    68

    69

int lvalue_check_c::get_error_count() {

    70

	return error_count;

    71

}

    72

    73

    74

#include <strings.h>

    75

/* No writing to iterator variables (used in FOR loops) inside the loop itself */

    76

void lvalue_check_c::check_assignment_to_controlvar(symbol_c *lvalue) {

    77

	for (unsigned int i = 0; i < control_variables.size(); i++) {

    78

		token_c *lvalue_name = get_var_name_c::get_name(lvalue);

    79

		if (compare_identifiers(lvalue_name, control_variables[i]) == 0) {

    80

			STAGE3_ERROR(0, lvalue, lvalue, "Assignment to FOR control variable is not allowed.");

    81

			break;

    82

		}

    83

	}

    84

}

    85

    86

    87

/* fb_instance.var := ...  is not valid if var is output variable */

    88

/* NOTE, if a fb_instance1.fb_instance2.fb_instance3.var is used, we must iteratively check that none of the 

    89

 *       FB records are declared as OUTPUT variables!!  

    90

 *       This is the reason why we have the while() loop in this function!

    91

 */

    92

void lvalue_check_c::check_assignment_to_output(symbol_c *lvalue) {

    93

	decompose_var_instance_name_c decompose_lvalue(lvalue);

    94

	search_base_type_c            search_base_type;

    95

    96

	/* Get the first element/record of the potentially structured variable symbol */

    97

	/* Note that if symbol is pointing to an expression (or simply a literal value), it will return a NULL.

    98

	 * Once we have implemented the check_assignment_to_expression() method, and abort calling the other checks (including this one)

    99

	 * when an expression is found, we may replace this check with an assertion...

   100

	 * if (NULL == struct_elem) ERROR;

   101

	 */

   102

	symbol_c *struct_elem = decompose_lvalue.next_part();

   103

	if (NULL == struct_elem) return;

   104

   105

	symbol_c *type_decl   = search_var_instance_decl->get_decl(struct_elem);

   106

	// symbol_c *type_id  = spec_init_sperator_c::get_spec(type_decl); /* this is not required! search_base_type_c can handle spec_init symbols! */

   107

	symbol_c *basetype_id = search_base_type.get_basetype_id(/*type_id*/ type_decl);

   108

	/* If we can not determine the data type of the element, then the code must have a data type semantic error.

   109

	 * This will have been caught by the data type semantic verifier, so we do not bother with this anymore!

   110

	 */

   111

	if (NULL == basetype_id) return;

   112

   113

	/* Determine if the record/structure element is of a FB type. */

   114

	/* NOTE: If the structure element is not a FB type, then we can quit this check.

   115

	 *       Remember that the standard does not allow a STRUCT data type to have elements that are FB instances!

   116

	 *       Similarly, arrays of FB instances is also not allowed.

   117

	 *       So, as soon as we find one record/structure element that is not a FB, no other record/structure element

   118

	 *       will be of FB type, which means we can quit this check!

   119

	 */

   120

	function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(basetype_id);

   121

	if (function_block_type_symtable.end_value() == fb_decl) return;

   122

   123

	while (NULL != (struct_elem = decompose_lvalue.next_part())) {

   124

		search_var_instance_decl_c   fb_search_var_instance_decl(fb_decl);

   125

		if (search_var_instance_decl_c::output_vt == fb_search_var_instance_decl.get_vartype(struct_elem)) {

   126

			STAGE3_ERROR(0, struct_elem, struct_elem, "Assignment to FB output variable is not allowed.");

   127

			return; /* no need to carry on checking once the first error is found! */

   128

		}

   129

   130

		/* prepare for any possible further record/structure elements */

   131

		type_decl   = fb_search_var_instance_decl.get_decl(struct_elem);

   132

		basetype_id = search_base_type.get_basetype_id(type_decl);

   133

		if (NULL == basetype_id) return; /* same comment as above... */

   134

		fb_decl = function_block_type_symtable.find_value(basetype_id);

   135

		if (function_block_type_symtable.end_value() == fb_decl) return; /* same comment as above... */

   136

	}

   137

}

   138

   139

   140

/*  No writing to CONSTANTs */

   141

void lvalue_check_c::check_assignment_to_constant(symbol_c *lvalue) {

   142

	unsigned int option = search_var_instance_decl->get_option(lvalue);

   143

	if (option == search_var_instance_decl_c::constant_opt) {

   144

		STAGE3_ERROR(0, lvalue, lvalue, "Assignment to CONSTANT variables is not be allowed.");

   145

	}

   146

}

   147

   148

   149

/*  No assigning values to expressions. */

   150

void lvalue_check_c::check_assignment_to_expression(symbol_c *lvalue) {

   151

	/* TODO: check whether the lvalue is an expresion! */

   152

	/* This may occur in function invocations, when passing values (possibly an expression) to one 

   153

	 * of the function's OUTPUT or IN_OUT parameters.

   154

	 */

   155

}

   156

   157

   158

   159

void lvalue_check_c::verify_is_lvalue(symbol_c *lvalue) {

   160

	check_assignment_to_expression(lvalue);

   161

	check_assignment_to_controlvar(lvalue);

   162

	check_assignment_to_output(lvalue);

   163

	check_assignment_to_constant(lvalue);

   164

}

   165

   166

   167

   168

   169

/* check whether all values passed to OUT or IN_OUT parameters are legal lvalues. */

   170

/*

   171

 * All parameters being passed to the called function MUST be in the parameter list to which f_call points to!

   172

 * This means that, for non formal function calls in IL, de current (default value) must be artificially added to the

   173

 * beginning of the parameter list BEFORE calling handle_function_call().

   174

 */

   175

#include <string.h> /* required for strcmp() */

   176

void lvalue_check_c::check_nonformal_call(symbol_c *f_call, symbol_c *f_decl) {

   177

	symbol_c *call_param_value;

   178

	identifier_c *param_name;

   179

	function_param_iterator_c       fp_iterator(f_decl);

   180

	function_call_param_iterator_c fcp_iterator(f_call);

   181

   182

	/* Iterating through the non-formal parameters of the function call */

   183

	while((call_param_value = fcp_iterator.next_nf()) != NULL) {

   184

		/* Iterate to the next parameter of the function being called.

   185

		 * Get the name of that parameter, and ignore if EN or ENO.

   186

		 */

   187

		do {

   188

			param_name = fp_iterator.next();

   189

			/* If there is no other parameter declared, then we are passing too many parameters... */

   190

			/* This error should have been caught in data type verification, so we simply abandon our check! */

   191

			if(param_name == NULL) return;

   192

		} while ((strcmp(param_name->value, "EN") == 0) || (strcmp(param_name->value, "ENO") == 0));

   193

   194

		/* Find the corresponding parameter in function declaration, and it's direction (IN, OUT, IN_OUT) */

   195

		function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();

   196

   197

		/* We only check if 'call_param_value' is a valid lvalue if the value is being passed

   198

		 * to a valid paramater of the function being called, and that parameter is either OUT or IN_OUT.

   199

		 */

   200

		if ((param_name != NULL) && ((function_param_iterator_c::direction_out == param_direction) || (function_param_iterator_c::direction_inout == param_direction))) {

   201

			verify_is_lvalue(call_param_value);

   202

		}

   203

	}

   204

}

   205

   206

   207

   208

   209

   210

   211

/* check whether all values passed to OUT or IN_OUT parameters are legal lvalues. */

   212

void lvalue_check_c::check_formal_call(symbol_c *f_call, symbol_c *f_decl) {

   213

	/* if data type semantic verification was unable to determine which function is being called,

   214

	 * then it does not make sense to go ahead and check for lvalues to unknown parameters.

   215

	 * We simply bug out!

   216

	 */

   217

	if (NULL == f_decl) return;

   218

   219

	symbol_c *call_param_name;

   220

	function_param_iterator_c       fp_iterator(f_decl);

   221

	function_call_param_iterator_c fcp_iterator(f_call);

   222

   223

	/* Iterating through the formal parameters of the function call */

   224

	while((call_param_name = fcp_iterator.next_f()) != NULL) {

   225

   226

		/* Obtaining the value being passed in the function call */

   227

		symbol_c *call_param_value = fcp_iterator.get_current_value();

   228

		if (NULL == call_param_value) ERROR;

   229

   230

		/* Find the corresponding parameter in function declaration, and it's direction (IN, OUT, IN_OUT) */

   231

		identifier_c *param_name = fp_iterator.search(call_param_name);

   232

		function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction();

   233

   234

		/* We only check if 'call_param_value' is a valid lvalue if the value is being passed

   235

		 * to a valid paramater of the function being called, and that parameter is either OUT or IN_OUT.

   236

		 */

   237

		if ((param_name != NULL) && ((function_param_iterator_c::direction_out == param_direction) || (function_param_iterator_c::direction_inout == param_direction))) {

   238

			verify_is_lvalue(call_param_value);

   239

		}

   240

	}

   241

}

   242

   243

   244

   245

   246

   247

   248

   249

/**************************************/

   250

/* B 1.5 - Program organisation units */

   251

/**************************************/

   252

/***********************/

   253

/* B 1.5.1 - Functions */

   254

/***********************/

   255

void *lvalue_check_c::visit(function_declaration_c *symbol) {

   256

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   257

	search_var_instance_decl = new search_var_instance_decl_c(symbol);

   258

	symbol->function_body->accept(*this);

   259

	delete search_varfb_instance_type;

   260

	delete search_var_instance_decl;

   261

	search_varfb_instance_type = NULL;

   262

	search_var_instance_decl = NULL;

   263

	return NULL;

   264

}

   265

   266

/*****************************/

   267

/* B 1.5.2 - Function blocks */

   268

/*****************************/

   269

void *lvalue_check_c::visit(function_block_declaration_c *symbol) {

   270

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   271

	search_var_instance_decl = new search_var_instance_decl_c(symbol);

   272

	symbol->fblock_body->accept(*this);

   273

	delete search_varfb_instance_type;

   274

	delete search_var_instance_decl;

   275

	search_varfb_instance_type = NULL;

   276

	search_var_instance_decl = NULL;

   277

	return NULL;

   278

}

   279

   280

/**********************/

   281

/* B 1.5.3 - Programs */

   282

/**********************/

   283

void *lvalue_check_c::visit(program_declaration_c *symbol) {

   284

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   285

	search_var_instance_decl = new search_var_instance_decl_c(symbol);

   286

	symbol->function_block_body->accept(*this);

   287

	delete search_varfb_instance_type;

   288

	delete search_var_instance_decl;

   289

	search_varfb_instance_type = NULL;

   290

	search_var_instance_decl = NULL;

   291

	return NULL;

   292

}

   293

   294

/***************************************/

   295

/* B.3 - Language ST (Structured Text) */

   296

/***************************************/

   297

/***********************/

   298

/* B 3.1 - Expressions */

   299

/***********************/

   300

// SYM_REF3(function_invocation_c, function_name, formal_param_list, nonformal_param_list, symbol_c *called_function_declaration; int extensible_param_count; std::vector <symbol_c *> candidate_functions;)

   301

void *lvalue_check_c::visit(function_invocation_c *symbol) {

   302

	if (NULL != symbol->formal_param_list   )  check_formal_call   (symbol, symbol->called_function_declaration);

   303

	if (NULL != symbol->nonformal_param_list)  check_nonformal_call(symbol, symbol->called_function_declaration);

   304

	return NULL;

   305

}

   306

   307

/*********************************/

   308

/* B 3.2.1 Assignment Statements */

   309

/*********************************/

   310

void *lvalue_check_c::visit(assignment_statement_c *symbol) {

   311

	verify_is_lvalue(symbol->l_exp);

   312

	/* We call visit r_exp to check function_call */

   313

	symbol->r_exp->accept(*this);

   314

	return NULL;

   315

}

   316

   317

/********************************/

   318

/* B 3.2.4 Iteration Statements */

   319

/********************************/

   320

void *lvalue_check_c::visit(for_statement_c *symbol) {

   321

	control_variables.push_back(get_var_name_c::get_name(symbol->control_variable));

   322

	symbol->statement_list->accept(*this);

   323

	control_variables.pop_back();

   324

	return NULL;

   325

}

   326

   327

   328

   329

   330

   331

   332