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

/*****           Some helper classes                  *****/

    59

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

    60

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

    61

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

    62

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

    63

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

    64

    65

/* Return the identifier (name) of a datatype, typically declared in a TYPE .. END_TYPE declaration */

    66

class get_datatype_id_c: null_visitor_c {

    67

  private:

    68

    static get_datatype_id_c *singleton;

    69

    70

  public:

    71

    static symbol_c *get_id(symbol_c *symbol) {

    72

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

    73

      if (NULL == singleton) ERROR;

    74

      return (symbol_c *)symbol->accept(*singleton);

    75

    }

    76

    77

  protected:

    78

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

    79

    /* B 1.3.3 - Derived data types */

    80

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

    81

    /*  simple_type_name ':' simple_spec_init */

    82

    void *visit(simple_type_declaration_c *symbol)      {return symbol->simple_type_name;}

    83

    /*  subrange_type_name ':' subrange_spec_init */

    84

    void *visit(subrange_type_declaration_c *symbol)    {return symbol->subrange_type_name;}

    85

    /*  enumerated_type_name ':' enumerated_spec_init */

    86

    void *visit(enumerated_type_declaration_c *symbol)  {return symbol->enumerated_type_name;}

    87

    /*  identifier ':' array_spec_init */

    88

    void *visit(array_type_declaration_c *symbol)       {return symbol->identifier;}

    89

    /*  structure_type_name ':' structure_specification */

    90

    void *visit(structure_type_declaration_c *symbol)   {return symbol->structure_type_name;}

    91

    /*  string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */

    92

    void *visit(string_type_declaration_c *symbol)      {return symbol->string_type_name;}

    93

    94

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

    95

    /* B 1.5.2 - Function Blocks */

    96

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

    97

    /*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

    98

    void *visit(function_block_declaration_c *symbol)      {return symbol->fblock_name;}

    99

}; // get_datatype_id_c 

   100

   101

get_datatype_id_c *get_datatype_id_c::singleton = NULL;

   102

   103

   104

   105

   106

   107

   108

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

   109

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

   110

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

   111

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

   112

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

   113

/*****        GET_DATATYPE_INFO_C                     *****/

   114

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

   115

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

   116

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

   117

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

   118

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

   119

   120

   121

   122

symbol_c *get_datatype_info_c::get_datatype_id(symbol_c *datatype) {

   123

  return get_datatype_id_c::get_id(datatype);

   124

}

   125

   126

   127

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

   128

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

   129

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

   130

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

   131

   132

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

   133

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

   134

  /* ANY_DERIVED */

   135

  return (first_type == second_type);

   136

}

   137

   138

   139

   140

bool get_datatype_info_c::is_type_valid(symbol_c *type) {

   141

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

   142

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

   143

  return true;

   144

}

   145

   146

   147

   148

   149

   150

   151

bool get_datatype_info_c::is_sfc_initstep(symbol_c *type_symbol) {

   152

  symbol_c *type_decl = search_base_type_c::get_basetype_decl(type_symbol); 

   153

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

   154

  return false;

   155

}

   156

   157

   158

   159

   160

   161

bool get_datatype_info_c::is_sfc_step(symbol_c *type_symbol) {

   162

  symbol_c *type_decl = search_base_type_c::get_basetype_decl(type_symbol); 

   163

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

   164

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

   165

  return false;

   166

}

   167

   168

   169

   170

   171

bool get_datatype_info_c::is_function_block(symbol_c *type_symbol) {

   172

  symbol_c *type_decl = search_base_type_c::get_basetype_decl(type_symbol); 

   173

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

   174

  return false;

   175

}

   176

   177

   178

   179

   180

   181

bool get_datatype_info_c::is_subrange(symbol_c *type_symbol) {

   182

  symbol_c *type_decl = search_base_type_c::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 */

   183

   184

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

   185

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

   186

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

   187

   188

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

   189

  return false;

   190

}

   191

   192

   193

   194

   195

   196

bool get_datatype_info_c::is_enumerated(symbol_c *type_symbol) {

   197

  symbol_c *type_decl = search_base_type_c::get_basetype_decl(type_symbol);

   198

   199

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

   200

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

   201

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

   202

   203

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

   204

  return false;

   205

}

   206

   207

   208

   209

   210

   211

bool get_datatype_info_c::is_array(symbol_c *type_symbol) {

   212

  symbol_c *type_decl = search_base_type_c::get_basetype_decl(type_symbol);

   213

   214

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

   215

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

   216

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

   217

   218

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

   219

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

   220

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

   221

  return false;

   222

}

   223

   224

   225

   226

   227

   228

bool get_datatype_info_c::is_structure(symbol_c *type_symbol) {

   229

  symbol_c *type_decl = search_base_type_c::get_basetype_decl(type_symbol);

   230

   231

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

   232

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

   233

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

   234

   235

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

   236

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

   237

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

   238

  return false;

   239

}

   240

   241

   242

   243

   244

   245

   246

   247

   248

   249

   250

bool get_datatype_info_c::is_ANY_ELEMENTARY(symbol_c *type_symbol) {

   251

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

   252

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

   253

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

   254

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

   255

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

   256

  return false;

   257

}

   258

   259

   260

bool get_datatype_info_c::is_ANY_SAFEELEMENTARY(symbol_c *type_symbol) {

   261

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

   262

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

   263

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

   264

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

   265

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

   266

  return false;

   267

}

   268

   269

   270

