1

/*

     2

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

     3

 *

     4

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

     5

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

     6

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

     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

/*

    36

 *  Fill candidate list of data types for all symbols

    37

 */

    38

    39

#include "print_datatypes_error.hh"

    40

#include "datatype_functions.hh"

    41

    42

#include <typeinfo>

    43

#include <list>

    44

#include <string>

    45

#include <string.h>

    46

#include <strings.h>

    47

    48

    49

    50

    51

    52

    53

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

    54

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

    55

    56

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

    57

  if (current_display_error_level >= error_level) {                                                                         \

    58

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

    59

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

    60

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

    61

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    62

    fprintf(stderr, "\n");                                                                                                  \

    63

    il_error = true;                                                                                                        \

    64

    error_found = true;                                                                                                     \

    65

  }                                                                                                                         \

    66

}  

    67

    68

    69

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

    70

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

    71

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

    72

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

    73

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    74

    fprintf(stderr, "\n");                                                                                                  \

    75

    warning_found = true;                                                                                                   \

    76

}  

    77

    78

    79

/* set to 1 to see debug info during execution */

    80

static int debug = 0;

    81

    82

print_datatypes_error_c::print_datatypes_error_c(symbol_c *ignore) {

    83

	error_found = false;

    84

	warning_found = false;

    85

	current_display_error_level = error_level_default;

    86

}

    87

    88

print_datatypes_error_c::~print_datatypes_error_c(void) {

    89

}

    90

    91

int print_datatypes_error_c::get_error_found() {

    92

	return error_found;

    93

}

    94

    95

    96

    97

    98

    99

/* Verify if the datatypes of all prev_il_instructions are valid and equal!  */

   100

static bool are_all_datatypes_of_prev_il_instructions_datatypes_equal(il_instruction_c *symbol) {

   101

	if (NULL == symbol) ERROR;

   102

	bool res;

   103

   104

	if (symbol->prev_il_instruction.size() > 0)

   105

		res = is_type_valid(symbol->prev_il_instruction[0]->datatype);

   106

   107

	for (unsigned int i = 1; i < symbol->prev_il_instruction.size(); i++)

   108

		res &= is_type_equal(symbol->prev_il_instruction[i-1]->datatype, symbol->prev_il_instruction[i]->datatype);

   109

   110

	return res;

   111

}

   112

   113

   114

   115

   116

/* a helper function... */

   117

symbol_c *print_datatypes_error_c::base_type(symbol_c *symbol) {

   118

	/* NOTE: symbol == NULL is valid. It will occur when, for e.g., an undefined/undeclared symbolic_variable is used

   119

	 *       in the code.

   120

	 */

   121

	if (symbol == NULL) return NULL;

   122

	return (symbol_c *)symbol->accept(search_base_type);

   123

}

   124

   125

   126

   127

   128

void print_datatypes_error_c::check_used_operation_status(symbol_c *symbol, symbol_c *left, symbol_c *right,  const struct widen_entry widen_table[]) {

   129

	/* find a compatible entry in the widening table */

   130

	for (int k = 0; NULL != widen_table[k].left;  k++)

   131

		if (is_type_equal(left, widen_table[k].left) && is_type_equal(right, widen_table[k].right))

   132

			if  (widen_entry::deprecated == widen_table[k].status)

   133

				STAGE3_WARNING(symbol, symbol, "Deprecated operation.");

   134

}

   135

   136

   137

/*

   138

typedef struct {

   139

  symbol_c *function_name,

   140

  symbol_c *nonformal_operand_list,

   141

  symbol_c *   formal_operand_list,

   142

   143

  std::vector <symbol_c *> &candidate_functions,  

   144

  symbol_c &*called_function_declaration,

   145

  int      &extensible_param_count

   146

} generic_function_call_t;

   147

*/

   148

