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

    58

    59

    60

    61

    62

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

    63

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

    64

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

    65

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

    66

    67

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

    68

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

    69

  /* ANY_DERIVED */

    70

  return (first_type == second_type);

    71

}

    72

    73

    74

    75

bool get_datatype_info_c::is_type_valid(symbol_c *type) {

    76

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

    77

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

    78

  return true;

    79

}

    80

    81

    82

    83

    84

    85

    86

bool get_datatype_info_c::is_sfc_initstep(symbol_c *type_symbol) {

    88

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

    89

  return false;

    90

}

    91

    92

    93

    94

    95

    96

bool get_datatype_info_c::is_sfc_step(symbol_c *type_symbol) {

    98

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

    99

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

   100

  return false;

   101

}

   102

   103

   104

   105

   106

bool get_datatype_info_c::is_function_block(symbol_c *type_symbol) {

   108

  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 */

   109

  return false;

   110

}

   111

   112

   113

   114

   115

   116

bool get_datatype_info_c::is_subrange(symbol_c *type_symbol) {

   118

   119

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

   120

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

   121

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

   122

   123

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

   124

  return false;

   125

}

   126

   127

   128

   129

   130

   131

bool get_datatype_info_c::is_enumerated(symbol_c *type_symbol) {

   133

   134

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

   135

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

   136

  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! */

   137

   138

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

   139

  return false;

   140

}

   141

   142

   143

   144

   145

   146

bool get_datatype_info_c::is_array(symbol_c *type_symbol) {

   148

   149

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

   150

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

   151

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

   152

   153

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

   154

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

   155

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

   156

  return false;

   157

}

   158

   159

   160

   161

   162

   163

bool get_datatype_info_c::is_structure(symbol_c *type_symbol) {

   165

   166

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

   167

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

   168

  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 ';' */

   169

   170

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

   171

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

   172

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

   173

  return false;

   174

}

   175

   176

   177

   178

   179

   180

   181

   182

   183

   184

   185

bool get_datatype_info_c::is_ANY_ELEMENTARY(symbol_c *type_symbol) {

   186

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

   187

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

   188

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

   189

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

   190

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

   191

  return false;

   192

}

   193

   194

   195

bool get_datatype_info_c::is_ANY_SAFEELEMENTARY(symbol_c *type_symbol) {

   196

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

   197

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

   198

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

   199

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

   200

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

   201

  return false;

   202

}

   203

   204

   205

bool get_datatype_info_c::is_ANY_ELEMENTARY_compatible(symbol_c *type_symbol) {

   206

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

   207

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

   208

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

   209

  return false;

   210

}

   211

   212

   213

   214

   215

   216

   217

   218

bool get_datatype_info_c::is_ANY_MAGNITUDE(symbol_c *type_symbol) {

   219

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

   220

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

   221

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

   222

  return false;

   223

}

   224

   225

   226

bool get_datatype_info_c::is_ANY_SAFEMAGNITUDE(symbol_c *type_symbol) {

   227

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

   228

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

   229

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

   230

  return false;

   231

}

   232

   233

   234

bool get_datatype_info_c::is_ANY_MAGNITUDE_compatible(symbol_c *type_symbol) {

   235

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

   236

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

   237

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

   238

  return false;

   239

}

   240

   241

   242

   243

   244

   245

   246

   247

bool get_datatype_info_c::is_ANY_signed_MAGNITUDE(symbol_c *type_symbol) {

   248

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

   249

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

   250

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

   251

  return false;

   252

}

   253

   254

   255

bool get_datatype_info_c::is_ANY_signed_SAFEMAGNITUDE(symbol_c *type_symbol) {

   256

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

   257

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

   258

  return is_ANY_signed_SAFENUM(type_symbol);

   259

}

   260

   261

   262

bool get_datatype_info_c::is_ANY_signed_MAGNITUDE_compatible(symbol_c *type_symbol) {

   263

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

   264

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

   265

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

   266

  return false;

   267

}

   268

   269

   270

   271

   272

   273

   274

   275

bool get_datatype_info_c::is_ANY_NUM(symbol_c *type_symbol) {

   276

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

   277

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

   278

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

   279

  return false;

   280

}

   281

   282

   283

bool get_datatype_info_c::is_ANY_SAFENUM(symbol_c *type_symbol) {

   284

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

   285

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

   286

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

   287

  return false;

   288

}

   289

   290

   291

bool get_datatype_info_c::is_ANY_NUM_compatible(symbol_c *type_symbol) {

   292

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

   293

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

   294

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

   295

  return false;

   296

}

   297

   298

   299

   300

   301

   302

   303

   304

