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

     6

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

/* TODO - things yet not checked by this data type checker...

    36

 *

    37

 * - check variable declarations

    38

 * - check data type declarations

    39

 * - check inside configurations (variable declarations)

    40

 * - check SFC code

    41

 * - must fix S and R IL functions (includes potientialy fixing stage4 code!) 

    42

 */

    43

    44

    45

/* NOTE: The algorithm implemented here assumes that flow control analysis has already been completed!

    46

 *       BEFORE running this visitor, be sure to CALL the flow_control_analysis_c visitor!

    47

 */

    48

    49

    50

/*

    51

 *  Fill the candidate datatype list for all symbols that may legally 'have' a data type (e.g. variables, literals, function calls, expressions, etc.)

    52

 * 

    53

 *  The candidate datatype list will be filled with a list of all the data types that expression may legally take.

    54

 *  For example, the very simple literal '0' (as in foo := 0), may represent a:

    55

 *    BOOL, BYTE, WORD, DWORD, LWORD, USINT, SINT, UINT, INT, UDINT, DINT, ULINT, LINT (as well as the SAFE versions of these data tyes too!)

    56

 *

    57

 * WARNING: This visitor class starts off by building a map of all enumeration constants that are defined in the source code (i.e. a library_c symbol),

    58

 *          and this map is later used to determine the datatpe of each use of an enumeration constant. By implication, the fill_candidate_datatypes_c 

    59

 *          visitor class will only work corretly if it is asked to visit a symbol of class library_c!!

    60

 */

    61

    62

#include <../main.hh>         /* required for UINT64_MAX, INT64_MAX, INT64_MIN, ... */

    63

#include "fill_candidate_datatypes.hh"

    64

#include "datatype_functions.hh"

    65

#include <typeinfo>

    66

#include <list>

    67

#include <string>

    68

#include <string.h>

    69

#include <strings.h>

    70

    71

#define GET_CVALUE(dtype, symbol)             ((symbol)->const_value._##dtype.value)

    72

#define VALID_CVALUE(dtype, symbol)           (symbol_c::cs_const_value == (symbol)->const_value._##dtype.status)

    73

#define IS_OVERFLOW(dtype, symbol)            (symbol_c::cs_overflow == (symbol)->const_value._##dtype.status)

    74

    75

    76

    77

    78

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

    79

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

    80

    81

    82

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

    83

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

    84

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

    85

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

    86

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    87

    fprintf(stderr, "\n");                                                                                                  \

    88

}  

    89

    90

    91

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

    92

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

    93

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

    94

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

    95

    fprintf(stderr, __VA_ARGS__);                                                                                           \

    96

    fprintf(stderr, "\n");                                                                                                  \

    97

}  

    98

    99

   100

   101

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

   102

static int debug = 0;

   103

   104

   105

   106

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

   107

/*                                                   */

   108

/*  A small helper class...                          */

   109

/*                                                   */

   110

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

   111

   112

/* Add to the global_enumerated_value_symtable the global enum value constants, i.e. the enum constants used in the enumerated

   113

 * datatypes that are defined inside a TYPE ... END_TYPE declaration.

   114

 */

   115

/* NOTE: we do not store any NULL values in this symbol table, so we can safely use NULL and the null value. */

   116

   117

symbol_c null_enumvalue_symbol; /* cannot be static, so it may be used in the template!! */

   118

typedef dsymtable_c<symbol_c *, &null_enumvalue_symbol> enumerated_value_symtable_t;

   119

static enumerated_value_symtable_t global_enumerated_value_symtable;

   120

   121

   122

class populate_globalenumvalue_symtable_c: public iterator_visitor_c {

   123

  private:

   124

    symbol_c *current_enumerated_type;

   125

   126

  public:

   127

     populate_globalenumvalue_symtable_c(void) {current_enumerated_type = NULL;};

   128

    ~populate_globalenumvalue_symtable_c(void) {}

   129

   130

  public:

   131

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

   132

  /* B.1 - Common elements */

   133

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

   134

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

   135

  /* B.1.3 - Data types */

   136

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

   137

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

   138

  /* B 1.3.3 - Derived data types */

   139

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

   140

  /*  enumerated_type_name ':' enumerated_spec_init */

   141