void print_datatypes_error_c::handle_function_invocation(symbol_c *fcall, generic_function_call_t fcall_data) {

   149

	symbol_c *param_value, *param_name;

   150

	function_call_param_iterator_c fcp_iterator(fcall);

   151

	bool function_invocation_error = false;

   152

	const char *POU_str = NULL;

   153

   154

	if (generic_function_call_t::POU_FB       == fcall_data.POU_type)  POU_str = "FB";

   155

	if (generic_function_call_t::POU_function == fcall_data.POU_type)  POU_str = "function";

   156

	if (NULL == POU_str) ERROR;

   157

   158

	if ((NULL != fcall_data.formal_operand_list) && (NULL != fcall_data.nonformal_operand_list)) 

   159

		ERROR;

   160

   161

	symbol_c *f_decl = fcall_data.called_function_declaration;

   162

	if ((NULL == f_decl) && (generic_function_call_t::POU_FB ==fcall_data.POU_type)) {

   163

		/* Due to the way the syntax analysis is buit (i.e. stage 2), this should never occur. */

   164

		/* I.e., a FB invocation using an undefined FB variable is not possible in the current implementation of stage 2. */

   165

		ERROR;

   166

	}

   167

	if (NULL == f_decl) {

   168

		/* we now try to find any function declaration with the same name, just so we can provide some relevant error messages */

   169

		function_symtable_t::iterator lower = function_symtable.lower_bound(fcall_data.function_name);

   170

		if (lower == function_symtable.end()) ERROR;

   171

		f_decl = function_symtable.get_value(lower);

   172

	}

   173

   174

	if (NULL != fcall_data.formal_operand_list) {

   175

		fcall_data.formal_operand_list->accept(*this);

   176

		if (NULL != f_decl) {

   177

			function_param_iterator_c fp_iterator(f_decl);

   178

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

   179

				param_value = fcp_iterator.get_current_value();

   180

   181

				/* Check if there are duplicate parameter values */

   182

				if(fcp_iterator.search_f(param_name) != param_value) {

   183

					function_invocation_error = true;

   184

					STAGE3_ERROR(0, param_name, param_name, "Duplicate parameter '%s' when invoking %s '%s'", ((identifier_c *)param_name)->value, POU_str, ((identifier_c *)fcall_data.function_name)->value);

   185

					continue; /* jump to next parameter */

   186

				}

   187

   188

				/* Find the corresponding parameter in function declaration */

   189

				if (NULL == fp_iterator.search(param_name)) {

   190

					function_invocation_error = true;

   191

					STAGE3_ERROR(0, param_name, param_name, "Invalid parameter '%s' when invoking %s '%s'", ((identifier_c *)param_name)->value, POU_str, ((identifier_c *)fcall_data.function_name)->value);

   192

					continue; /* jump to next parameter */

   193

				} 

   194

   195

				/* check whether direction (IN, OUT, IN_OUT) and assignment types (:= , =>) are compatible !!! */

   196

				/* Obtaining the assignment direction:  := (assign_in) or => (assign_out) */

   197

				function_call_param_iterator_c::assign_direction_t call_param_dir = fcp_iterator.get_assign_direction();

   198

				/* Get the parameter direction: IN, OUT, IN_OUT */

   199

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

   200

				if          (function_call_param_iterator_c::assign_in  == call_param_dir) {

   201

					if ((function_param_iterator_c::direction_in    != param_dir) &&

   202

					    (function_param_iterator_c::direction_inout != param_dir)) {

   203

						function_invocation_error = true;

   204

						STAGE3_ERROR(0, param_name, param_name, "Invalid assignment syntax ':=' used for parameter '%s', when invoking %s '%s'", ((identifier_c *)param_name)->value, POU_str, ((identifier_c *)fcall_data.function_name)->value);

   205

						continue; /* jump to next parameter */

   206

					}

   207

				} else if   (function_call_param_iterator_c::assign_out == call_param_dir) {

   208

					if ((function_param_iterator_c::direction_out   != param_dir)) {

   209

						function_invocation_error = true;

   210

						STAGE3_ERROR(0, param_name, param_name, "Invalid assignment syntax '=>' used for parameter '%s', when invoking %s '%s'", ((identifier_c *)param_name)->value, POU_str, ((identifier_c *)fcall_data.function_name)->value);

   211

						continue; /* jump to next parameter */

   212

					}

   213

				} else ERROR;

   214

   215

				if (NULL == param_value->datatype) {

   216

					function_invocation_error = true;

   217

					STAGE3_ERROR(0, param_value, param_value, "Data type incompatibility between parameter '%s' and value being passed, when invoking %s '%s'", ((identifier_c *)param_name)->value, POU_str, ((identifier_c *)fcall_data.function_name)->value);

   218

					continue; /* jump to next parameter */

   219

				}

   220

			}

   221

		}

   222

	}

   223

	if (NULL != fcall_data.nonformal_operand_list) {

   224

		fcall_data.nonformal_operand_list->accept(*this);

   225

		if (f_decl)

   226

			for (int i = 1; (param_value = fcp_iterator.next_nf()) != NULL; i++) {

   227

		  		/* TODO: verify if it is lvalue when INOUT or OUTPUT parameters! */

   228

   229

				if (NULL == param_value->datatype) {

   230

					function_invocation_error = true;

   231

					STAGE3_ERROR(0, param_value, param_value, "Data type incompatibility for value passed in position %d when invoking %s '%s'", i, POU_str, ((identifier_c *)fcall_data.function_name)->value);

   232

				}

   233

			}

   234

	}

   235

   236

	if (NULL == fcall_data.called_function_declaration) {

   237

		function_invocation_error = true;

   238

		STAGE3_ERROR(0, fcall, fcall, "Unable to resolve which overloaded %s '%s' is being invoked.", POU_str, ((identifier_c *)fcall_data.function_name)->value);

   239

	}

   240

   241

	if (function_invocation_error) {

   242

		/* No compatible function exists */

   243

		STAGE3_ERROR(2, fcall, fcall, "Invalid parameters when invoking %s '%s'", POU_str, ((identifier_c *)fcall_data.function_name)->value);

   244

	} 

   245

   246

	return;

   247

}

   248

   249

   250

   251

