1

/*

     2

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

     3

 *

     4

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

     5

 *  Copyright (C) 2012       Manuele Conti  (conti.ma@alice.it)

     6

 *

     7

 *  This program is free software: you can redistribute it and/or modify

     8

 *  it under the terms of the GNU General Public License as published by

     9

 *  the Free Software Foundation, either version 3 of the License, or

    10

 *  (at your option) any later version.

    11

 *

    12

 *  This program is distributed in the hope that it will be useful,

    13

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    14

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15

 *  GNU General Public License for more details.

    16

 *

    17

 *  You should have received a copy of the GNU General Public License

    18

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    19

 *

    20

 *

    21

 * This code is made available on the understanding that it will not be

    22

 * used in safety-critical situations without a full and competent review.

    23

 */

    24

    25

#include "datatype_functions.hh"

    26

#include "../absyntax_utils/absyntax_utils.hh"

    27

#include <vector>

    28

// #include <algorithm>

    29

    30

    31

    32

    33

    34

elementary_type_c *elementary_type_c::singleton = NULL;

    35

    36

const char *elementary_type_c::to_string(symbol_c *symbol) {

    37

  if (NULL == singleton)    singleton = new elementary_type_c;

    38

  if (NULL == singleton)    ERROR;

    39

  const char *res           = (const char *)symbol->accept(*singleton);

    40

  if (NULL == res) {

    41

	  int i = 1;

    42

  }

    43

  return res;

    44

}

    45

    46

    47

    48

    49

    85

/*

    86

 * 2.5.1.5.6 Functions of time data types

    87

 * Table 30 - page 64

    88

 */

    89

    90

const struct widen_entry widen_ADD_table[] = {

    91

    { &search_constant_type_c::time_type_name,          &search_constant_type_c::time_type_name,            &search_constant_type_c::time_type_name, widen_entry::ok         },

    92

    { &search_constant_type_c::tod_type_name,           &search_constant_type_c::time_type_name,            &search_constant_type_c::tod_type_name, widen_entry::deprecated },

    93

    /* NOTE: the standard des not explicitly support the following semantics. However, since 'addition' is supposed to be commutative, we add it anyway... */

    94

    { &search_constant_type_c::time_type_name,          &search_constant_type_c::tod_type_name,             &search_constant_type_c::tod_type_name, widen_entry::deprecated },

    95

    { &search_constant_type_c::dt_type_name,            &search_constant_type_c::time_type_name,            &search_constant_type_c::dt_type_name, widen_entry::deprecated },         

    96

    /* NOTE: the standard des not explicitly support the following semantics. However, since 'addition' is supposed to be commutative, we add it anyway... */

    97

    { &search_constant_type_c::time_type_name,          &search_constant_type_c::dt_type_name,              &search_constant_type_c::dt_type_name, widen_entry::deprecated },         

    98

    99

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

   100

    /* SAFE version on the left... */

   101

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

   109

   110

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

   111

    /* SAFE version on the right... */

   112

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

   120

   121

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

   122

    /* SAFE version on left and right... */

   123

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

   124

    { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::safetime_type_name,        &search_constant_type_c::safetime_type_name, widen_entry::ok         },

   131

   132

    { NULL, NULL, NULL, widen_entry::ok },

   133

};

   134

   135

   136

   137

   141

const struct widen_entry widen_SUB_table[] = {

   148

   149

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

   150

    /* SAFE version on the left... */

   151

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

   158

   159

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

   160

    /* SAFE version on the right... */

   161

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

   168

   169

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

   170

    /* SAFE version on left and right... */

   171

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

   172

    { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::safetime_type_name,            &search_constant_type_c::safetime_type_name, widen_entry::ok         },

   173

    { &search_constant_type_c::safedate_type_name,      &search_constant_type_c::safedate_type_name,            &search_constant_type_c::safetime_type_name, widen_entry::deprecated },

   175

    { &search_constant_type_c::safetod_type_name,       &search_constant_type_c::safetod_type_name,             &search_constant_type_c::safetime_type_name, widen_entry::deprecated },

   177

    { &search_constant_type_c::safedt_type_name,        &search_constant_type_c::safedt_type_name,              &search_constant_type_c::safetime_type_name, widen_entry::deprecated },        

   178

   179

    { NULL, NULL, NULL, widen_entry::ok },

   180

};

   181

   182

   183

   184

   185

   186

   187

   188

