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, as well as the runtime_options global variable

    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

    66

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

    67

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

    68

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

    69

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

    70

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

    71

class get_datatype_id_c: null_visitor_c {

    72

  private:

    73

    static get_datatype_id_c *singleton;

    74

    75

  public:

    76

    static symbol_c *get_id(symbol_c *symbol) {

    77

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

    78

      if (NULL == singleton) ERROR;

    79

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

    80

    }

    81

    82

  protected:

    83

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

    84

    /* B 1.3.1 - Elementary Data Types */

    85

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

    86

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

    87

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

    88

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

    89

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

    90

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

    91

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

    92

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

    93

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

    94

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

    95

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

    96

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

    97

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

    98

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

    99

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

   100

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

   101

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

   102

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

   103

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

   104

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

   105

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

   106

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

   107

   108

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

   109

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

   110

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

   111

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

   112

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

   113

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

   114

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

   115

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

   116

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

   117

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

   118

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

   119

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

   120

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

   121

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

   122

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

   123

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

   124

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

   125

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

   126

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

   127

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

   128

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

   129

   130

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

   131

   132

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

   133

    /* B 1.3.3 - Derived data types */

   134

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

   135

    /*  simple_type_name ':' simple_spec_init */

   136

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

   137

    /*  subrange_type_name ':' subrange_spec_init */

   138

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

   139

    /*  enumerated_type_name ':' enumerated_spec_init */

   140

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

   141

    /*  identifier ':' array_spec_init */

   142

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

   143

    /*  structure_type_name ':' structure_specification */

   144

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

   145

    /*  string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */

   146

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

   147

    /* ref_type_decl: identifier ':' ref_spec_init */

   148

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

   149

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

   150

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

   151

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

   152

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

   153

     */ 

   154

   155

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

   156

    /* B 1.5.2 - Function Blocks */

   157

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

   158

    /*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   159

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

   160

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

   161

    /* B 1.5.3 - Programs */

   162

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

   163

    /*  PROGRAM program_type_name program_var_declarations_list function_block_body END_PROGRAM */

   164

    void *visit(program_declaration_c  *symbol)  {return symbol->program_type_name;}

   165

   166

}; // get_datatype_id_c 

   167

   168

get_datatype_id_c *get_datatype_id_c::singleton = NULL;

   169

   170

   171

   172

   173

   174

   175

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

   176

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

   177

/* transform elementary data type class to string */

   178

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

   179

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

   180

   181

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

   182

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

   183

 */

   184

   185

class get_datatype_id_str_c: public null_visitor_c {

   186

  protected:

   187

     get_datatype_id_str_c(void)  {};

   188

    ~get_datatype_id_str_c(void) {};

   189

   190

  private:

   191

    /* singleton class! */

   192

    static get_datatype_id_str_c *singleton;

   193

   194

  public:

   195

    static const char *get_id_str(symbol_c *symbol) {

   196

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

   197

      if (NULL == singleton)    ERROR;

   198

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

   199

      if (NULL == res)          ERROR;

   200

      return res;

   201

    }

   202

   203

   204

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

   205

    /* B.1 - Common elements */

   206

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

   207

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

   208

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

   209

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

   210

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

   211

    // Should not be necessary, as datatype declarations currently use an identifier_c for their name! 

   212

    // Only references to the datatype (when declaring variable, for ex., will use poutype_identifier_c

   213

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

   214

    // Should not be necessary, as FB declarations currently use an identifier_c for their name! 

   215

    // Only references to the FB (when declaring variable, for ex., will use poutype_identifier_c

   216

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

   217

   218

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

   219

    /* B 1.3.1 - Elementary Data Types */

   220

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

   221

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

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

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

   241

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

   242

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

   265

    void *visit(void_type_name_c        *symbol) {return (void *)"VOID"; };

   266

   267

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

   268

    /* B.1.3.2 - Generic data types */

   269

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

   270

    void *visit(generic_type_any_c *symbol) {return (void *)"ANY"; };

   271

   272

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

   273

    /* B 1.3.3 - Derived data types */

   274

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

   275

    /*  simple_type_name ':' simple_spec_init */

