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.1 - Elementary Data Types */

    80

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

    81

    void *visit(time_type_name_c        *symbol) {return (void *)symbol;};

    82

    void *visit(bool_type_name_c        *symbol) {return (void *)symbol;};

    83

    void *visit(sint_type_name_c        *symbol) {return (void *)symbol;};

    84

    void *visit(int_type_name_c         *symbol) {return (void *)symbol;};

    85

    void *visit(dint_type_name_c        *symbol) {return (void *)symbol;};

    86

    void *visit(lint_type_name_c        *symbol) {return (void *)symbol;};

    87

    void *visit(usint_type_name_c       *symbol) {return (void *)symbol;};

    88

    void *visit(uint_type_name_c        *symbol) {return (void *)symbol;};

    89

    void *visit(udint_type_name_c       *symbol) {return (void *)symbol;};

    90

    void *visit(ulint_type_name_c       *symbol) {return (void *)symbol;};

    91

    void *visit(real_type_name_c        *symbol) {return (void *)symbol;};

    92

    void *visit(lreal_type_name_c       *symbol) {return (void *)symbol;};

    93

    void *visit(date_type_name_c        *symbol) {return (void *)symbol;};

    94

    void *visit(tod_type_name_c         *symbol) {return (void *)symbol;};

    95

    void *visit(dt_type_name_c          *symbol) {return (void *)symbol;};

    96

    void *visit(byte_type_name_c        *symbol) {return (void *)symbol;};

    97

    void *visit(word_type_name_c        *symbol) {return (void *)symbol;};

    98

    void *visit(lword_type_name_c       *symbol) {return (void *)symbol;};

    99

    void *visit(dword_type_name_c       *symbol) {return (void *)symbol;};

   100

    void *visit(string_type_name_c      *symbol) {return (void *)symbol;};

   101

    void *visit(wstring_type_name_c     *symbol) {return (void *)symbol;};

   102

   103

    void *visit(safetime_type_name_c    *symbol) {return (void *)symbol;};

   104

    void *visit(safebool_type_name_c    *symbol) {return (void *)symbol;};

   105

    void *visit(safesint_type_name_c    *symbol) {return (void *)symbol;};

   106

    void *visit(safeint_type_name_c     *symbol) {return (void *)symbol;};

   107

    void *visit(safedint_type_name_c    *symbol) {return (void *)symbol;};

   108

    void *visit(safelint_type_name_c    *symbol) {return (void *)symbol;};

   109

    void *visit(safeusint_type_name_c   *symbol) {return (void *)symbol;};

   110

    void *visit(safeuint_type_name_c    *symbol) {return (void *)symbol;};

   111

    void *visit(safeudint_type_name_c   *symbol) {return (void *)symbol;};

   112

    void *visit(safeulint_type_name_c   *symbol) {return (void *)symbol;};

   113

    void *visit(safereal_type_name_c    *symbol) {return (void *)symbol;};

   114

    void *visit(safelreal_type_name_c   *symbol) {return (void *)symbol;};

   115

    void *visit(safedate_type_name_c    *symbol) {return (void *)symbol;};

   116

    void *visit(safetod_type_name_c     *symbol) {return (void *)symbol;};

   117

    void *visit(safedt_type_name_c      *symbol) {return (void *)symbol;};

   118

    void *visit(safebyte_type_name_c    *symbol) {return (void *)symbol;};

   119

    void *visit(safeword_type_name_c    *symbol) {return (void *)symbol;};

   120

    void *visit(safelword_type_name_c   *symbol) {return (void *)symbol;};

   121

    void *visit(safedword_type_name_c   *symbol) {return (void *)symbol;};

   122

    void *visit(safestring_type_name_c  *symbol) {return (void *)symbol;};

   123

    void *visit(safewstring_type_name_c *symbol) {return (void *)symbol;};

   124

   125

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

   126

    /* B 1.3.3 - Derived data types */

   127

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

   128

    /*  simple_type_name ':' simple_spec_init */

   129

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

   130

    /*  subrange_type_name ':' subrange_spec_init */

   131

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

   132

    /*  enumerated_type_name ':' enumerated_spec_init */

   133

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

   134

    /*  identifier ':' array_spec_init */

   135

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

   136

    /*  structure_type_name ':' structure_specification */

   137

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

   138

    /*  string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */

   139

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

   140

    /* ref_type_decl: identifier ':' ref_spec_init */

   141

    void *visit(ref_type_decl_c               *symbol)  {return symbol->ref_type_name;}

   142

    /* NOTE: DO NOT place any code here that references symbol->anotations_map["generate_c_annotaton__implicit_type_id"] !!

   143

     *       All anotations in the symbol->anotations_map[] are considered a stage4 construct. In the above example,

   144

     *       That anotation is specific to the generate_c stage4 code, and must therefore NOT be referenced

   145

     *       in the absyntax_utils code, as this last code should be independent of the stage4 version!

   146

     */ 

   147

   148

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

   149

    /* B 1.5.2 - Function Blocks */

   150

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

   151

    /*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   152

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

   153

}; // get_datatype_id_c 

   154

   155

get_datatype_id_c *get_datatype_id_c::singleton = NULL;

   156

   157

   158

   159

   160

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

   161

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

   162

   163

   164

/* A small helper class, to transform elementary data type to string.

   165

 * this allows us to generate more relevant error messages...

   166

 */

   167

   168