void print_datatypes_error_c::handle_implicit_il_fb_invocation(symbol_c *il_operator, const char *param_name, symbol_c *called_fb_declaration) {

   252

	if (NULL == il_operand) {

   253

		STAGE3_ERROR(0, il_operator, il_operator, "Missing operand for FB call operator '%s'.", param_name);

   254

		return;

   255

	}

   256

	il_operand->accept(*this);

   257

   258

	if (NULL == called_fb_declaration) {

   259

		STAGE3_ERROR(0, il_operator, il_operand, "Invalid FB call: operand is not a FB instance.");

   260

		return;

   261

	}

   262

   263

	if (fake_prev_il_instruction->prev_il_instruction.empty()) {

   264

		STAGE3_ERROR(0, il_operator, il_operand, "FB invocation operator '%s' must be preceded by a 'LD' (or equivalent) operator.", param_name);	

   265

		return;

   266

	}

   267

   268

	/* Find the corresponding parameter in function declaration */

   269

	function_param_iterator_c fp_iterator(called_fb_declaration);

   270

	if (NULL == fp_iterator.search(param_name)) {

   271

		/* TODO: must also check whther it is an IN parameter!! */

   272

		/* NOTE: although all standard FBs have the implicit FB calls defined as input parameters

   273

		*        (i.e., for all standard FBs, CLK, PT, IN, CU, CD, S1, R1, etc... is always an input parameter)

   274

		*        if a non-standard (i.e. a FB not defined in the standard library) FB is being called, then

   275

		*        this (CLK, PT, IN, CU, ...) parameter may just have been defined as OUT or INOUT,

   276

		*        which will not work for an implicit FB call!

   277

		*/

   278

		STAGE3_ERROR(0, il_operator, il_operand, "FB called by '%s' operator does not have a parameter named '%s'", param_name, param_name);	

   279

		return;

   280

	}

   281

	if (!are_all_datatypes_of_prev_il_instructions_datatypes_equal(fake_prev_il_instruction)) {

   282

		STAGE3_ERROR(0, il_operator, il_operand, "Data type incompatibility between parameter '%s' and value being passed.", param_name);

   283

		return;

   284

	}

   285

   286

   287

	/* NOTE: The error_level currently being used for errors in variables/constants etc... is rather high.

   288

	 *       However, in the case of an implicit FB call, if the datatype of the operand == NULL, this may be

   289

	 *       the __only__ indication of an error! So we test it here again, to make sure thtis error will really

   290

	 *       be printed out!

   291

	 */

   292

	if (NULL == il_operand->datatype) {

   293

		/* Note: the case of (NULL == fb_declaration) was already caught above! */

   294

// 		if (NULL != fb_declaration) {

   295

			STAGE3_ERROR(0, il_operator, il_operator, "Invalid FB call: Datatype incompatibility between the FB's '%s' parameter and value being passed, or paramater '%s' is not a 'VAR_INPUT' parameter.", param_name, param_name);

   296

			return;

   297

// 		}

   298

	}

   299

// 

   300

	return;

   301

}

   302

   303

   304

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

   305

/* B 1.2 - Constants */

   306

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

   307

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

   308

/* B 1.2.1 - Numeric Literals */

   309

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

   310

void *print_datatypes_error_c::visit(real_c *symbol) {

   311

	if (symbol->candidate_datatypes.size() == 0) {

   312

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_REAL data type.");

   313

	} else if (NULL == symbol->datatype) {

   314

		STAGE3_ERROR(4, symbol, symbol, "ANY_REAL data type not valid in this location.");

   315

	}

   316

	return NULL;

   317

}

   318

   319

