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) 2011-2012 Manuele Conti (manuele.conti@sirius-es.it)

     6

 *  Copyright (C) 2011-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

/* NOTE: The algorithm implemented here assumes that the symbol_c.candidate_datatype, and the symbol_c.datatype 

    35

 *       annotations have already been apropriately filled in!

    36

 *       BEFORE running this visitor, be sure to CALL the fill_candidate_datatypes_c, and the narrow_candidate_datatypes_c visitors!

    37

 */

    38

    39

    40

/*

    41

 *  By analysing the candidate datatype lists, as well as the chosen datatype for each expression, determine

    42

 *  if an datatype error has been found, and if so, print out an error message.

    43

 */

    44

    45

    46

#include "print_datatypes_error.hh"

    47

#include "datatype_functions.hh"

    48

    49

#include <typeinfo>

    50

#include <list>

    51

#include <string>

    52

#include <string.h>

    53

#include <strings.h>

    54

    55

    56

    57

    58

    59

    60

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

    61

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

    62

    63

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

    64

  if (current_display_error_level >= error_level) {                                                                         \

    65

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

    66

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

    67

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

    68

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    69

    fprintf(stderr, "\n");                                                                                                  \

    70

    il_error = true;                                                                                                        \

    71

    error_count++;                                                                                                     \

    72

  }                                                                                                                         \

    73

}  

    74

    75

    76

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

    77

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

    78

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

    79

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

    80

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    81

    fprintf(stderr, "\n");                                                                                                  \

    82

    warning_found = true;                                                                                                   \

    83

}  

    84

    85

    86

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

    87

static int debug = 0;

    88

    89

print_datatypes_error_c::print_datatypes_error_c(symbol_c *ignore) {

    90

	error_count = 0;

    91

	warning_found = false;

    92

	current_display_error_level = error_level_default;

    93

}

    94

    95

print_datatypes_error_c::~print_datatypes_error_c(void) {

    96

}

    97

    98

int print_datatypes_error_c::get_error_count() {

    99

	return error_count;

   100

}

   101

   102

   103

   104

   105

   106

/* Verify if the datatypes of all symbols in the vector are valid and equal!  */

   107

static bool are_all_datatypes_equal(std::vector <symbol_c *> &symbol_vect) {

   108

	if (symbol_vect.size() <= 0) return false;

   109

   110

	bool res = get_datatype_info_c::is_type_valid(symbol_vect[0]->datatype);

   111

	for (unsigned int i = 1; i < symbol_vect.size(); i++)

   112

		res &= get_datatype_info_c::is_type_equal(symbol_vect[i-1]->datatype, symbol_vect[i]->datatype);	

   113

	return res;

   114

}

   115

   116

   117

   118

   119

   120