class get_datatype_id_str_c: public null_visitor_c {

   169

  protected:

   170

     get_datatype_id_str_c(void)  {};

   171

    ~get_datatype_id_str_c(void) {};

   172

   173

  private:

   174

    /* singleton class! */

   175

    static get_datatype_id_str_c *singleton;

   176

   177

  public:

   178

    static const char *get_id_str(symbol_c *symbol) {

   179

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

   180

      if (NULL == singleton)    ERROR;

   181

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

   182

      if (NULL == res)          ERROR;

   183

      return res;

   184

    }

   185

   186

   187

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

   188

    /* B.1 - Common elements */

   189

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

   190

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

   191

    /* B 1.1 - Letters, digits and identifiers */

   192

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

   193

    void *visit(identifier_c *symbol) {return (void *)symbol->value;};

   194

   195

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

   196

    /* B 1.3.1 - Elementary Data Types */

   197

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

   198

    void *visit(time_type_name_c        *symbol) {return (void *)"TIME";        };

   199

    void *visit(bool_type_name_c        *symbol) {return (void *)"BOOL";        };

   200

    void *visit(sint_type_name_c        *symbol) {return (void *)"SINT";        };

   201

    void *visit(int_type_name_c         *symbol) {return (void *)"INT";         };

   202

    void *visit(dint_type_name_c        *symbol) {return (void *)"DINT";        };

   203

    void *visit(lint_type_name_c        *symbol) {return (void *)"LINT";        };

   204

    void *visit(usint_type_name_c       *symbol) {return (void *)"USINT";       };

   205

    void *visit(uint_type_name_c        *symbol) {return (void *)"UINT";        };

   206

    void *visit(udint_type_name_c       *symbol) {return (void *)"UDINT";       };

   207

    void *visit(ulint_type_name_c       *symbol) {return (void *)"ULINT";       };

   208

    void *visit(real_type_name_c        *symbol) {return (void *)"REAL";        };

   209

    void *visit(lreal_type_name_c       *symbol) {return (void *)"LREAL";       };

   210

    void *visit(date_type_name_c        *symbol) {return (void *)"DATE";        };

   211

    void *visit(tod_type_name_c         *symbol) {return (void *)"TOD";         };

   212

    void *visit(dt_type_name_c          *symbol) {return (void *)"DT";          };

   213

    void *visit(byte_type_name_c        *symbol) {return (void *)"BYTE";        };

   214

    void *visit(word_type_name_c        *symbol) {return (void *)"WORD";        };

   215

    void *visit(lword_type_name_c       *symbol) {return (void *)"LWORD";       };

   216

    void *visit(dword_type_name_c       *symbol) {return (void *)"DWORD";       };

   217

    void *visit(string_type_name_c      *symbol) {return (void *)"STRING";      };

   218

    void *visit(wstring_type_name_c     *symbol) {return (void *)"WSTRING";     };

   219

   220