  void *visit(enumerated_type_declaration_c *symbol) {

   142

  //current_enumerated_type = symbol->enumerated_type_name;

   143

    current_enumerated_type = symbol;

   144

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

   145

    current_enumerated_type = NULL;

   146

    return NULL;

   147

  }

   148

   149

  /* enumerated_specification ASSIGN enumerated_value */

   150

  void *visit(enumerated_spec_init_c *symbol) {

   151

    return symbol->enumerated_specification->accept(*this);

   152

  }

   153

   154

  /* [enumerated_type_name '#'] identifier */

   155

  void *visit(enumerated_value_c *symbol) {

   156

    if (current_enumerated_type == NULL) ERROR;

   157

    if (symbol->type != NULL) ERROR;

   158

   159

    enumerated_value_symtable_t::iterator lower = global_enumerated_value_symtable.lower_bound(symbol->value);

   160

    enumerated_value_symtable_t::iterator upper = global_enumerated_value_symtable.upper_bound(symbol->value);

   161

    for (; lower != upper; lower++)

   162

      if (lower->second == current_enumerated_type) {

   163

        /*  The same identifier is used more than once as an enumerated value/constant inside the same enumerated datat type! */

   164

        STAGE3_ERROR(0, symbol, symbol, "Duplicate identifier in enumerated data type.");

   165

        return NULL; /* No need to insert it! It is already in the table! */

   166

      }

   167

   168

    global_enumerated_value_symtable.insert(symbol->value, current_enumerated_type);

   169

    return NULL;

   170

  }

   171

   172

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

   173

  /* B.1.5 - Program organization units */

   174

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

   175

  /* B 1.5.1 - Functions */

   176

  void *visit(function_declaration_c *symbol) {return NULL;}

   177

  /* B 1.5.2 - Function Blocks */

   178

  void *visit(function_block_declaration_c *symbol) {return NULL;}

   179

  /* B 1.5.3 - Programs */

   180

  void *visit(program_declaration_c *symbol) {return NULL;}

   181

   182

}; /* populate_globalenumvalue_symtable_c */

   183

   184

static populate_globalenumvalue_symtable_c populate_globalenumvalue_symtable;

   185

   186

   187

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

   188

/*                                                   */

   189

/*  A small helper class...                          */

   190

/*                                                   */

   191

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

   192

   193

/* Add to the local_enumerated_value_symtable the local enum value constants */

   194

/* Notes:

   195

 * Some enumerations are 

   196

 *   (A) declared anonymously inside a VAR ... END_VAR declaration

   197

 *       (e.g. VAR enum_var : (enumvalue1, enumvalue2); END_VAR)

   198

 *  while others are 

   199

 *   (B) declared (with a name) inside a TYPE .. END_TYPE declaration.

   200

 *

   201

 *  Values in (A) are added to the enumerated_value_symtable in absyntaxt_utils.cc.

   202

 *  Values in (B) are only in scope inside the POU with the VAR END_VAR declaration.

   203

 *

   204

 * This class will add the enum values in (B) to the local_enumerated_value_symtable.

   205

 *

   206

 * If a locally defined enum value is identical to another locally defined enum_value, a 

   207

 *  duplicate entry is created.

   208

 *  However, if a locally defined enum value is identical to another globally defined enum_value, the

   209

 *  corresponding entry in local_enumerated_value_symtable is also set to the local datatype.

   210

 *  This is because anonynous locally feined enum datatypes are anonymous, and its enum values cannot therefore

   211

 *  be disambiguated using EnumType#enum_value (since the enum type does not have a name, it is anonymous!).

   212

 *  For this reason we implement the semantics where locally defined enum values, when in scope, will 'cover'

   213

 *  the globally defined enum value with the same name/identifier.

   214

 *  For example:

   215

 *

   216

 *  TYPE  GlobalEnumT: (xxx1, xxx2, xxx3) END_TYPE

   217

 * 

   218

 *   FUNCTION_BLOCK FOO

   219

 *    VAR_INPUT

   220

 *       GlobalEnumVar: GlobalEnumT;

   221

 *      LocalEnumVar : (xxx1, yyy2, yyy3);

   222

 *     END_VAR

   223

 *     LocalEnumVar  := xxx1;   <-- We consider it OK!!!     xxx1 will reference the anonymous type used for LocalEnumVar

   224

 *     GlobalEnumVar := xxx1;   <-- We consider it an error. xxx1 will reference the anonymous type used for LocalEnumVar

   225

 *     GlobalEnumVar := GlobalEnumT#xxx1;

   226

 *     END_FUNCTION_BLOCK

   227

 */

   228

   229

