1

/*

     2

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

     3

 *

     4

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

     5

 *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant

     6

 *  Copyright (C) 2012       Manuele Conti  (conti.ma@alice.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

/* Determine the characteristics of a specific data type

    35

 *  e.g., is it an enumeration, is it an array, is it ANY_INT, etc...

    36

 *

    37

 * The methods of this class may be passed either:

    38

 *  - a data type declaration symbol_c, 

    39

 *   OR

    40

 *  - the name of a data type (identifier_c)

    41

 *    In this case, we shall first serach for the basetype declaration using search_base_type_c, and then 

    42

 *    run the normal process.

    43

 */

    44

#include "absyntax_utils.hh"

    45

    46

#include "../main.hh" // required for ERROR() and ERROR_MSG() macros.

    47

    48

    49

    50

#include <typeinfo>  // required for typeid

    51

    52

    53

    54

    55

    56

    57

static search_base_type_c search_base_type;

    58

    59

    60

    61

    62

    63

bool get_datatype_info_c::is_type_equal(symbol_c *first_type, symbol_c *second_type) {

    64

  if ((NULL == first_type) || (NULL == second_type))                 {return false;}

    65

  if (typeid(* first_type) == typeid(invalid_type_name_c))           {return false;}

    66

  if (typeid(*second_type) == typeid(invalid_type_name_c))           {return false;}

    67

    68

  if ((get_datatype_info_c::is_ANY_ELEMENTARY(first_type)) &&

    69

      (typeid(*first_type) == typeid(*second_type)))                 {return true;}

    70

  /* ANY_DERIVED */

    71

  return (first_type == second_type);

    72

}

    73

    74

    75

    76

bool get_datatype_info_c::is_type_valid(symbol_c *type) {

    77

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

    78

  if (typeid(*type) == typeid(invalid_type_name_c))                  {return false;}

    79

  return true;

    80

}

    81

    82

    83

    84

    85

    86

    87

bool get_datatype_info_c::is_sfc_initstep(symbol_c *type_symbol) {

    88

  symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol); 

    89

  if (typeid(*type_decl) == typeid(initial_step_c))                  {return true;}   /* INITIAL_STEP step_name ':' action_association_list END_STEP */  /* A pseudo data type! */

    90

  return false;

    91

}

    92

    93

    94

    95

    96

    97

bool get_datatype_info_c::is_sfc_step(symbol_c *type_symbol) {

    98

  symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol); 

    99

  if (typeid(*type_decl) == typeid(initial_step_c))                  {return true;}   /* INITIAL_STEP step_name ':' action_association_list END_STEP */  /* A pseudo data type! */

   100

  if (typeid(*type_decl) == typeid(        step_c))                  {return true;}   /*         STEP step_name ':' action_association_list END_STEP */  /* A pseudo data type! */

   101

  return false;

   102

}

   103

   104

   105

   106

   107

bool get_datatype_info_c::is_function_block(symbol_c *type_symbol) {

   108

  symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol); 

   109

  if (typeid(*type_decl) == typeid(function_block_declaration_c))    {return true;}   /*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   110

  return false;

   111

}

   112

   113

   114

   115

   116

   117

bool get_datatype_info_c::is_subrange(symbol_c *type_symbol) {

   118

  symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol); /* NOTE: will work correctly once we update the way search_base_type_c works, by adding a new search_effective_type:c */

   119

   120

  if (typeid(*type_decl) == typeid(subrange_type_declaration_c))     {return true;}   /*  subrange_type_name ':' subrange_spec_init */

   121

  if (typeid(*type_decl) == typeid(subrange_spec_init_c))            {return true;}   /* subrange_specification ASSIGN signed_integer */

   122

  if (typeid(*type_decl) == typeid(subrange_specification_c))        {return true;}   /*  integer_type_name '(' subrange')' */

   123

   124

  if (typeid(*type_decl) == typeid(subrange_c))                      {ERROR;}         /*  signed_integer DOTDOT signed_integer */

   125

  return false;

   126

}

   127

   128

   129

   130

   131

   132

bool get_datatype_info_c::is_enumerated(symbol_c *type_symbol) {

   133

  symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol);

   134

   135

  if (typeid(*type_decl) == typeid(enumerated_type_declaration_c))   {return true;}   /*  enumerated_type_name ':' enumerated_spec_init */

   136

  if (typeid(*type_decl) == typeid(enumerated_spec_init_c))          {return true;}   /* enumerated_specification ASSIGN enumerated_value */

   137

  if (typeid(*type_decl) == typeid(enumerated_value_list_c))         {return true;}   /* enumerated_value_list ',' enumerated_value */        /* once we change the way we handle enums, this will probably become an ERROR! */

   138

   139

  if (typeid(*type_decl) == typeid(enumerated_value_c))              {ERROR;}         /* enumerated_type_name '#' identifier */

   140

  return false;

   141

}

   142

   143

   144

   145

   146

   147

