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

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

    70

static int debug = 0;

    71

    72

print_datatypes_error_c::print_datatypes_error_c(symbol_c *ignore) {

    73

	error_found = false;

    74

	current_display_error_level = error_level_default;

    75

}

    76

    77

print_datatypes_error_c::~print_datatypes_error_c(void) {

    78

}

    79

    80

int print_datatypes_error_c::get_error_found() {

    81

	return error_found;

    82

}

    83

    84

/* a helper function... */

    85

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

    86

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

    87

	 *       in the code.

    88

	 */

    89

	if (symbol == NULL) return NULL;

    90

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

    91

}

    92

    93

    94

    95

    96

/*

    97

typedef struct {

    98

  symbol_c *function_name,

    99

  symbol_c *nonformal_operand_list,

   100

  symbol_c *   formal_operand_list,

   101

   102

  std::vector <symbol_c *> &candidate_functions,  

   103

  symbol_c &*called_function_declaration,

   104

  int      &extensible_param_count

   105

} generic_function_call_t;

   106

*/

   107

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

   108

	symbol_c *param_value, *param_name;

   109

	function_call_param_iterator_c fcp_iterator(fcall);

   110

	bool function_invocation_error = false;

   111

	const char *POU_str = NULL;

   112

   113

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

   114

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

   115

	if (NULL == POU_str) ERROR;

   116

   117

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

   118

		ERROR;

   119

   120

	symbol_c *f_decl = fcall_data.called_function_declaration;

   121

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

   122

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

   123

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

   124

		ERROR;

   125

	}

   126

	if (NULL == f_decl) {

   127

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

   128

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

   129

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

   130

		f_decl = function_symtable.get_value(lower);

   131

	}

   132

   133

	if (NULL != fcall_data.formal_operand_list) {

   134

		fcall_data.formal_operand_list->accept(*this);

   135

		if (NULL != f_decl) {

   136

			function_param_iterator_c fp_iterator(f_decl);

   137

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

   138

				param_value = fcp_iterator.get_current_value();

   139

   140

				/* Check if there are duplicate parameter values */

   141

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

   142

					function_invocation_error = true;

   143

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

   144

					continue; /* jump to next parameter */

   145

				}

   146

   147

				/* Find the corresponding parameter in function declaration */

   148

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

   149

					function_invocation_error = true;

   150

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

   151

					continue; /* jump to next parameter */

   152

				} 

   153

   154

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

   155

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

   156

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

   157

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

   158

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

   159

				if          (function_call_param_iterator_c::assign_in  == call_param_dir) {

   160

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

   161

					    (function_param_iterator_c::direction_inout != param_dir)) {

   162

						function_invocation_error = true;

   163

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

   164

						continue; /* jump to next parameter */

   165

					}

   166

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

   167

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

   168

						function_invocation_error = true;

   169

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

   170

						continue; /* jump to next parameter */

   171

					}

   172

				} else ERROR;

   173

   174

				if (NULL == param_value->datatype) {

   175

					function_invocation_error = true;

   176

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

   177

					continue; /* jump to next parameter */

   178

				}

   179

			}

   180

		}

   181

	}

   182

	if (NULL != fcall_data.nonformal_operand_list) {

   183

		fcall_data.nonformal_operand_list->accept(*this);

   184

		if (f_decl)

   185

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

   186

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

   187

   188

				if (NULL == param_value->datatype) {

   189

					function_invocation_error = true;

   190

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

   191

				}

   192

			}

   193

	}

   194

   195

	if (NULL == fcall_data.called_function_declaration) {

   196

		function_invocation_error = true;

   197

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

   198

	}

   199

   200

	if (function_invocation_error) {

   201

		/* No compatible function exists */

   202

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

   203

	} 

   204

   205

	return;

   206

}

   207

   208

   209

   210

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

   211

	if (NULL == il_operand) {

   212

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

   213

		return;

   214

	}

   215

	il_operand->accept(*this);

   216

   217

	if (NULL == called_fb_declaration) {

   218

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

   219

		return;

   220

	}

   221

   222

	if (NULL == prev_il_instruction) {

   223

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

   224

		return;

   225

	}

   226

   227

	/* Find the corresponding parameter in function declaration */

   228

	function_param_iterator_c fp_iterator(called_fb_declaration);

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

		*        which will not work for an implicit FB call!

   236

		*/

   237

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

   238

		return;

   239

	}

   240

	if (NULL == prev_il_instruction->datatype) {

   241

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

   242

		return;

   243

	}

   244

   245

   246

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

   247

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

   248

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

   249

	 *       be printed out!

   250

	 */

   251

	if (NULL == il_operand->datatype) {

   252

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

   253

// 		if (NULL != fb_declaration) {

   254

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

   255

			return;

   256

// 		}

   257

	}

   258