const struct widen_entry widen_MUL_table[] = {

   202

   203

    { NULL, NULL, NULL, widen_entry::ok },

   204

};

   205

   210

const struct widen_entry widen_DIV_table[] = {

   218

   219

    { NULL, NULL, NULL, widen_entry::ok },

   220

 };

   221

   222

   223

   224

/* Search for a datatype inside a candidate_datatypes list.

   225

 * Returns: position of datatype in the list, or -1 if not found.

   226

 */

   227

int search_in_candidate_datatype_list(symbol_c *datatype, std::vector <symbol_c *> candidate_datatypes) {

   228

	if (NULL == datatype) 

   229

		return -1;

   230

   231

	for(unsigned int i = 0; i < candidate_datatypes.size(); i++)

   232

		if (is_type_equal(datatype, candidate_datatypes[i]))

   233

			return i;

   234

	/* Not found ! */

   235

	return -1;

   236

}

   237

   238

   239

   240

   241

   242

   243

   244

/* Intersect two candidate_datatype_lists.

   245

 * Remove from list1 (origin, dest.) all elements that are not found in list2 (with).

   246

 * In essence, list1 will contain the result of the intersection of list1 with list2.

   247

 * In other words, modify list1 so it only contains the elelements that are simultaneously in list1 and list2!

   248

 */

   249

void intersect_candidate_datatype_list(symbol_c *list1 /*origin, dest.*/, symbol_c *list2 /*with*/) {

   250

	if ((NULL == list1) || (NULL == list2))

   251

		/* In principle, we should never call it with NULL values. Best to abort the compiler just in case! */

   252

		return;

   253

   254

	for(std::vector<symbol_c *>::iterator i = list1->candidate_datatypes.begin(); i < list1->candidate_datatypes.end(); ) {

   255

		/* Note that we do _not_ increment i in the for() loop!

   256

		 * When we erase an element from position i, a new element will take it's place, that must also be tested! 

   257

		 */

   258

		if (search_in_candidate_datatype_list(*i, list2->candidate_datatypes) < 0)

   259

			/* remove this element! This will change the value of candidate_datatypes.size() */

   260

			list1->candidate_datatypes.erase(i);

   261

		else i++;

   262

	}

   263

}

   264

   265

   266

   267

   268

/* intersect the candidate_datatype lists of all prev_il_intructions, and set the local candidate_datatype list to the result! */

   269

void intersect_prev_candidate_datatype_lists(il_instruction_c *symbol) {

   270

	if (symbol->prev_il_instruction.empty())

   271

		return;

   272

   273

	symbol->candidate_datatypes = symbol->prev_il_instruction[0]->candidate_datatypes;

   274

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

   275

		intersect_candidate_datatype_list(symbol /*origin, dest.*/, symbol->prev_il_instruction[i] /*with*/);

   276

	}  

   277

}

   278

   279

   280

   281

   282

/* A helper function... */

   283

bool is_ANY_ELEMENTARY_type(symbol_c *type_symbol) {

   284

  if (type_symbol == NULL) {return false;}

   285

  return is_ANY_MAGNITUDE_type(type_symbol)

   286

      || is_ANY_BIT_type      (type_symbol)

   287

      || is_ANY_STRING_type   (type_symbol)

   288

      || is_ANY_DATE_type     (type_symbol);

   289

}

   290

   291

/* A helper function... */

   292