bool get_datatype_info_c::is_ANY_signed_NUM(symbol_c *type_symbol) {

   305

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

   306

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

   307

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

   308

  return false;

   309

}

   310

   311

   312

bool get_datatype_info_c::is_ANY_signed_SAFENUM(symbol_c *type_symbol) {

   313

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

   314

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

   315

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

   316

  return false;

   317

}

   318

   319

   320

bool get_datatype_info_c::is_ANY_signed_NUM_compatible(symbol_c *type_symbol) {

   321

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

   322

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

   323

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

   324

  return false;

   325

}

   326

   327

   328

   329

   330

   331

   332

   333

bool get_datatype_info_c::is_ANY_INT(symbol_c *type_symbol) {

   334

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

   335

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

   336

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

   337

  return false;

   338

}

   339

   340

   341

bool get_datatype_info_c::is_ANY_SAFEINT(symbol_c *type_symbol) {

   342

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

   343

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

   344

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

   345

  return false;

   346

}

   347

   348

   349

bool get_datatype_info_c::is_ANY_INT_compatible(symbol_c *type_symbol) {

   350

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

   351

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

   352

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

   353

  return false;

   354

}

   355

   356

   357

   358

   359

   360

   361

bool get_datatype_info_c::is_ANY_signed_INT(symbol_c *type_symbol) {

   362

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

   363

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

   364

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

   365

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

   366

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

   367

  return false;

   368

}

   369

   370

   371

bool get_datatype_info_c::is_ANY_signed_SAFEINT(symbol_c *type_symbol) {

   372

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

   373

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

   374

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

   375

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

   376

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

   377

  return false;

   378

}

   379

   380

   381

bool get_datatype_info_c::is_ANY_signed_INT_compatible(symbol_c *type_symbol) {

   382

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

   383

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

   384

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

   385

  return false;

   386

}

   387

   388

   389

   390

   391

   392

   393

   394

   395

   396

bool get_datatype_info_c::is_ANY_unsigned_INT(symbol_c *type_symbol) {

   397

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

   398

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

   399

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

   400

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

   401

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

   402

  return false;

   403

}

   404

   405

   406

bool get_datatype_info_c::is_ANY_unsigned_SAFEINT(symbol_c *type_symbol) {

   407

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

   408

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

   409

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

   410

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

   411

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

   412

  return false;

   413

}

   414

   415

   416

bool get_datatype_info_c::is_ANY_unsigned_INT_compatible(symbol_c *type_symbol) {

   417

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

   418

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

   419

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

   420

  return false;

   421

}

   422

   423

   424

   425

   426

   427

   428

   429

   430

bool get_datatype_info_c::is_ANY_REAL(symbol_c *type_symbol) {

   431

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

   432

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

   433

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

   434

  return false;

   435

}

   436

   437

   438

bool get_datatype_info_c::is_ANY_SAFEREAL(symbol_c *type_symbol) {

   439

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

   440

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

   441

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

   442

  return false;

   443

}

   444

   445

   446

bool get_datatype_info_c::is_ANY_REAL_compatible(symbol_c *type_symbol) {

   447

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

   448

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

   449

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

   450

  return false;

   451

}

   452

   453

   454

   455

   456

   457

   458

   459

   460

bool get_datatype_info_c::is_ANY_nBIT(symbol_c *type_symbol) {

   461

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

   462

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

   463

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

   464

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

   465

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

   466

  return false;

   467

}

   468

   469

   470

bool get_datatype_info_c::is_ANY_SAFEnBIT(symbol_c *type_symbol) {

   471

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

   472

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

   473

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

   474

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

   475

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

   476

  return false;

   477

}

   478

   479

   480

bool get_datatype_info_c::is_ANY_nBIT_compatible(symbol_c *type_symbol) {

   481

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

   482

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

   483

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

   484

  return false;

   485

}

   486

   487

   488

   489

   490

   491

   492

   493

   494

   495

   496

bool get_datatype_info_c::is_BOOL(symbol_c *type_symbol) {

   497

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

   498

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

   499

  return false;

   500

}

   501

   502

   503

bool get_datatype_info_c::is_SAFEBOOL(symbol_c *type_symbol) {

   504

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

   505

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

   506

  return false;

   507

}

   508

   509

   510

bool get_datatype_info_c::is_BOOL_compatible(symbol_c *type_symbol) {

   511

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

   512

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

   513

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

   514

  return false;

   515

}

   516

   517

   518

   519

   520

   521

   522

   523

   524

   525

bool get_datatype_info_c::is_ANY_BIT(symbol_c *type_symbol) {