static enumerated_value_symtable_t local_enumerated_value_symtable;

   230

   231

   232

class populate_enumvalue_symtable_c: public iterator_visitor_c {

   233

  private:

   234

    symbol_c *current_enumerated_type;

   235

   236

  public:

   237

     populate_enumvalue_symtable_c(void) {current_enumerated_type = NULL;};

   238

    ~populate_enumvalue_symtable_c(void) {}

   239

   240

  public:

   241

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

   242

  /* B.1 - Common elements */

   243

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

   244

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

   245

  /* B.1.3 - Data types */

   246

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

   247

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

   248

  /* B 1.3.3 - Derived data types */

   249

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

   250

  /*  TYPE type_declaration_list END_TYPE */

   251

  void *visit(data_type_declaration_c *symbol) {return NULL;} // do not visit the type declarations!!

   252

   253

  /* enumerated_specification ASSIGN enumerated_value */

   254

  void *visit(enumerated_spec_init_c *symbol) {

   255

    current_enumerated_type = symbol;

   256

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

   257

    /* DO NOT visit the symbol->enumerated_value   !!! */

   258

    current_enumerated_type = NULL;

   259

    return NULL;

   260

  }

   261

   262

  /* [enumerated_type_name '#'] identifier */

   263

  void *visit(enumerated_value_c *symbol) {

   264

    /* if the enumerated_value_c is not inside a enumerated_spec_init_c (e.g. used as the inital value of a variable), we simply return */

   265

    if (current_enumerated_type == NULL) return NULL;  

   266

    /* this is really an ERROR! The initial value may use the syntax NUM_TYPE#enum_value, but in that case we should have return'd in the above statement !! */

   267

    if (symbol->type != NULL) ERROR;  

   268

   269

    enumerated_value_symtable_t::iterator lower = local_enumerated_value_symtable.lower_bound(symbol->value);

   270

    enumerated_value_symtable_t::iterator upper = local_enumerated_value_symtable.upper_bound(symbol->value);

   271

    for (; lower != upper; lower++)

   272

      if (lower->second == current_enumerated_type) {

   273

        /*  The same identifier is used more than once as an enumerated value/constant inside the same enumerated datat type! */

   274

        STAGE3_ERROR(0, symbol, symbol, "Duplicate identifier in enumerated data type.");

   275

        return NULL; /* No need to insert it! It is already in the table! */

   276

      }

   277

   278

    /* add it to the local symbol table. */

   279

    local_enumerated_value_symtable.insert(symbol->value, current_enumerated_type);

   280

    return NULL;

   281

  }

   282

}; // class populate_enumvalue_symtable_c

   283

   284

static populate_enumvalue_symtable_c populate_enumvalue_symtable;

   285

   286

   287

   288

   289

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

   290

/*                                                   */

   291

/*  Main  FILL candidate datatypes algorithm...      */

   292

/*                                                   */

   293

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

   294

   295

   296

fill_candidate_datatypes_c::fill_candidate_datatypes_c(symbol_c *ignore) {

   297

	il_operand = NULL;

   298

	prev_il_instruction = NULL;

   299

	search_varfb_instance_type = NULL;

   300

	current_enumerated_spec_type = NULL;

   301

}

   302

   303

fill_candidate_datatypes_c::~fill_candidate_datatypes_c(void) {

   304

}

   305

   306

   307

   308

   309

   310

   311

   312

symbol_c *fill_candidate_datatypes_c::widening_conversion(symbol_c *left_type, symbol_c *right_type, const struct widen_entry widen_table[]) {

   313

	int k;

   314

	/* find a widening table entry compatible */

   315

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

   316

		if ((typeid(*left_type) == typeid(*widen_table[k].left)) && (typeid(*right_type) == typeid(*widen_table[k].right)))

   317

                      return widen_table[k].result;

   318

	return NULL;

   319

}

   320

   321

   322