bool is_ANY_SAFEELEMENTARY_type(symbol_c *type_symbol) {

   293

  if (type_symbol == NULL) {return false;}

   294

  return is_ANY_SAFEMAGNITUDE_type(type_symbol)

   295

      || is_ANY_SAFEBIT_type      (type_symbol)

   296

      || is_ANY_SAFESTRING_type   (type_symbol)

   297

      || is_ANY_SAFEDATE_type     (type_symbol);

   298

}

   299

   300

/* A helper function... */

   301

bool is_ANY_ELEMENTARY_compatible(symbol_c *type_symbol) {

   302

  if (type_symbol == NULL) {return false;}

   303

  /* NOTE: doing

   304

   *          return is_ANY_SAFEELEMENTARY_type() || is_ANY_ELEMENTARY_type()

   305

   *       is incorrect, as the literals would never be considered compatible...

   306

   */

   307

  return is_ANY_MAGNITUDE_compatible(type_symbol)

   308

      || is_ANY_BIT_compatible      (type_symbol)

   309

      || is_ANY_STRING_compatible   (type_symbol)

   310

      || is_ANY_DATE_compatible     (type_symbol);

   311

}

   312

   313

   314

/* A helper function... */

   315

bool is_ANY_MAGNITUDE_type(symbol_c *type_symbol) {

   316

  if (type_symbol == NULL) {return false;}

   317

  if (typeid(*type_symbol) == typeid(time_type_name_c)) {return true;}

   318

  return is_ANY_NUM_type(type_symbol);

   319

}

   320

   321

/* A helper function... */

   322

bool is_ANY_signed_MAGNITUDE_type(symbol_c *type_symbol) {

   323

  if (type_symbol == NULL) {return false;}

   324

  if (typeid(*type_symbol) == typeid(time_type_name_c)) {return true;}

   325

  return is_ANY_signed_NUM_type(type_symbol);

   326

}

   327

   328

/* A helper function... */

   329

bool is_ANY_SAFEMAGNITUDE_type(symbol_c *type_symbol) {

   330

  if (type_symbol == NULL) {return false;}

   331

  if (typeid(*type_symbol) == typeid(safetime_type_name_c)) {return true;}

   332

  return is_ANY_SAFENUM_type(type_symbol);

   333

}

   334

   335

/* A helper function... */

   336

bool is_ANY_signed_SAFEMAGNITUDE_type(symbol_c *type_symbol) {

   337

  if (type_symbol == NULL) {return false;}

   338

  if (typeid(*type_symbol) == typeid(safetime_type_name_c)) {return true;}

   339

  return is_ANY_signed_SAFENUM_type(type_symbol);

   340

}

   341

   342

/* A helper function... */

   343

bool is_ANY_MAGNITUDE_compatible(symbol_c *type_symbol) {

   344

  if (type_symbol == NULL) {return false;}

   345

  if (is_ANY_MAGNITUDE_type    (type_symbol))              {return true;}

   346

  if (is_ANY_SAFEMAGNITUDE_type(type_symbol))              {return true;}

   347

  return is_ANY_NUM_compatible(type_symbol);

   348

}

   349

   350

/* A helper function... */

   351

bool is_ANY_signed_MAGNITUDE_compatible(symbol_c *type_symbol) {

   352

  if (type_symbol == NULL) {return false;}

   353

  if (is_ANY_signed_MAGNITUDE_type    (type_symbol))       {return true;}

   354

  if (is_ANY_signed_SAFEMAGNITUDE_type(type_symbol))       {return true;}

   355

  return is_ANY_signed_NUM_compatible(type_symbol);

   356

}

   357

   358

/* A helper function... */

   359

bool is_ANY_NUM_type(symbol_c *type_symbol) {

   360

  if (type_symbol == NULL) {return false;}

   361

  if (is_ANY_REAL_type(type_symbol))                       {return true;}

   362

  if (is_ANY_INT_type(type_symbol))                        {return true;}

   363

  return false;

   364

}

   365

   366