/*

   121

typedef struct {

   122

  symbol_c *function_name,

   123

  symbol_c *nonformal_operand_list,

   124

  symbol_c *   formal_operand_list,

   125

   126

  std::vector <symbol_c *> &candidate_functions,  

   127

  symbol_c &*called_function_declaration,

   128

  int      &extensible_param_count

   129

} generic_function_call_t;

   130

*/

   131

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

   132

	symbol_c *param_value, *param_name;

   133

	function_call_param_iterator_c fcp_iterator(fcall);

   134

	bool function_invocation_error = false;

   135

	const char *POU_str = NULL;

   136

   137

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

   138

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

   139

	if (NULL == POU_str) ERROR;

   140

   141

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

   142

		ERROR;

   143

   144

	symbol_c *f_decl = fcall_data.called_function_declaration;

   145

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

   146

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

   147

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

   148

		ERROR;

   149

	}

   150

	if (NULL == f_decl) {

   151

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

   152

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

   153

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

   154

		f_decl = function_symtable.get_value(lower);

   155

	}

   156

   157

	if (NULL != fcall_data.formal_operand_list) {

   158

		fcall_data.formal_operand_list->accept(*this);

   159

		if (NULL != f_decl) {

   160

			function_param_iterator_c fp_iterator(f_decl);

   161

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

   162

				param_value = fcp_iterator.get_current_value();

   163

   164

				/* Check if there are duplicate parameter values */

   165

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

   166

					function_invocation_error = true;

   167

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

   168

					continue; /* jump to next parameter */

   169

				}

   170

   171

				/* Find the corresponding parameter in function declaration */

   172

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

   173

					function_invocation_error = true;

   174

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

   175

					continue; /* jump to next parameter */

   176

				} 

   177

   178

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

   179

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

   180

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

   181

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

   182

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

   183

				if          (function_call_param_iterator_c::assign_in  == call_param_dir) {

   184

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

   185

					    (function_param_iterator_c::direction_inout != param_dir)) {

   186

						function_invocation_error = true;

   187

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

   188

						continue; /* jump to next parameter */

   189

					}

   190

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

   191

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

   192

						function_invocation_error = true;

   193

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

   194

						continue; /* jump to next parameter */

   195

					}

   196

				} else ERROR;

   197

   198

				if (NULL == param_value->datatype) {

   199

					function_invocation_error = true;

   200

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

   201

					continue; /* jump to next parameter */

   202

				}

   203

			}

   204

		}

   205

	}

   206

	if (NULL != fcall_data.nonformal_operand_list) {

   207

		if (f_decl)

   208

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

   209

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

   210

   211

				/* This handle_function_invocation() will be called to handle IL function calls, where the first parameter comes from the previous IL instruction.

   212

				 * In this case, the previous IL instruction will be artifically (and temporarily) added to the begining ot the parameter list

   213

				 * so we (in this function) can handle this situation like all the other function calls.

   214

				 * However, 

   215

				 *     a) if NO previous IL function exists, then we get a fake previous IL function, with no location data (i.e. not found anywhere in the source code.

   216

				 *     b) the function call may actually have several prev IL instructions (if several JMP instructions jump directly to the il function call).

   217

				 * In order to handle these situations gracefully, we first check whether the first parameter is really an IL istruction!

   218

				 */

   219

				il_instruction_c *il_instruction_symbol = dynamic_cast<il_instruction_c *>(param_value);

   220

				if ((NULL != il_instruction_symbol) && (i == 1)) {

   221

					/* We are in a situation where an IL function call is passed the first parameter, which is actually the previous IL instruction */

   222

					/* However, this is really a fake previous il instruction (see visit(il_instruction_c *) )

   223

					 * We will iterate through all the real previous IL instructions, and analyse each of them one by one */

   224

					if (il_instruction_symbol->prev_il_instruction.size() == 0) {

   225

						function_invocation_error = true;

   226

						STAGE3_ERROR(0, fcall, fcall, "No available data to pass to first parameter of IL function %s. Missing a previous LD instruction?", ((identifier_c *)fcall_data.function_name)->value);

   227

					}

   228

#if 0

   229

					/* NOTE: We currently comment out this code...

   230

					 * This does not currently work, since the narrow operation is currently done on the intersection 

   231

					 * of all the previous IL instructions, so we currently either accept them all, or none at all.

   232

					 * In order to be able to produce these user freindly error messages, we will need to update the 

   233

					 * narrow algorithm. We leave this untill somebody aks for it...

   234

					 * So, for now, we simply comment out this code.

   235

					 */

   236

					for (unsigned int p = 0; p < il_instruction_symbol->prev_il_instruction.size(); p++) {

   237

						symbol_c *value = il_instruction_symbol->prev_il_instruction[p];  

   238

						if (!get_datatype_info_c::is_type_valid(value->datatype)) {

   239

							function_invocation_error = true;

   240

							STAGE3_ERROR(0, fcall, fcall, "Data type incompatibility for value passed to first parameter when invoking function '%s'", ((identifier_c *)fcall_data.function_name)->value);

   241

							STAGE3_ERROR(0, value, value, "This is the IL instruction producing the incompatible data type to first parameter of function '%s'", ((identifier_c *)fcall_data.function_name)->value);

   242

						}

   243

					}

   244

#else

   245

					if (!get_datatype_info_c::is_type_valid(il_instruction_symbol->datatype)) {

   246

						function_invocation_error = true;

   247

						STAGE3_ERROR(0, fcall, fcall, "Data type incompatibility between value in IL 'accumulator' and first parameter of function '%s'", ((identifier_c *)fcall_data.function_name)->value);

   248

					}

   249

#endif

   250

					if (function_invocation_error)

   251

						/* when handling a IL function call, and an error is found in the first parameter, then we bug out and do not print out any more error messages. */

   252

						return;

   253

				}

   254

				else if (!get_datatype_info_c::is_type_valid(param_value->datatype)) {

   255

					function_invocation_error = true;

   256

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

   257

				}

   258

			}

   259

	}

   260

   261

	if (NULL == fcall_data.called_function_declaration) {

   262

		function_invocation_error = true;

   263

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

   264

	}

   265

   266

	if (function_invocation_error) {

   267

		/* No compatible function exists */

   268

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

   269

	} 

   270

   271

	return;

   272

}

   273

   274

   275

   276

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

   277

	if (NULL == il_operand) {

   278

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

   279

		return NULL;

   280

	}

   281

	// il_operand->accept(*this);  // NOT required. The il_simple_operation_c already visits it!!

   282

   283

	if (NULL == called_fb_declaration) {

   284

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

   285

		return NULL;

   286

	}

   287

   288

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

   289

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

   290

		return NULL;

   291

	}

   292

   293

	/* Find the corresponding parameter in function declaration */

   294

	function_param_iterator_c fp_iterator(called_fb_declaration);

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

		*        which will not work for an implicit FB call!

   302

		*/

   303

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

   304

		return NULL;

   305

	}

   306

	if (!are_all_datatypes_equal(fake_prev_il_instruction->prev_il_instruction)) {

   307

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

   308

		return NULL;

   309

	}

   310

   311

   312

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

   313

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

   314

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

   315

	 *       be printed out!

   316

	 */

   317

	if (NULL == il_operand->datatype) {

   318

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

   319

// 		if (NULL != fb_declaration) {

   320

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

   321

			return NULL;

   322

// 		}

   323

	}

   324

   325

	return NULL;

   326

}

   327

   328

   329

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

   330