    void *visit(safetime_type_name_c    *symbol) {return (void *)"SAFETIME";    };

   221

    void *visit(safebool_type_name_c    *symbol) {return (void *)"SAFEBOOL";    };

   222

    void *visit(safesint_type_name_c    *symbol) {return (void *)"SAFESINT";    };

   223

    void *visit(safeint_type_name_c     *symbol) {return (void *)"SAFEINT";     };

   224

    void *visit(safedint_type_name_c    *symbol) {return (void *)"SAFEDINT";    };

   225

    void *visit(safelint_type_name_c    *symbol) {return (void *)"SAFELINT";    };

   226

    void *visit(safeusint_type_name_c   *symbol) {return (void *)"SAFEUSINT";   };

   227

    void *visit(safeuint_type_name_c    *symbol) {return (void *)"SAFEUINT";    };

   228

    void *visit(safeudint_type_name_c   *symbol) {return (void *)"SAFEUDINT";   };

   229

    void *visit(safeulint_type_name_c   *symbol) {return (void *)"SAFEULINT";   };

   230

    void *visit(safereal_type_name_c    *symbol) {return (void *)"SAFEREAL";    };

   231

    void *visit(safelreal_type_name_c   *symbol) {return (void *)"SAFELREAL";   };

   232

    void *visit(safedate_type_name_c    *symbol) {return (void *)"SAFEDATE";    };

   233

    void *visit(safetod_type_name_c     *symbol) {return (void *)"SAFETOD";     };

   234

    void *visit(safedt_type_name_c      *symbol) {return (void *)"SAFEDT";      };

   235

    void *visit(safebyte_type_name_c    *symbol) {return (void *)"SAFEBYTE";    };

   236

    void *visit(safeword_type_name_c    *symbol) {return (void *)"SAFEWORD";    };

   237

    void *visit(safelword_type_name_c   *symbol) {return (void *)"SAFELWORD";   };

   238

    void *visit(safedword_type_name_c   *symbol) {return (void *)"SAFEDWORD";   };

   239

    void *visit(safestring_type_name_c  *symbol) {return (void *)"SAFESTRING";  };

   240

    void *visit(safewstring_type_name_c *symbol) {return (void *)"SAFEWSTRING"; };

   241

   242

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

   243

    /* B 1.3.3 - Derived data types */

   244

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

   245

    /*  simple_type_name ':' simple_spec_init */

   246

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

   247

    /*  subrange_type_name ':' subrange_spec_init */

   248

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

   249

    /*  enumerated_type_name ':' enumerated_spec_init */

   250

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

   251

    /*  identifier ':' array_spec_init */

   252

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

   253

    /*  structure_type_name ':' structure_specification */

   254

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

   255

    /*  string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */

   256

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

   257

    /* ref_type_decl: identifier ':' ref_spec_init */

   258

    void *visit(ref_type_decl_c               *symbol)  {return symbol->ref_type_name->accept(*this);}

   259

    /* NOTE: DO NOT place any code here that references symbol->anotations_map["generate_c_annotaton__implicit_type_id"] !!

   260

     *       All anotations in the symbol->anotations_map[] are considered a stage4 construct. In the above example,

   261

     *       That anotation is specific to the generate_c stage4 code, and must therefore NOT be referenced

   262

     *       in the absyntax_utils code, as this last code should be independent of the stage4 version!

   263

     */ 

   264

   265

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

   266

    /* B 1.5.2 - Function Blocks */

   267

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

   268

    /*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   269

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

   270

};

   271

   272

get_datatype_id_str_c *get_datatype_id_str_c::singleton = NULL;

   273

   274

   275

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

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

   284

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

   285

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

   286

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

   287

   288

const char *get_datatype_info_c::get_id_str(symbol_c *datatype) {

   289

  return get_datatype_id_str_c::get_id_str(datatype);

   290

}

   291

   292

   293

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

   294

  return get_datatype_id_c::get_id(datatype);

   295

}

   296

   297

   298

/* Returns true if both datatypes are equivalent (not necessarily equal!).

   299

 * WARNING: May return true even though the datatypes are not the same/identicial!!!

   300

 *          This occurs when at least one of the datatypes is of a generic

   301

 *          datatype (or a REF_TO a generic datatype). 

   302

 *          (Generic dataypes: ANY, ANY_INT, ANY_NUM, ...)

   303

 * NOTE: Currently only the ANY generic datatype is implemented!

   304

 * NOTE: Currently stage1_2 only allows the use of the ANY keyword when in conjuntion with

   305

 *       the REF_TO keyword (i.e. REF_TO ANY), so when handling non REF_TO datatypes,

   306

 *       this function will currently only return true if the dataypes are identicial.

   307

 */