void *print_datatypes_error_c::visit(integer_c *symbol) {

   320

	if (symbol->candidate_datatypes.size() == 0) {

   321

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_INT data type.");

   322

	} else if (NULL == symbol->datatype) {

   323

		STAGE3_ERROR(4, symbol, symbol, "ANY_INT data type not valid in this location.");

   324

	}

   325

	return NULL;

   326

}

   327

   328

void *print_datatypes_error_c::visit(neg_real_c *symbol) {

   329

	if (symbol->candidate_datatypes.size() == 0) {

   330

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_REAL data type.");

   331

	} else if (NULL == symbol->datatype) {

   332

		STAGE3_ERROR(4, symbol, symbol, "ANY_REAL data type not valid in this location.");

   333

	}

   334

	return NULL;

   335

}

   336

   337

void *print_datatypes_error_c::visit(neg_integer_c *symbol) {

   338

	if (symbol->candidate_datatypes.size() == 0) {

   339

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_INT data type.");

   340

	} else if (NULL == symbol->datatype) {

   341

		STAGE3_ERROR(4, symbol, symbol, "ANY_INT data type not valid in this location.");

   342

	}

   343

	return NULL;

   344

}

   345

   346

void *print_datatypes_error_c::visit(binary_integer_c *symbol) {

   347

	if (symbol->candidate_datatypes.size() == 0) {

   348

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_INT data type.");

   349

	} else if (NULL == symbol->datatype) {

   350

		STAGE3_ERROR(4, symbol, symbol, "ANY_INT data type not valid in this location.");

   351

	}

   352

	return NULL;

   353

}

   354

   355

void *print_datatypes_error_c::visit(octal_integer_c *symbol) {

   356

	if (symbol->candidate_datatypes.size() == 0) {

   357

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_INT data type.");

   358

	} else if (NULL == symbol->datatype) {

   359

		STAGE3_ERROR(4, symbol, symbol, "ANY_INT data type not valid in this location.");

   360

	}

   361

	return NULL;

   362

}

   363

   364

void *print_datatypes_error_c::visit(hex_integer_c *symbol) {

   365

	if (symbol->candidate_datatypes.size() == 0) {

   366

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for ANY_INT data type.");

   367

	} else if (NULL == symbol->datatype) {

   368

		STAGE3_ERROR(4, symbol, symbol, "ANY_INT data type not valid in this location.");

   369

	}

   370

	return NULL;

   371

}

   372

   373

void *print_datatypes_error_c::visit(integer_literal_c *symbol) {

   374

	if (symbol->candidate_datatypes.size() == 0) {

   375

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for %s data type.", elementary_type_c::to_string(symbol->type));

   376

	} else if (NULL == symbol->datatype) {

   377

		STAGE3_ERROR(4, symbol, symbol, "ANY_INT data type not valid in this location.");

   378

	}

   379

	return NULL;

   380

}

   381

   382

void *print_datatypes_error_c::visit(real_literal_c *symbol) {

   383

	if (symbol->candidate_datatypes.size() == 0) {

   384

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for %s data type.", elementary_type_c::to_string(symbol->type));

   385

	} else if (NULL == symbol->datatype) {

   386

		STAGE3_ERROR(4, symbol, symbol, "ANY_REAL data type not valid in this location.");

   387

	}

   388

	return NULL;

   389

}

   390

   391

void *print_datatypes_error_c::visit(bit_string_literal_c *symbol) {

   392

	if (symbol->candidate_datatypes.size() == 0) {

   393

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for %s data type.", elementary_type_c::to_string(symbol->type));

   394

	} else if (NULL == symbol->datatype) {

   395

		STAGE3_ERROR(4, symbol, symbol, "ANY_BIT data type not valid in this location.");

   396

	}

   397

	return NULL;

   398

}

   399

   400

void *print_datatypes_error_c::visit(boolean_literal_c *symbol) {

   401

	if (symbol->candidate_datatypes.size() == 0) {

   402

		STAGE3_ERROR(0, symbol, symbol, "Value is not valid for %s data type.", elementary_type_c::to_string(symbol->type));

   403

	} else if (NULL == symbol->datatype) {

   404

		STAGE3_ERROR(4, symbol, symbol, "ANY_BOOL data type not valid in this location.");

   405

	}

   406

	return NULL;

   407

}

   408

   409