   276

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

   277

    /*  subrange_type_name ':' subrange_spec_init */

   278

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

   279

    /*  enumerated_type_name ':' enumerated_spec_init */

   280

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

   281

    /*  identifier ':' array_spec_init */

   282

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

   283

    /*  structure_type_name ':' structure_specification */

   284

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

   285

    /*  string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */

   286

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

   287

    /* ref_type_decl: identifier ':' ref_spec_init */

   288

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

   289

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

   290

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

   291

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

   292

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

   293

     */ 

   294

   295

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

   296

    /* B 1.5.1 - Functions */

   297

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

   298

    /* Functions are not really datatypes, but we include it here as it helps in printing out error messages!   */

   299

    /* Currently this is needed only by remove_forward_depencies_c::print_circ_error()                          */

   300

    /*  FUNCTION derived_function_name ':' elementary_type_name io_OR_function_var_declarations_list function_body END_FUNCTION */

   301

    void *visit(      function_declaration_c  *symbol)  {return symbol->derived_function_name->accept(*this);}

   302

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

   303

    /* B 1.5.2 - Function Blocks */

   304

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

   305

    /*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   306

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

   307

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

   308

    /* B 1.5.3 - Programs */

   309

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

   310

    /*  PROGRAM program_type_name program_var_declarations_list function_block_body END_PROGRAM */

   311

    void *visit(       program_declaration_c  *symbol)  {return symbol->program_type_name->accept(*this);} 

   312

};

   313

   314

get_datatype_id_str_c *get_datatype_id_str_c::singleton = NULL;

   315

   316

   317

   318

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

   319

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

   320

/* get the datatype of a field inside a struct data type */

   321

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

   322

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

   323

   324

class get_struct_info_c : null_visitor_c {

   325

  private:

   326

    symbol_c *current_field;

   327

    /* singleton class! */

   328

    static get_struct_info_c *singleton;

   329

   330

  public:

   331

    get_struct_info_c(void) {current_field = NULL;}

   332

   333

    static symbol_c *get_field_type_id(symbol_c *struct_type, symbol_c *field_name) {

   334

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

   335

      if (NULL == singleton)    ERROR;

   336

      singleton->current_field = field_name;

   337

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

   338

    }

   339

   340

   341

  private:

   342

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

   343

    /* B.1 - Common elements */

   344

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

   345

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

   346

    /* B 1.3.3 - Derived data types */

   347

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

   348

    /*  structure_type_name ':' structure_specification */

   349

    /* NOTE: this is only used inside a TYPE ... END_TYPE declaration.  It is never used directly when declaring a new variable! */

   350

    /* NOTE: structure_specification will point to either initialized_structure_c  OR  structure_element_declaration_list_c */

   351

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

   352

   353

    /* structure_type_name ASSIGN structure_initialization */

   354

    /* structure_initialization may be NULL ! */

   355

    // SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization)

   356

    /* NOTE: only the initialized structure is never used when declaring a new variable instance */

   357

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

   358

   359

    /* helper symbol for structure_declaration */

   360

    /* structure_declaration:  STRUCT structure_element_declaration_list END_STRUCT */

   361

    /* structure_element_declaration_list structure_element_declaration ';' */

   362

    void *visit(structure_element_declaration_list_c *symbol) {

   363

      /* now search the structure declaration */

   364

      for(int i = 0; i < symbol->n; i++) {

   365

        void *tmp = symbol->elements[i]->accept(*this);

   366

        if (NULL != tmp) return tmp;

   367

      }

   368

      return NULL; // not found!!

   369

    }  

   370

   371

    /*  structure_element_name ':' spec_init */

   372

    void *visit(structure_element_declaration_c *symbol) {

   373

      if (compare_identifiers(symbol->structure_element_name, current_field) == 0)

   374

        return symbol->spec_init; /* found the type of the element we were looking for! */

   375

      return NULL;   /* not the element we are looking for! */

   376

    }

   377

   378

   379

    /* helper symbol for structure_initialization */

   380

    /* structure_initialization: '(' structure_element_initialization_list ')' */

   381