bool get_datatype_info_c::is_array(symbol_c *type_symbol) {

   148

  symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol);

   149

   150

  if (typeid(*type_decl) == typeid(array_type_declaration_c))        {return true;}   /*  identifier ':' array_spec_init */

   151

  if (typeid(*type_decl) == typeid(array_spec_init_c))               {return true;}   /* array_specification [ASSIGN array_initialization} */

   152

  if (typeid(*type_decl) == typeid(array_specification_c))           {return true;}   /* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */

   153

   154

  if (typeid(*type_decl) == typeid(array_subrange_list_c))           {ERROR;}         /* array_subrange_list ',' subrange */

   155

  if (typeid(*type_decl) == typeid(array_initial_elements_list_c))   {ERROR;}         /* array_initialization:  '[' array_initial_elements_list ']' */  /* array_initial_elements_list ',' array_initial_elements */

   156

  if (typeid(*type_decl) == typeid(array_initial_elements_c))        {ERROR;}         /* integer '(' [array_initial_element] ')' */

   157

  return false;

   158

}

   159

   160

   161

   162

   163

   164

bool get_datatype_info_c::is_structure(symbol_c *type_symbol) {

   165

  symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol);

   166

   167

  if (typeid(*type_decl) == typeid(structure_type_declaration_c))              {return true;}   /*  structure_type_name ':' structure_specification */

   168

  if (typeid(*type_decl) == typeid(initialized_structure_c))                   {return true;}   /* structure_type_name ASSIGN structure_initialization */

   169

  if (typeid(*type_decl) == typeid(structure_element_declaration_list_c))      {return true;}   /* structure_declaration:  STRUCT structure_element_declaration_list END_STRUCT */ /* structure_element_declaration_list structure_element_declaration ';' */

   170

   171

  if (typeid(*type_decl) == typeid(structure_element_declaration_c))           {ERROR;}         /*  structure_element_name ':' *_spec_init */

   172

  if (typeid(*type_decl) == typeid(structure_element_initialization_list_c))   {ERROR;}         /* structure_initialization: '(' structure_element_initialization_list ')' */  /* structure_element_initialization_list ',' structure_element_initialization */

   173

  if (typeid(*type_decl) == typeid(structure_element_initialization_c))        {ERROR;}         /*  structure_element_name ASSIGN value */

   174

  return false;

   175

}

   176

   177

   178

   179

   180

   181

   182

   183

   184

   185

   186

bool get_datatype_info_c::is_ANY_ELEMENTARY(symbol_c *type_symbol) {

   187

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

   188

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

   189

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

   190

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

   191

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

   192

  return false;

   193

}

   194

   195

   196

bool get_datatype_info_c::is_ANY_SAFEELEMENTARY(symbol_c *type_symbol) {

   197

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

   198

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

   199

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

   200

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

   201

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

   202

  return false;

   203

}

   204

   205

   206

bool get_datatype_info_c::is_ANY_ELEMENTARY_compatible(symbol_c *type_symbol) {

   207

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

   208

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

   209

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

   210

  return false;

   211

}

   212

   213

   214

   215

   216

   217

   218

   219

bool get_datatype_info_c::is_ANY_MAGNITUDE(symbol_c *type_symbol) {

   220

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

   221

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

   222

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

   223

  return false;

   224

}

   225

   226

   227

bool get_datatype_info_c::is_ANY_SAFEMAGNITUDE(symbol_c *type_symbol) {

   228

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

   229

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

   230

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

   231

  return false;

   232

}

   233

   234

   235

bool get_datatype_info_c::is_ANY_MAGNITUDE_compatible(symbol_c *type_symbol) {

   236

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

   237

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

   238

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

   239

  return false;

   240

}

   241

   242

   243

   244

   245

   246

   247

   248

bool get_datatype_info_c::is_ANY_signed_MAGNITUDE(symbol_c *type_symbol) {

   249

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

   250

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

   251

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

   252

  return false;

   253

}

   254

   255

   256

bool get_datatype_info_c::is_ANY_signed_SAFEMAGNITUDE(symbol_c *type_symbol) {

   257

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

   258

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

   259

  return is_ANY_signed_SAFENUM(type_symbol);

   260

}

   261

   262

   263

bool get_datatype_info_c::is_ANY_signed_MAGNITUDE_compatible(symbol_c *type_symbol) {

   264

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

   265

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

   266

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

   267

  return false;

   268

}

   269

   270

   271

   272

   273

   274

   275

   276

bool get_datatype_info_c::is_ANY_NUM(symbol_c *type_symbol) {

   277

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

   278

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

   279

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

   280

  return false;

   281

}

   282

   283

   284

bool get_datatype_info_c::is_ANY_SAFENUM(symbol_c *type_symbol) {

   285

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

   286

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

   287

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

   288

  return false;

   289

}

   290

   291

   292