void *print_datatypes_error_c::visit(boolean_true_c *symbol) {

   410

	if (symbol->candidate_datatypes.size() == 0) {

   411

		STAGE3_ERROR(0, symbol, symbol, "Value is not valid for ANY_BOOL data type.");

   412

	} else if (NULL == symbol->datatype) {

   413

		STAGE3_ERROR(4, symbol, symbol, "ANY_BOOL data type not valid in this location.");

   414

	}

   415

	return NULL;

   416

}

   417

   418

void *print_datatypes_error_c::visit(boolean_false_c *symbol) {

   419

	if (symbol->candidate_datatypes.size() == 0) {

   420

		STAGE3_ERROR(0, symbol, symbol, "Value is not valid for ANY_BOOL data type.");

   421

	} else if (NULL == symbol->datatype) {

   422

		STAGE3_ERROR(4, symbol, symbol, "ANY_BOOL data type not valid in this location.");

   423

	}

   424

	return NULL;

   425

}

   426

   427

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

   428

/* B.1.2.2   Character Strings */

   429

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

   430

void *print_datatypes_error_c::visit(double_byte_character_string_c *symbol) {

   431

	if (symbol->candidate_datatypes.size() == 0) {

   432

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for WSTRING data type.");

   433

	} else if (NULL == symbol->datatype) {

   434

		STAGE3_ERROR(4, symbol, symbol, "WSTRING data type not valid in this location.");

   435

	}

   436

	return NULL;

   437

}

   438

   439

void *print_datatypes_error_c::visit(single_byte_character_string_c *symbol) {

   440

	if (symbol->candidate_datatypes.size() == 0) {

   441

		STAGE3_ERROR(0, symbol, symbol, "Numerical value exceeds range for STRING data type.");

   442

	} else if (NULL == symbol->datatype) {

   443

		STAGE3_ERROR(4, symbol, symbol, "STRING data type not valid in this location.");

   444

	}

   445

	return NULL;

   446

}

   447

   448

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

   449

/* B 1.2.3 - Time Literals */

   450

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

   451

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

   452

/* B 1.2.3.1 - Duration */

   453

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

   454

void *print_datatypes_error_c::visit(duration_c *symbol) {

   455

	if (symbol->candidate_datatypes.size() == 0) {

   456

		STAGE3_ERROR(0, symbol, symbol, "Invalid syntax for TIME data type.");

   457

	} else if (NULL == symbol->datatype) {

   458

		STAGE3_ERROR(4, symbol, symbol, "TIME data type not valid in this location.");

   459

	}

   460

	return NULL;

   461

}

   462

   463

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

   464

/* B 1.2.3.2 - Time of day and Date */

   465

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

   466

void *print_datatypes_error_c::visit(time_of_day_c *symbol) {

   467

	if (symbol->candidate_datatypes.size() == 0) {

   468

		STAGE3_ERROR(0, symbol, symbol, "Invalid syntax for TOD data type.");

   469

	} else if (NULL == symbol->datatype) {

   470

		STAGE3_ERROR(4, symbol, symbol, "TOD data type not valid in this location.");

   471

	}

   472

	return NULL;

   473

}

   474

   475

void *print_datatypes_error_c::visit(date_c *symbol) {

   476

	if (symbol->candidate_datatypes.size() == 0) {

   477

		STAGE3_ERROR(0, symbol, symbol, "Invalid syntax for DATE data type.");

   478

	} else if (NULL == symbol->datatype) {

   479

		STAGE3_ERROR(4, symbol, symbol, "DATE data type not valid in this location.");

   480

	}

   481

	return NULL;

   482

}

   483

   484

void *print_datatypes_error_c::visit(date_and_time_c *symbol) {

   485

	if (symbol->candidate_datatypes.size() == 0) {

   486

		STAGE3_ERROR(0, symbol, symbol, "Invalid syntax for DT data type.");

   487

	} else if (NULL == symbol->datatype) {

   488

		STAGE3_ERROR(4, symbol, symbol, "DT data type not valid in this location.");

   489

	}

   490

	return NULL;

   491

}

   492

   493

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

   494

/* B 1.3 - Data types */

   495

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

   496

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

   497

/* B 1.3.3 - Derived data types */

   498

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

   499

void *print_datatypes_error_c::visit(data_type_declaration_c *symbol) {

   500

	// TODO !!!

   501

	/* for the moment we must return NULL so semantic analysis of remaining code is not interrupted! */

   502

	return NULL;

   503

}

   504