   308

   309

/* NOTE: Currently the datatype model used by matiec considers any implicitly defined datatype

   310

 *       (e.g. an array datatype defined in the variable declaration itself, instead of inside a TYPE ... END_TYPE

   311

 *       construct) to be different (i.e. not the same datatype, and therefore not compatible) to any other

   312

 *       datatype, including with datatypes declared identically to the implicit datatype.

   313

 *       e.g.

   314

 *         TYPE my_array_t: ARRAY [1..3] OF INT; END_TYPE;

   315

 *         FUNCTION_BLOCK FOO

   316

 *          VAR my_array:  ARRAY [1..3] OF INT; END_VAR

   317

 *         ...

   318

 *         END_FUNCTION_BLOCK

   319

 * 

   320

 *         In the abive code, my_array is NOT considered to te compatible with my_Array_t !!!

   321

 * 

   322

 *       In essence, the currently supported datatype model considers all datatypes to be different to each other,

   323

 *       even though the stored data is the same (Let us call this rule (0))!

   324

 *       There are 2 exceptions to the above rule:

   325

 *        (1) Datatypes that are directly derived from other datatypes.

   326

 *              (this rule is specified in the standard, so we follow it!)

   327

 *        (2) REF_TO datatypes that reference the same datatype

   328

 *              (I dont think the standard says anything about this!)

   329

 *

   330

 *         TYPE 

   331

 *          my_array_1_t: ARRAY [1..3] OF INT; 

   332

 *          my_array_2_t: ARRAY [1..3] OF INT; 

   333

 *          my_array_3_t: my_array_1_t; 

   334

 *          A_ref_t: REF_TO my_array_1_t;

   335

 *          B_ref_t: REF_TO my_array_1_t;

   336

 *          C_ref_t: A_ref_t;

   337

 *         END_TYPE;

   338

 *                 

   339

 *         In the above code, my_array_1_t is a distinct datatype to my_array_2_t

   340

 *           (this is different to C and C++, where they would be considered the same datatype!)

   341

 *           (following rule (0))

   342

 *         In the above code, my_array_3_t is the same datatype as my_array_1_t

   343

 *           (following rule (1))

   344

 *         In the above code, A_ref_t is the same datatype as B_ref_t

   345

 *           (following rule (2))

   346

 *         In the above code, A_ref_t is the same datatype as C_ref_t

   347

 *           (following rule (1))

   348

 *

   349

 *       Note that rule (0) means that a function/FB with a parameter whose datatype is implicitly defined

   350

 *       can never be passed a value!

   351

 *         FUNCTION_BLOCK FOO

   352

 *          VAR_INPUT my_array:  ARRAY [1..3] OF INT; END_VAR

   353

 *         ...

   354

 *         END_FUNCTION_BLOCK

   355

 *

   356

 *       Any call to FB foo can never pass a value to parameter my_array, as its datatype is distinct

   357

 *       to all other datatypes, and therefore passing any other variable to my_array will result in an

   358

 *       'incompatible datatypes' error!

   359

 *       The above seems natural o me (Mario) in a programming language that is very strongly typed.

   360

 * 

   361

 *       However, if we did not have exception (2), the following would also be invalid:

   362

 *         TYPE my_array_t: ARRAY [1..3] OF INT; END_TYPE;

   363

 *         FUNCTION_BLOCK FOO_t

   364

 *          VAR_INPUT my_array: REF_TO my_array_t; END_VAR

   365

 *         ...

   366

 *         END_FUNCTION_BLOCK

   367

 * 

   368

 *         FUNCTION_BLOCK BAR

   369

 *          VAR

   370

 *            my_array: my_array_t; 

   371

 *            foo: FOO_t;

   372

 *          END_VAR

   373

 *          foo(REF(my_array));  <----- invalid, without rule 2!!

   374

 *         ...

   375

 *         END_FUNCTION_BLOCK

   376

 * 

   377

 *       Rule/exception (2) goes against the datatype model used for all other datatypes.

   378

 *       This rule was adopted as without it, the datatype of the value returned by the REF() 

   379

 *       operator would be considered distinct to all other datatypes, and therefore the

   380

 *       REF() operator would be essentially useless.

   381

 */