/* A helper function... */

   367

bool is_ANY_signed_NUM_type(symbol_c *type_symbol) {

   368

  if (type_symbol == NULL) {return false;}

   369

  if (is_ANY_REAL_type(type_symbol))                       {return true;}

   370

  if (is_ANY_signed_INT_type(type_symbol))                 {return true;}

   371

  return false;

   372

}

   373

   374

/* A helper function... */

   375

bool is_ANY_SAFENUM_type(symbol_c *type_symbol) {

   376

  if (type_symbol == NULL) {return false;}

   377

  return is_ANY_SAFEREAL_type(type_symbol)

   378

      || is_ANY_SAFEINT_type (type_symbol);

   379

}

   380

   381

/* A helper function... */

   382

bool is_ANY_signed_SAFENUM_type(symbol_c *type_symbol) {

   383

  if (type_symbol == NULL) {return false;}

   384

  return is_ANY_SAFEREAL_type(type_symbol)

   385

      || is_ANY_signed_SAFEINT_type (type_symbol);

   386

}

   387

   388

/* A helper function... */

   389

bool is_ANY_NUM_compatible(symbol_c *type_symbol) {

   390

  if (type_symbol == NULL) {return false;}

   391

  if (is_ANY_REAL_compatible(type_symbol))                       {return true;}

   392

  if (is_ANY_INT_compatible(type_symbol))                        {return true;}

   393

  return false;

   394

}

   395

   396

/* A helper function... */

   397

bool is_ANY_signed_NUM_compatible(symbol_c *type_symbol) {

   398

  if (type_symbol == NULL) {return false;}

   399

  if (is_ANY_REAL_compatible(type_symbol))                       {return true;}

   400

  if (is_ANY_signed_INT_compatible(type_symbol))                 {return true;}

   401

  return false;

   402

}

   403

   404

/* A helper function... */

   405

bool is_ANY_DATE_type(symbol_c *type_symbol) {

   406

  if (type_symbol == NULL) {return false;}

   407

  if (typeid(*type_symbol) == typeid(date_type_name_c)) {return true;}

   408

  if (typeid(*type_symbol) == typeid(tod_type_name_c))  {return true;}

   409

  if (typeid(*type_symbol) == typeid(dt_type_name_c))   {return true;}

   410

  return false;

   411

}

   412

   413

/* A helper function... */

   414

bool is_ANY_SAFEDATE_type(symbol_c *type_symbol) {

   415

  if (type_symbol == NULL) {return false;}

   416

  if (typeid(*type_symbol) == typeid(safedate_type_name_c)) {return true;}

   417

  if (typeid(*type_symbol) == typeid(safetod_type_name_c))  {return true;}

   418

  if (typeid(*type_symbol) == typeid(safedt_type_name_c))   {return true;}

   419

  return false;

   420

}

   421

   422

/* A helper function... */

   423

bool is_ANY_DATE_compatible(symbol_c *type_symbol) {

   424

  if (type_symbol == NULL) {return false;}

   425

  if (is_ANY_DATE_type    (type_symbol))              {return true;}

   426

  if (is_ANY_SAFEDATE_type(type_symbol))              {return true;}

   427

  return false;

   428

}

   429

   430

/* A helper function... */

   431

bool is_ANY_STRING_type(symbol_c *type_symbol) {

   432

  if (type_symbol == NULL) {return false;}

   433

  if (typeid(*type_symbol) == typeid(string_type_name_c)) {return true;}

   434

  if (typeid(*type_symbol) == typeid(wstring_type_name_c)) {return true;}

   435

  return false;

   436

}

   437

   438

/* A helper function... */

   439

bool is_ANY_SAFESTRING_type(symbol_c *type_symbol) {

   440

  if (type_symbol == NULL) {return false;}

   441

  if (typeid(*type_symbol) == typeid(safestring_type_name_c)) {return true;}

   442

  if (typeid(*type_symbol) == typeid(safewstring_type_name_c)) {return true;}

   443

  return false;

   444

}

   445

   446