bool get_datatype_info_c::is_ANY_ELEMENTARY_compatible(symbol_c *type_symbol) {

   271

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

   272

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

   273

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

   274

  return false;

   275

}

   276

   277

   278

   279

   280

   281

   282

   283

bool get_datatype_info_c::is_ANY_MAGNITUDE(symbol_c *type_symbol) {

   284

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

   285

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

   286

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

   287

  return false;

   288

}

   289

   290

   291

bool get_datatype_info_c::is_ANY_SAFEMAGNITUDE(symbol_c *type_symbol) {

   292

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

   293

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

   294

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

   295

  return false;

   296

}

   297

   298

   299

bool get_datatype_info_c::is_ANY_MAGNITUDE_compatible(symbol_c *type_symbol) {

   300

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

   301

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

   302

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

   303

  return false;

   304

}

   305

   306

   307

   308

   309

   310

   311

   312

bool get_datatype_info_c::is_ANY_signed_MAGNITUDE(symbol_c *type_symbol) {

   313

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

   314

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

   315

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

   316

  return false;

   317

}

   318

   319

   320

bool get_datatype_info_c::is_ANY_signed_SAFEMAGNITUDE(symbol_c *type_symbol) {

   321

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

   322

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

   323

  return is_ANY_signed_SAFENUM(type_symbol);

   324

}

   325

   326

   327

bool get_datatype_info_c::is_ANY_signed_MAGNITUDE_compatible(symbol_c *type_symbol) {

   328

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

   329

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

   330

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

   331

  return false;

   332

}

   333

   334

   335

   336

   337

   338

   339

   340

bool get_datatype_info_c::is_ANY_NUM(symbol_c *type_symbol) {

   341

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

   342

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

   343

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

   344

  return false;

   345

}

   346

   347

   348

bool get_datatype_info_c::is_ANY_SAFENUM(symbol_c *type_symbol) {

   349

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

   350

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

   351

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

   352

  return false;

   353

}

   354

   355

   356

bool get_datatype_info_c::is_ANY_NUM_compatible(symbol_c *type_symbol) {

   357

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

   358

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

   359

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

   360

  return false;

   361

}

   362

   363

   364

   365

   366

   367

   368

   369

bool get_datatype_info_c::is_ANY_signed_NUM(symbol_c *type_symbol) {

   370

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

   371

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

   372

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

   373

  return false;

   374

}

   375

   376

   377

bool get_datatype_info_c::is_ANY_signed_SAFENUM(symbol_c *type_symbol) {

   378

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

   379

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

   380

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

   381

  return false;

   382

}

   383

   384

   385

bool get_datatype_info_c::is_ANY_signed_NUM_compatible(symbol_c *type_symbol) {

   386

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

   387

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

   388

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

   389

  return false;

   390

}

   391

   392

   393

   394

   395

   396

   397

   398

bool get_datatype_info_c::is_ANY_INT(symbol_c *type_symbol) {

   399

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

   400

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

   401

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

   402

  return false;

   403

}

   404

   405

   406

bool get_datatype_info_c::is_ANY_SAFEINT(symbol_c *type_symbol) {

   407

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

   408

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

   409

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

   410

  return false;

   411

}

   412

   413

   414

bool get_datatype_info_c::is_ANY_INT_compatible(symbol_c *type_symbol) {

   415

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

   416

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

   417

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

   418

  return false;

   419

}

   420

   421

   422

   423

   424

   425

   426

bool get_datatype_info_c::is_ANY_signed_INT(symbol_c *type_symbol) {

   427

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

   428

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

   429

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

   430

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

   431

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

   432

  return false;

   433

}

   434

   435

   436

bool get_datatype_info_c::is_ANY_signed_SAFEINT(symbol_c *type_symbol) {

   437

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

   438

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

   439

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

   440

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

   441

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

   442

  return false;

   443

}

   444

   445

   446

bool get_datatype_info_c::is_ANY_signed_INT_compatible(symbol_c *type_symbol) {

   447

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

   448

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

   449

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

   450

  return false;

   451

}

   452

   453

   454

   455

   456

   457

   458

   459

   460

   461

bool get_datatype_info_c::is_ANY_unsigned_INT(symbol_c *type_symbol) {

   462

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

   463

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

   464

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

   465

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

   466

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

   467

  return false;

   468

}

   469

   470

   471

bool get_datatype_info_c::is_ANY_unsigned_SAFEINT(symbol_c *type_symbol) {

   472

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

   473

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

   474

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

   475

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

   476

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

   477

  return false;

   478

}

   479

   480

   481

bool get_datatype_info_c::is_ANY_unsigned_INT_compatible(symbol_c *type_symbol) {

   482

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

   483

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

   484

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

   485

  return false;

   486

}

   487

   488

   489

   490

   491

   492

   493

   494

   495

bool get_datatype_info_c::is_ANY_REAL(symbol_c *type_symbol) {

   496

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

   497

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

   498

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

   499

  return false;

   500

}

   501

   502

   503

bool get_datatype_info_c::is_ANY_SAFEREAL(symbol_c *type_symbol) {

   504

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

   505

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

   506

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

   507

  return false;

   508

}

   509

   510

   511

bool get_datatype_info_c::is_ANY_REAL_compatible(symbol_c *type_symbol) {

   512

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

   513

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

   514

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

   515

  return false;

   516

}

   517

   518

   519

   520