bool get_datatype_info_c::is_ANY_NUM_compatible(symbol_c *type_symbol) {

   293

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

   294

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

   295

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

   296

  return false;

   297

}

   298

   299

   300

   301

   302

   303

   304

   305

bool get_datatype_info_c::is_ANY_signed_NUM(symbol_c *type_symbol) {

   306

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

   307

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

   308

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

   309

  return false;

   310

}

   311

   312

   313

bool get_datatype_info_c::is_ANY_signed_SAFENUM(symbol_c *type_symbol) {

   314

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

   315

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

   316

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

   317

  return false;

   318

}

   319

   320

   321

bool get_datatype_info_c::is_ANY_signed_NUM_compatible(symbol_c *type_symbol) {

   322

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

   323

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

   324

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

   325

  return false;

   326

}

   327

   328

   329

   330

   331

   332

   333

   334

bool get_datatype_info_c::is_ANY_INT(symbol_c *type_symbol) {

   335

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

   336

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

   337

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

   338

  return false;

   339

}

   340

   341

   342

bool get_datatype_info_c::is_ANY_SAFEINT(symbol_c *type_symbol) {

   343

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

   344

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

   345

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

   346

  return false;

   347

}

   348

   349

   350

bool get_datatype_info_c::is_ANY_INT_compatible(symbol_c *type_symbol) {

   351

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

   352

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

   353

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

   354

  return false;

   355

}

   356

   357

   358

   359

   360

   361

   362

bool get_datatype_info_c::is_ANY_signed_INT(symbol_c *type_symbol) {

   363

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

   364

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

   365

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

   366

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

   367

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

   368

  return false;

   369

}

   370

   371

   372

bool get_datatype_info_c::is_ANY_signed_SAFEINT(symbol_c *type_symbol) {

   373

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

   374

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

   375

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

   376

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

   377

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

   378

  return false;

   379

}

   380

   381

   382

bool get_datatype_info_c::is_ANY_signed_INT_compatible(symbol_c *type_symbol) {

   383

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

   384

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

   385

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

   386

  return false;

   387

}

   388

   389

   390

   391

   392

   393

   394

   395

   396

   397

bool get_datatype_info_c::is_ANY_unsigned_INT(symbol_c *type_symbol) {

   398

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

   399

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

   400

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

   401

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

   402

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

   403

  return false;

   404

}

   405

   406

   407

bool get_datatype_info_c::is_ANY_unsigned_SAFEINT(symbol_c *type_symbol) {

   408

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

   409

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

   410

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

   411

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

   412

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

   413

  return false;

   414

}

   415

   416

   417

bool get_datatype_info_c::is_ANY_unsigned_INT_compatible(symbol_c *type_symbol) {

   418

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

   419

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

   420

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

   421

  return false;

   422

}

   423

   424

   425

   426

   427

   428

   429

   430

   431

bool get_datatype_info_c::is_ANY_REAL(symbol_c *type_symbol) {

   432

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

   433

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

   434

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

   435

  return false;

   436

}

   437

   438

   439

bool get_datatype_info_c::is_ANY_SAFEREAL(symbol_c *type_symbol) {

   440

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

   441

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

   442

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

   443

  return false;

   444

}

   445

   446

   447

bool get_datatype_info_c::is_ANY_REAL_compatible(symbol_c *type_symbol) {

   448

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

   449

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

   450

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

   451

  return false;

   452

}

   453

   454

   455

   456

   457

   458

   459

   460

   461

bool get_datatype_info_c::is_ANY_nBIT(symbol_c *type_symbol) {

   462

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

   463

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

   464

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

   465

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

   466

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

   467

  return false;

   468

}

   469

   470

   471

bool get_datatype_info_c::is_ANY_SAFEnBIT(symbol_c *type_symbol) {

   472

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

   473

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

   474

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

   475

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

   476

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

   477

  return false;

   478

}

   479

   480

   481

bool get_datatype_info_c::is_ANY_nBIT_compatible(symbol_c *type_symbol) {

   482

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

   483

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

   484

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

   485

  return false;

   486

}

   487

   488

   489

   490

   491

   492

   493

   494

   495

   496

   497

bool get_datatype_info_c::is_BOOL(symbol_c *type_symbol) {

   498

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

   499

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

   500

  return false;

   501

}

   502

   503

   504

bool get_datatype_info_c::is_SAFEBOOL(symbol_c *type_symbol) {

   505

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

   506

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

   507

  return false;

   508

}

   509

   510

   511

bool get_datatype_info_c::is_BOOL_compatible(symbol_c *type_symbol) {

   512

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

   513

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

   514

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

   515

  return false;

   516

}

   517

   518

   519

   520

   521

   522

   523

   524

   525

   526

bool get_datatype_info_c::is_ANY_BIT(symbol_c *type_symbol) {