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

     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

    96

bool get_datatype_info_c::is_sfc_initstep(symbol_c *type_symbol) {

    97

  symbol_c *type_decl = search_base_type.get_basetype_decl(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

  return false;

   100

}

   101

   102

   103

   104

   105

   106

bool get_datatype_info_c::is_sfc_step(symbol_c *type_symbol) {

   107

  symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol); 

   108

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

   109

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

   110

  return false;

   111

}

   112

   113

   114

   115

   116

bool get_datatype_info_c::is_function_block(symbol_c *type_symbol) {

   117

  symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol); 

   118

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

   119

  return false;

   120

}

   121

   122

   123

   124

   125

   126

bool get_datatype_info_c::is_subrange(symbol_c *type_symbol) {

   127

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

   128

   129

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

   130

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

   131

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

   132

   133

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

   134

  return false;

   135

}

   136

   137

   138

   139

   140

   141

bool get_datatype_info_c::is_enumerated(symbol_c *type_symbol) {

   142

  symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol);

   143

   144

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

   145

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

   146

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

   147

   148

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

   149

  return false;

   150

}

   151

   152

   153

   154

   155

   156

bool get_datatype_info_c::is_array(symbol_c *type_symbol) {

   157

  symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol);

   158

   159

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

   160

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

   161

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

   162

   163

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

   164

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

   165

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

   166

  return false;

   167

}

   168

   169

   170

   171

   172

   173

bool get_datatype_info_c::is_structure(symbol_c *type_symbol) {

   174

  symbol_c *type_decl = search_base_type.get_basetype_decl(type_symbol);

   175

   176

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

   177

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

   178

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

   179

   180

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

   181

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

   182

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

   183

  return false;

   184

}

   185

   186

   187

   188

   189

   190

   191

   192

   193

   194

   195

bool get_datatype_info_c::is_ANY_ELEMENTARY(symbol_c *type_symbol) {

   196

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

   197

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

   198

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

   199

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

   200

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

   201

  return false;

   202

}

   203

   204

   205

bool get_datatype_info_c::is_ANY_SAFEELEMENTARY(symbol_c *type_symbol) {

   206

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

   207

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

   208

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

   209

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

   210

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

   211

  return false;

   212

}

   213

   214

   215

bool get_datatype_info_c::is_ANY_ELEMENTARY_compatible(symbol_c *type_symbol) {

   216

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

   217

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

   218

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

   219

  return false;

   220

}

   221

   222

   223

   224

   225

   226

   227

   228

bool get_datatype_info_c::is_ANY_MAGNITUDE(symbol_c *type_symbol) {

   229

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

   230

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

   231

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

   232

  return false;

   233

}

   234

   235

   236

bool get_datatype_info_c::is_ANY_SAFEMAGNITUDE(symbol_c *type_symbol) {

   237

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

   238

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

   239

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

   240

  return false;

   241

}

   242

   243

   244

bool get_datatype_info_c::is_ANY_MAGNITUDE_compatible(symbol_c *type_symbol) {

   245

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

   246

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

   247

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

   248

  return false;

   249

}

   250

   251

   252

   253

   254

   255

   256

   257

bool get_datatype_info_c::is_ANY_signed_MAGNITUDE(symbol_c *type_symbol) {

   258

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

   259

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

   260

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

   261

  return false;

   262

}

   263

   264

   265

bool get_datatype_info_c::is_ANY_signed_SAFEMAGNITUDE(symbol_c *type_symbol) {

   266

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

   267

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

   268

  return is_ANY_signed_SAFENUM(type_symbol);

   269

}

   270

   271

   272

bool get_datatype_info_c::is_ANY_signed_MAGNITUDE_compatible(symbol_c *type_symbol) {

   273

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

   274

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

   275

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

   276

  return false;

   277

}

   278

   279

   280

   281

   282

   283

   284

   285

bool get_datatype_info_c::is_ANY_NUM(symbol_c *type_symbol) {

   286

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

   287

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

   288

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

   289

  return false;

   290

}

   291

   292

   293

bool get_datatype_info_c::is_ANY_SAFENUM(symbol_c *type_symbol) {

   294

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

   295

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

   296

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

   298

}

   299

   300

   301

bool get_datatype_info_c::is_ANY_NUM_compatible(symbol_c *type_symbol) {

   302

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

   303

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

   304

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

   305

  return false;

   306

}

   307

   308

   309

   310

   311

   312

   313

   314