/* add a data type to a candidate data type list, while guaranteeing no duplicate entries! */

   323

/* Returns true if it really did add the datatype to the list, or false if it was already present in the list! */

   324

bool fill_candidate_datatypes_c::add_datatype_to_candidate_list(symbol_c *symbol, symbol_c *datatype) {

   325

  /* If it is an invalid data type, do not insert!

   326

   * NOTE: it reduces overall code size to do this test here, instead of doing every time before calling the add_datatype_to_candidate_list() function. 

   327

   */

   328

  if (!get_datatype_info_c::is_type_valid(datatype)) /* checks for NULL and invalid_type_name_c */

   329

    return false;

   330

   331

  if (search_in_candidate_datatype_list(datatype, symbol->candidate_datatypes) >= 0) 

   332

    /* already in the list, Just return! */

   333

    return false;

   334

   335

  /* not yet in the candidate data type list, so we insert it now! */

   336

  symbol->candidate_datatypes.push_back(datatype);

   337

  return true;

   338

}

   339

   340

   341

bool fill_candidate_datatypes_c::add_2datatypes_to_candidate_list(symbol_c *symbol, symbol_c *datatype1, symbol_c *datatype2) {

   342

  add_datatype_to_candidate_list(symbol, datatype1);

   343

  add_datatype_to_candidate_list(symbol, datatype2);

   344

  return true;

   345

}

   346

   347

   348

   349