   382

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

   383

  if (!is_type_valid( first_type))                                   {return false;}

   384

  if (!is_type_valid(second_type))                                   {return false;}

   385

   386

  /* GENERIC DATATYPES */

   387

  /* For the moment, we only support the ANY generic datatype! */

   388

  if ((is_ANY_generic_type( first_type)) ||

   389

      (is_ANY_generic_type(second_type)))                            {return true;}

   390

   391

  /* ANY_ELEMENTARY */

   392

  if ((is_ANY_ELEMENTARY(first_type)) &&

   393

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

   394

   395

  /* ANY_DERIVED */

   396

  if (is_ref_to(first_type) && is_ref_to(second_type)) {

   397

    return is_type_equal(search_base_type_c::get_basetype_decl(get_ref_to(first_type )),

   398

                         search_base_type_c::get_basetype_decl(get_ref_to(second_type)));

   399

  }

   400

  return (first_type == second_type);

   401

}

   402

   403

   404

bool get_datatype_info_c::is_type_valid(symbol_c *type) {

   405

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

   406

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

   407

  return true;

   408

}

   409

   410

   411

   412

   413

   414

   415

   416

/* returns the datatype the REF_TO datatype references/points to... */ 

   417

symbol_c *get_datatype_info_c::get_ref_to(symbol_c *type_symbol) {

   418

  ref_type_decl_c *type1 = dynamic_cast<ref_type_decl_c *>(type_symbol);

   419

  if (NULL != type1) type_symbol = type1->ref_spec_init;

   420

   421

  ref_spec_init_c *type2 = dynamic_cast<ref_spec_init_c *>(type_symbol);

   422

  if (NULL != type2) type_symbol = type2->ref_spec;

   423

   424

  ref_spec_c      *type3 = dynamic_cast<ref_spec_c      *>(type_symbol);

   425

  if (NULL != type3) return type3->type_name;

   426

   427

  return NULL; /* this is not a ref datatype!! */

   428

}

   429

   430

   431

   432

   433

   434

   435

bool get_datatype_info_c::is_ref_to(symbol_c *type_symbol) {

   436

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

   437

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

   438

   439

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

   440

  if (typeid(*type_decl) == typeid(ref_spec_init_c))                           {return true;}   /* ref_spec [ ASSIGN ref_initialization ]; */

   441

  if (typeid(*type_decl) == typeid(ref_spec_c))                                {return true;}   /* REF_TO (non_generic_type_name | function_block_type_name) */

   442

  return false;

   443

}

   444

   445

   446

   447

   448

bool get_datatype_info_c::is_sfc_initstep(symbol_c *type_symbol) {

   449

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

   450

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

   451

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

   452

  return false;

   453

}

   454

   455

   456

   457

bool get_datatype_info_c::is_sfc_step(symbol_c *type_symbol) {

   458

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

   459

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

   460

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

   461

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

   462

  return false;

   463

}

   464

   465

   466

   467

   468

bool get_datatype_info_c::is_function_block(symbol_c *type_symbol) {

   469

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

   470

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

   471

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

   472

  return false;

   473

}

   474

   475

   476

   477

   478

   479

bool get_datatype_info_c::is_subrange(symbol_c *type_symbol) {

   480

  symbol_c *type_decl = search_base_type_c::get_equivtype_decl(type_symbol); /* NOTE: do NOT call search_base_type_c !! */

   481

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

   482

   483

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

   484

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

   485

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

   486

   487

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

   488

  return false;

   489

}

   490

   491

   492

   493

   494

   495

bool get_datatype_info_c::is_enumerated(symbol_c *type_symbol) {

   496

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

   497

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

   498