/* B 1.2 - Constants */

   331

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

   332

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

   333

/* B 1.2.1 - Numeric Literals */

   334

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

   335

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

   336

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

   337

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

   338

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

   339

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

   340

	}

   341

	return NULL;

   342

}

   343

   344

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

   345

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

   346

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

   347

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

   348

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

   349

	}

   350

	return NULL;

   351

}

   352

   353

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

   354

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

   355

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

   356

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

   357

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

   358

	}

   359

	return NULL;

   360

}

   361

   362

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

   363

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

   364

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

   365

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

   366

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

   367

	}

   368

	return NULL;

   369

}

   370

   371

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

   372

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

   373

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

   374

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

   375

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

   376

	}

   377

	return NULL;

   378

}

   379

   380

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

   381

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

   382

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

   383

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

   384

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

   385

	}

   386

	return NULL;

   387

}

   388

   389

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

   390

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

   391

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

   392

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

   393

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

   394

	}

   395

	return NULL;

   396

}

   397

   398

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

   399

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

   400

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

   401

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

   402

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

   403

	}

   404

	return NULL;

   405

}

   406

   407

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

   408

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

   409

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

   410

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

   411

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

   412

	}

   413

	return NULL;

   414

}

   415

   416

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

   417

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

   418

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

   419

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

   420

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

   421

	}

   422

	return NULL;

   423

}

   424

   425

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

   426

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

   427

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

   428

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

   429

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

   430

	}

   431

	return NULL;

   432

}

   433

   434

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

   435

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

   436

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

   437

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

   438

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

   439

	}

   440

	return NULL;

   441

}

   442

   443

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

   444

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

   445

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

   446

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

   447

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

   448

	}

   449

	return NULL;

   450

}

   451

   452

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

   453

/* B.1.2.2   Character Strings */

   454

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

   455

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

   456

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

   457

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

   458

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

   459

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

   460

	}

   461

	return NULL;

   462

}

   463

   464

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

   465

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

   466

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

   467

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

   468

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

   469

	}

   470

	return NULL;

   471

}

   472

   473

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

   474

/* B 1.2.3 - Time Literals */

   475

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

   476

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

   477

/* B 1.2.3.1 - Duration */

   478

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

   479

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

   480

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

   481

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

   482

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

   483

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

   484

	}

   485

	return NULL;

   486

}

   487

   488

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

   489

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

   490

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

   491

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

   492

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

   493

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

   494

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

   495

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

   496

	}

   497

	return NULL;

   498

}

   499

   500

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