void fill_candidate_datatypes_c::remove_incompatible_datatypes(symbol_c *symbol) {

   350

  #ifdef __REMOVE__

   351

    #error __REMOVE__ macro already exists. Choose another name!

   352

  #endif

   353

  #define __REMOVE__(datatype)\

   354

      remove_from_candidate_datatype_list(&get_datatype_info_c::datatype,       symbol->candidate_datatypes);\

   355

      remove_from_candidate_datatype_list(&get_datatype_info_c::safe##datatype, symbol->candidate_datatypes);

   356

   357

  {/* Remove unsigned data types */

   358

    uint64_t value = 0;

   359

    if (VALID_CVALUE( uint64, symbol)) value = GET_CVALUE(uint64, symbol);

   360

    if (IS_OVERFLOW ( uint64, symbol)) value = (uint64_t)UINT32_MAX + (uint64_t)1;

   361

   362

    if (value > 1          )          {__REMOVE__(bool_type_name);}

   363

    if (value > UINT8_MAX  )          {__REMOVE__(usint_type_name);  __REMOVE__( byte_type_name);}

   364

    if (value > UINT16_MAX )          {__REMOVE__( uint_type_name);  __REMOVE__( word_type_name);}

   365

    if (value > UINT32_MAX )          {__REMOVE__(udint_type_name);  __REMOVE__(dword_type_name);}

   366

    if (IS_OVERFLOW( uint64, symbol)) {__REMOVE__(ulint_type_name);  __REMOVE__(lword_type_name);}

   367

  }

   368

   369

  {/* Remove signed data types */

   370

    int64_t value = 0;

   371

    if (VALID_CVALUE(  int64, symbol)) value = GET_CVALUE(int64, symbol);

   372

    if (IS_OVERFLOW (  int64, symbol)) value = (int64_t)INT32_MAX + (int64_t)1;

   373

   374

    if ((value <  INT8_MIN) || (value >  INT8_MAX)) {__REMOVE__(sint_type_name);}

   375

    if ((value < INT16_MIN) || (value > INT16_MAX)) {__REMOVE__( int_type_name);}

   376

    if ((value < INT32_MIN) || (value > INT32_MAX)) {__REMOVE__(dint_type_name);}

   377

    if (IS_OVERFLOW( int64, symbol))                {__REMOVE__(lint_type_name);}

   378

  }

   379

   380

  {/* Remove floating point data types */

   381

    real64_t value = 0;

   382

    if (VALID_CVALUE( real64, symbol)) value = GET_CVALUE(real64, symbol);

   383

    if (IS_OVERFLOW ( real64, symbol)) value = (real64_t)REAL32_MAX + (real64_t)1;

   384

    if (value >  REAL32_MAX )         {__REMOVE__( real_type_name);}

   385

    if (value < -REAL32_MAX )         {__REMOVE__( real_type_name);}

   386

    if (IS_OVERFLOW( real64, symbol)) {__REMOVE__(lreal_type_name);}

   387

  }

   388

  #undef __REMOVE__

   389

}

   390

   391

   392

/* returns true if compatible function/FB invocation, otherwise returns false */

   393

/* Assumes that the candidate_datatype lists of all the parameters being passed haved already been filled in */

   394

/*

   395

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

   396

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

   397

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

   398

 */

   399

bool fill_candidate_datatypes_c::match_nonformal_call(symbol_c *f_call, symbol_c *f_decl) {

   400

	symbol_c *call_param_value,  *param_datatype;

   401

	identifier_c *param_name;

   402

	function_param_iterator_c       fp_iterator(f_decl);

   403

	function_call_param_iterator_c fcp_iterator(f_call);

   404

	int extensible_parameter_highest_index = -1;

   405

	unsigned int i;

   406

   407

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

   408

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

   409

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

   410

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

   411

		 */

   412

		do {

   413

			param_name = fp_iterator.next();

   414

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

   415

			if(param_name == NULL) return false;

   416

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

   417

   418

		/* Get the parameter type */

   419

		param_datatype = base_type(fp_iterator.param_type());

   420

   421

		/* check whether one of the candidate_data_types of the value being passed is the same as the param_type */

   422

		if (search_in_candidate_datatype_list(param_datatype, call_param_value->candidate_datatypes) < 0)

   423

			return false; /* return false if param_type not in the list! */

   424

	}

   425

	/* call is compatible! */

   426

	return true;

   427

}

   428

   429

   430

   431

/* returns true if compatible function/FB invocation, otherwise returns false */

   432

/* Assumes that the candidate_datatype lists of all the parameters being passed haved already been filled in */

   433

bool fill_candidate_datatypes_c::match_formal_call(symbol_c *f_call, symbol_c *f_decl, symbol_c **first_param_datatype) {

   434

	symbol_c *call_param_value, *call_param_name, *param_datatype;

   435

	symbol_c *verify_duplicate_param;

   436

	identifier_c *param_name;

   437

	function_param_iterator_c       fp_iterator(f_decl);

   438

	function_call_param_iterator_c fcp_iterator(f_call);

   439

	int extensible_parameter_highest_index = -1;

   440

	identifier_c *extensible_parameter_name;

   441

	unsigned int i;

   442

	bool is_first_param = true;

   443

   444

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

   445

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

   446

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

   447

		call_param_value = fcp_iterator.get_current_value();

   448

		/* the following should never occur. If it does, then we have a bug in our code... */

   449

		if (NULL == call_param_value) ERROR;

   450

   451

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

   452

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

   453

   454

		/* Checking if there are duplicated parameter values */

   455

		verify_duplicate_param = fcp_iterator.search_f(call_param_name);

   456

		if(verify_duplicate_param != call_param_value)

   457

			return false;

   458

   459

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

   460

		std::vector <symbol_c *>&call_param_types = call_param_value->candidate_datatypes;

   461

   462

		/* Find the corresponding parameter in function declaration */

   463

		param_name = fp_iterator.search(call_param_name);

   464

		if(param_name == NULL) return false;

   465

		/* Get the parameter data type */

   466

		param_datatype = base_type(fp_iterator.param_type());

   467

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

   468

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

   469

   470

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

   471

		if          (function_call_param_iterator_c::assign_in  == call_param_dir) {

   472

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

   473

			    (function_param_iterator_c::direction_inout != param_dir))

   474

				return false;

   475

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

   476

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

   477

				return false;

   478

		} else ERROR;

   479

   480

		/* check whether one of the candidate_data_types of the value being passed is the same as the param_type */

   481

		if (search_in_candidate_datatype_list(param_datatype, call_param_types) < 0)

   482

			return false; /* return false if param_type not in the list! */

   483

   484

		/* If this is the first parameter, then copy the datatype to *first_param_datatype */

   485

		if (is_first_param)

   486

			if (NULL != first_param_datatype)

   487

				*first_param_datatype = param_datatype;

   488

		is_first_param = false;

   489

	}

   490

	/* call is compatible! */

   491

	return true;

   492

}

   493

   494

   495

   496