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");                                                                                                  \

    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) {

    64

}

    65

    66

lvalue_check_c::~lvalue_check_c(void) {

    67

}

    68

    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

		symbolic_variable_c *cvar = (symbolic_variable_c *)control_variables[i];

    79

		if (strcasecmp(((identifier_c *)((symbolic_variable_c *)lvalue)->var_name)->value, ((identifier_c *)((symbolic_variable_c *)cvar)->var_name)->value) == 0) {

    80

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

    81

			break;

    82

		}

    83

	}

    84

}

    85

    86

   120

		}

   128

	}

   129

}

   130

   131

   132

/*  No writing to CONSTANTs */

   133

void lvalue_check_c::check_assignment_to_constant(symbol_c *lvalue) {

   134

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

   135

	if (option == search_var_instance_decl_c::constant_opt) {

   136

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

   137

	}

   138

}

   139

   140

   141

/*  No assigning values to expressions. */

   142

void lvalue_check_c::check_assignment_to_expression(symbol_c *lvalue) {

   143

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

   144

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

   146

	 */

   147

}

   148

   149

   150

   151

void lvalue_check_c::verify_is_lvalue(symbol_c *lvalue) {

   153

	check_assignment_to_controlvar(lvalue);

   154

	check_assignment_to_output(lvalue);

   155

	check_assignment_to_constant(lvalue);

   156

}

   157

   158

   159

   160

   161

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

   162

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

   163

  /* TODO */

   164

}

   165

   166

   167

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

   168

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

   169

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

   170

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

   171

	 * We simply bug out!

   172

	 */

   173

	if (NULL == f_decl) return;

   174

   175

	symbol_c *call_param_name;

   176

	function_param_iterator_c       fp_iterator(f_decl);

   177

	function_call_param_iterator_c fcp_iterator(f_call);

   178

   179

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

   180

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

   181

   182

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

   183

		symbol_c *call_param_value = fcp_iterator.get_current_value();

   184

		if (NULL == call_param_value) ERROR;

   185

   186

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

   187

		identifier_c *param_name = fp_iterator.search(call_param_name);

   188

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

   189

   190

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

   191

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

   192

		 */

   194

			verify_is_lvalue(call_param_value);

   195

		}

   196

	}

   197

}

   198

   199

   200

   201

   202

   203

   204

   205

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

   206

/* B 1.5 - Program organisation units */

   207

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

   208

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

   209

/* B 1.5.1 - Functions */

   210

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

   211

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

   212

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   213

	search_var_instance_decl = new search_var_instance_decl_c(symbol);

   214

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

   215

	delete search_varfb_instance_type;

   216

	delete search_var_instance_decl;

   217

	search_varfb_instance_type = NULL;

   218

	search_var_instance_decl = NULL;

   219

	return NULL;

   220

}

   221

   222

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

   223

/* B 1.5.2 - Function blocks */

   224

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

   225

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

   226

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   227

	search_var_instance_decl = new search_var_instance_decl_c(symbol);

   228

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

   229

	delete search_varfb_instance_type;

   230

	delete search_var_instance_decl;

   231

	search_varfb_instance_type = NULL;

   232

	search_var_instance_decl = NULL;

   233

	return NULL;

   234

}

   235

   236

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

   237

/* B 1.5.3 - Programs */

   238

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

   239

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

   240

	search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

   241

	search_var_instance_decl = new search_var_instance_decl_c(symbol);

   242

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

   243

	delete search_varfb_instance_type;

   244

	delete search_var_instance_decl;

   245

	search_varfb_instance_type = NULL;

   246

	search_var_instance_decl = NULL;

   247

	return NULL;

   248

}

   249

   250

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

   251

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

   252

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

   253

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

   254

/* B 3.1 - Expressions */

   255

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

   256

// 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;)

   257

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

   260

	return NULL;

   261

}

   262

   263

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

   264

/* B 3.2.1 Assignment Statements */

   265

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

   266

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

   267

	verify_is_lvalue(symbol->l_exp);

   268

	/* We call visit r_exp to check function_call */

   269

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

   270

	return NULL;

   271

}

   272

   273

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

   274

/* B 3.2.4 Iteration Statements */

   275

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

   276

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

   277

	control_variables.push_back(symbol->control_variable);

   278

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

   279

	control_variables.pop_back();

   280

	return NULL;

   281

}

   282

   283

   284

   285

   286

   287

   288