// 

   259

	return;

   260

}

   261

   262

   263

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

   264

/* B 1.2 - Constants */

   265

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

   266

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

   267

/* B 1.2.1 - Numeric Literals */

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

	}

   275

	return NULL;

   276

}

   277

   278

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

   279

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

   280

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

   281

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

   282

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

   283

	}

   284

	return NULL;

   285

}

   286

   287

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

   288

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

   289

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

   290

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

   291

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

   292

	}

   293

	return NULL;

   294

}

   295

   296

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

   297

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

   298

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

   299

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

   300

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

   301

	}

   302

	return NULL;

   303

}

   304

   305

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

   306

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

   307

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

   308

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

   309

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

   310

	}

   311

	return NULL;

   312

}

   313

   314

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

   315

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

   316

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

   317

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

   318

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

   319

	}

   320

	return NULL;

   321

}

   322

   323

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

   324

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

   325

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

   326

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

   327

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

   328

	}

   329

	return NULL;

   330

}

   331

   332

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

   333

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

   334

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

   335

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

   336

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

   337

	}

   338

	return NULL;

   339

}

   340

   341

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

   342

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

   343

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

   344

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

   345

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

   346

	}

   347

	return NULL;

   348

}

   349

   350

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

   351

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

   352

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

   353

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

   354

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

   355

	}

   356

	return NULL;

   357

}

   358

   359

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

   360

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

   361

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

   362

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

   363

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

   364

	}

   365

	return NULL;

   366

}

   367

   368

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

   369

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

   370

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

   371

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

   372

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

   373

	}

   374

	return NULL;

   375

}

   376

   377

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

   378

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

   379

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

   380

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

   381

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

   382

	}

   383

	return NULL;

   384

}

   385

   386

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

   387

/* B.1.2.2   Character Strings */

   388

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

   389

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

   390

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

   391

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

   392

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

   393

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

   394

	}

   395

	return NULL;

   396

}

   397

   398

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

   399

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

   400

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

   401

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

   402

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

   403

	}

   404

	return NULL;

   405

}

   406

   407

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

   408

/* B 1.2.3 - Time Literals */

   409

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

   410

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

   411

/* B 1.2.3.1 - Duration */

   412

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

   413

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

   414

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

   415

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

   416

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

   417

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

   418

	}

   419

	return NULL;

   420

}

   421

   422

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

   423

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

   424

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

   425

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

   426

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

   427

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

   428

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

   429

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

   430

	}

   431

	return NULL;

   432

}

   433

   434

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

   435

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

   436

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

   437

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

   438

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

   439

	}

   440

	return NULL;

   441

}

   442

   443

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

   444

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

   445

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

   446

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

   447

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

   448

	}

   449

	return NULL;

   450

}

   451

   452

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

   453

/* B 1.3 - Data types */

   454

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

   455

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

   456

/* B 1.3.3 - Derived data types */

   457

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

   458

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

   459

	// TODO !!!

   460

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

   461

	return NULL;

   462

}

   463

   464

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

   465

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

   466

		STAGE3_ERROR(0, symbol, symbol, "Ambiguous enumerate value or Variable not declared in this scope.");

   467

	return NULL;

   468

}

   469

   470

   471

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

   472

/* B 1.4 - Variables */

   473

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

   474

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

   475

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

   476

		STAGE3_ERROR(0, symbol, symbol, "Variable not declared in this scope.");

   477

	return NULL;

   478

}

   479

   480

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

   481

/* B 1.4.1 - Directly Represented Variables */

   482

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

   483

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

   484

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

   485

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

   486

	return NULL;

   487

}

   488

   489

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

   490

/* B 1.4.2 - Multi-element variables */

   491

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

   492

/*  subscripted_variable '[' subscript_list ']' */

   493

// SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   494

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

   495

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

   496

		STAGE3_ERROR(0, symbol, symbol, "Array variable not declared in this scope.");

   497

   498

	/* recursively call the subscript list to print any errors in the expressions used in the subscript...*/

   499

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

   500

	return NULL;

   501

}

   502

   503

/* subscript_list ',' subscript */

   504

// SYM_LIST(subscript_list_c)

   505

/* NOTE: we inherit from iterator visitor, so we do not need to implement this method... */

   506

// void *print_datatypes_error_c::visit(subscript_list_c *symbol)

   507