bool get_datatype_info_c::is_ANY_signed_NUM(symbol_c *type_symbol) {

   315

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

   316

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

   317

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

   318

  return false;

   319

}

   320

   321

   322

bool get_datatype_info_c::is_ANY_signed_SAFENUM(symbol_c *type_symbol) {

   323

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

   324

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

   325

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

   327

}

   328

   329

   330

bool get_datatype_info_c::is_ANY_signed_NUM_compatible(symbol_c *type_symbol) {

   331

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

   332

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

   333

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

   334

  return false;

   335

}

   336

   337

   338

   339

   340

   341

   342

   343

bool get_datatype_info_c::is_ANY_INT(symbol_c *type_symbol) {

   344

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

   345

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

   346

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

   347

  return false;

   348

}

   349

   350

   351

bool get_datatype_info_c::is_ANY_SAFEINT(symbol_c *type_symbol) {

   352

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

   353

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

   354

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

   355

  return false;

   356

}

   357

   358

   359

bool get_datatype_info_c::is_ANY_INT_compatible(symbol_c *type_symbol) {

   360

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

   361

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

   362

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

   363

  return false;

   364

}

   365

   366

   367

   368

   369

   370

   371

bool get_datatype_info_c::is_ANY_signed_INT(symbol_c *type_symbol) {

   372

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

   373

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

   374

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

   375

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

   376

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

   377

  return false;

   378

}

   379

   380

   381

bool get_datatype_info_c::is_ANY_signed_SAFEINT(symbol_c *type_symbol) {

   382

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

   383

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

   384

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

   385

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

   386

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

   387

  return false;

   388

}

   389

   390

   391

bool get_datatype_info_c::is_ANY_signed_INT_compatible(symbol_c *type_symbol) {

   392

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

   393

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

   394

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

   395

  return false;

   396

}

   397

   398

   399

   400

   401

   402

   403

   404

   405

   406

bool get_datatype_info_c::is_ANY_unsigned_INT(symbol_c *type_symbol) {

   407

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

   408

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

   409

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

   410

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

   411

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

   412

  return false;

   413

}

   414

   415

   416

bool get_datatype_info_c::is_ANY_unsigned_SAFEINT(symbol_c *type_symbol) {

   417

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

   418

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

   419

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

   420

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

   421

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

   422

  return false;

   423

}

   424

   425

   426

bool get_datatype_info_c::is_ANY_unsigned_INT_compatible(symbol_c *type_symbol) {

   427

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

   428

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

   429

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

   430

  return false;

   431

}

   432

   433

   434

   435

   436

   437

   438

   439

   440

bool get_datatype_info_c::is_ANY_REAL(symbol_c *type_symbol) {

   441

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

   442

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

   443

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

   444

  return false;

   445

}

   446

   447

   448

bool get_datatype_info_c::is_ANY_SAFEREAL(symbol_c *type_symbol) {

   449

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

   450

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

   451

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

   452

  return false;

   453

}

   454

   455

   456

bool get_datatype_info_c::is_ANY_REAL_compatible(symbol_c *type_symbol) {

   457

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

   458

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

   459

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

   460

  return false;

   461

}

   462

   463

   464

   465

   466

   467

   468

   469

   470

bool get_datatype_info_c::is_ANY_nBIT(symbol_c *type_symbol) {

   471

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

   472

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

   473

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

   474

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

   475

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

   476

  return false;

   477

}

   478

   479

   480

bool get_datatype_info_c::is_ANY_SAFEnBIT(symbol_c *type_symbol) {

   481

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

   482

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

   483

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

   484

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

   485

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

   486

  return false;

   487

}

   488

   489

   490

bool get_datatype_info_c::is_ANY_nBIT_compatible(symbol_c *type_symbol) {

   491

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

   492

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

   493

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

   494

  return false;

   495

}

   496

   497

   498

   499

   500

   501

   502

   503

   504

   505

   506

bool get_datatype_info_c::is_BOOL(symbol_c *type_symbol) {

   507

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

   508

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

   509

  return false;

   510

}

   511

   512

   513

bool get_datatype_info_c::is_SAFEBOOL(symbol_c *type_symbol) {

   514

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

   515

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

   516

  return false;

   517

}

   518

   519

   520

bool get_datatype_info_c::is_BOOL_compatible(symbol_c *type_symbol) {

   521

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

   522

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

   523

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

   524

  return false;

   525

}

   526