/* A helper function... */

   447

bool is_ANY_STRING_compatible(symbol_c *type_symbol) {

   448

  if (type_symbol == NULL) {return false;}

   449

  if (is_ANY_STRING_type    (type_symbol))              {return true;}

   450

  if (is_ANY_SAFESTRING_type(type_symbol))              {return true;}

   451

  return false;

   452

}

   453

   454

/* A helper function... */

   455

bool is_ANY_INT_type(symbol_c *type_symbol) {

   456

  if (type_symbol == NULL) {return false;}

   457

  if (typeid(*type_symbol) == typeid(sint_type_name_c))  {return true;}

   458

  if (typeid(*type_symbol) == typeid(int_type_name_c))   {return true;}

   459

  if (typeid(*type_symbol) == typeid(dint_type_name_c))  {return true;}

   460

  if (typeid(*type_symbol) == typeid(lint_type_name_c))  {return true;}

   461

  if (typeid(*type_symbol) == typeid(usint_type_name_c)) {return true;}

   462

  if (typeid(*type_symbol) == typeid(uint_type_name_c))  {return true;}

   463

  if (typeid(*type_symbol) == typeid(udint_type_name_c)) {return true;}

   464

  if (typeid(*type_symbol) == typeid(ulint_type_name_c)) {return true;}

   465

  return false;

   466

}

   467

   468

/* A helper function... */

   469

bool is_ANY_signed_INT_type(symbol_c *type_symbol) {

   470

  if (type_symbol == NULL) {return false;}

   471

  if (typeid(*type_symbol) == typeid(sint_type_name_c))  {return true;}

   472

  if (typeid(*type_symbol) == typeid(int_type_name_c))   {return true;}

   473

  if (typeid(*type_symbol) == typeid(dint_type_name_c))  {return true;}

   474

  if (typeid(*type_symbol) == typeid(lint_type_name_c))  {return true;}

   475

  return false;

   476

}

   477

   478

/* A helper function... */

   479

bool is_ANY_signed_SAFEINT_type(symbol_c *type_symbol) {

   480

  if (type_symbol == NULL) {return false;}

   481

  if (typeid(*type_symbol) == typeid(safesint_type_name_c))  {return true;}

   482

  if (typeid(*type_symbol) == typeid(safeint_type_name_c))   {return true;}

   483

  if (typeid(*type_symbol) == typeid(safedint_type_name_c))  {return true;}

   484

  if (typeid(*type_symbol) == typeid(safelint_type_name_c))  {return true;}

   485

  return false;

   486

}

   487

   488

/* A helper function... */

   489

bool is_ANY_SAFEINT_type(symbol_c *type_symbol) {

   490

  if (type_symbol == NULL) {return false;}

   491

  if (typeid(*type_symbol) == typeid(safesint_type_name_c))  {return true;}

   492

  if (typeid(*type_symbol) == typeid(safeint_type_name_c))   {return true;}

   493

  if (typeid(*type_symbol) == typeid(safedint_type_name_c))  {return true;}

   494

  if (typeid(*type_symbol) == typeid(safelint_type_name_c))  {return true;}

   495

  if (typeid(*type_symbol) == typeid(safeusint_type_name_c)) {return true;}

   496

  if (typeid(*type_symbol) == typeid(safeuint_type_name_c))  {return true;}

   497

  if (typeid(*type_symbol) == typeid(safeudint_type_name_c)) {return true;}

   498

  if (typeid(*type_symbol) == typeid(safeulint_type_name_c)) {return true;}

   499

  return false;

   500

}

   501

   502

/* A helper function... */

   503

bool is_ANY_signed_INT_compatible(symbol_c *type_symbol) {

   504

  if (type_symbol == NULL) {return false;}

   505

  if (is_ANY_signed_INT_type    (type_symbol))              {return true;}