    /* structure_element_initialization_list ',' structure_element_initialization */

   382

    void *visit(structure_element_initialization_list_c *symbol) {ERROR; return NULL;} /* should never get called... */

   383

    /*  structure_element_name ASSIGN value */

   384

    void *visit(structure_element_initialization_c *symbol) {ERROR; return NULL;} /* should never get called... */

   385

   386

   387

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

   388

    /* B.1.5 - Program organization units */

   389

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

   390

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

   391

    /* B 1.5.2 - Function Blocks */

   392

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

   393

    /*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   394

    // SYM_REF4(function_block_declaration_c, fblock_name, var_declarations, fblock_body, unused)

   395

    void *visit(function_block_declaration_c *symbol) {

   396

      /* now search the function block declaration for the variable... */

   397

      search_var_instance_decl_c search_decl(symbol);

   398

      return search_decl.get_decl(current_field);

   399

    }

   400

   401

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

   402

    /* B.1.6  Sequential function chart elements */

   403

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

   404

    /* INITIAL_STEP step_name ':' action_association_list END_STEP */

   405

    // SYM_REF2(initial_step_c, step_name, action_association_list)

   406

    void *visit(initial_step_c *symbol) {

   407

      identifier_c T("T");  identifier_c X("X");

   408

      /* Hard code the datatypes of the implicit variables Stepname.X and Stepname.T */

   409

      if (compare_identifiers(&T, current_field) == 0)  return &get_datatype_info_c::time_type_name;

   410

      if (compare_identifiers(&X, current_field) == 0)  return &get_datatype_info_c::bool_type_name;

   411

      return NULL;

   412

    }

   413

   414

    /* STEP step_name ':' action_association_list END_STEP */

   415

    // SYM_REF2(step_c, step_name, action_association_list)

   416

    /* The code here should be identicial to the code in the visit(initial_step_c *) visitor! So we simply call the other visitor! */

   417

    void *visit(step_c *symbol) {initial_step_c initial_step(NULL, NULL); return initial_step.accept(*this);}

   418

   419

}; // get_struct_info_c

   420

   421

get_struct_info_c *get_struct_info_c::singleton = NULL;

   422

   423

   424

   425

   426

   427

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

   428

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

   429

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

   430

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

   431

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

   432

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

   433

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

   434

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

   435

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

   436

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

   437

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

   438

   439

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

   440

  return get_datatype_id_str_c::get_id_str(datatype);

   441

}

   442

   443

   444

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

   445

  return get_datatype_id_c::get_id(datatype);

   446

}

   447

   448

   449

symbol_c *get_datatype_info_c::get_struct_field_type_id(symbol_c *struct_datatype, symbol_c *struct_fieldname) {

   450

  return get_struct_info_c::get_field_type_id(struct_datatype, struct_fieldname);

   451

}

   452

   453

   454

   455

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

   456

  // returns the datatype of the variables stored in the array

   457

  array_specification_c *symbol = NULL;

   458

  if (NULL == symbol)  symbol = dynamic_cast<array_specification_c *>(type_symbol);

   459

  if (NULL == symbol)  symbol = dynamic_cast<array_specification_c *>(search_base_type_c::get_basetype_decl(type_symbol));

   460

  if (NULL != symbol)  

   461

    return symbol->non_generic_type_name;

   462

  return NULL; // this is not an array!

   463

}

   464

   465

   466

   467

   468

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

   469

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

   470

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

   471

 *          datatype (or a REF_TO a generic datatype). 

   472

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

   473

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

   474

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

   475

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

   476

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

   477

 */

   478

   479

/* NOTE: matiec supports a strict and a relaxed data type model. Which datatype model to use is chosen

   480

 *       as a command line option.

   481

 * 

   482

 * 

   483

 *       The Strict Datatype Model

   484

 *       =========================

   485

 *       The strict datatype model used by matiec considers any implicitly defined datatype

   486

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

   487

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

   488

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

   489

 *       e.g.

   490

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

   491

 *         FUNCTION_BLOCK FOO

   492

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

   493

 *         ...

   494

 *         END_FUNCTION_BLOCK

   495

 *