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

    /* ref_type_decl: identifier ':' ref_spec_init */

    94

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

    95

    96

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

    97

    /* B 1.5.2 - Function Blocks */

    98

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

    99

    /*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   100

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

   101

}; // get_datatype_id_c 

   102

   103

get_datatype_id_c *get_datatype_id_c::singleton = NULL;

   104

   105

   106

   107

   108

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

   109

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

   110

   111

   112

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

   113

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

   114

 */

   115

   116

class get_datatype_id_str_c: public null_visitor_c {

   117

  protected:

   118

     get_datatype_id_str_c(void)  {};

   119

    ~get_datatype_id_str_c(void) {};

   120

   121

  private:

   122

    /* singleton class! */

   123

    static get_datatype_id_str_c *singleton;

   124

   125

  public:

   126

    static const char *get_id_str(symbol_c *symbol) {

   127

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

   128

      if (NULL == singleton)    ERROR;

   129

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

   130

      if (NULL == res)          ERROR;

   131

      return res;

   132

    }

   133

   134

   135

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

   136

    /* B.1 - Common elements */

   137

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

   138

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

   139

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

   140

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

   141

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

   142

   143

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

   144

    /* B 1.3.1 - Elementary Data Types */

   145

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

   146

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

   147

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

   148

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

   149

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

   150

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

   151

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

   152

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

   153

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

   154

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

   155

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

   156

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

   157

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

   158

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

   159

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

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

   168

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

   169

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

   170

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

   171

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

   172

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

   173

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

   174

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

   175

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

   176

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

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

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

   184

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

   185

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

   186

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

   187

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

   188

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

   189

   190

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

   191

    /* B 1.3.3 - Derived data types */

   192

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

   193

    /*  simple_type_name ':' simple_spec_init */

   194

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

   195

    /*  subrange_type_name ':' subrange_spec_init */

   196

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

   197

    /*  enumerated_type_name ':' enumerated_spec_init */

   198

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

   199

    /*  identifier ':' array_spec_init */

   200

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

   201

    /*  structure_type_name ':' structure_specification */

   202

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

   203

    /*  string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */

   204

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

   205

    /* ref_type_decl: identifier ':' ref_spec_init */

   206

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

   207

   208

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

   209

    /* B 1.5.2 - Function Blocks */

   210

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

   211

    /*  FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */

   212

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

   213

};

   214

   215

get_datatype_id_str_c *get_datatype_id_str_c::singleton = NULL;

   216

   217

   218

   219

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

   220

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

   221

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

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

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

   229

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

   230

   231

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

   232

  return get_datatype_id_str_c::get_id_str(datatype);

   233

}

   234

   235

   236

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

   237

  return get_datatype_id_c::get_id(datatype);

   238

}

   239

   240

   241

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

   242

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

   243

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

   244

 *          datatype (or a REF_TO a generic datatype). 

   245

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

   246

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

   247

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

   248

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

   249

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

   250

 */

   251

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

   252

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

   253

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

   254

   255

  /* GENERIC DATATYPES */

   256

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

   257

  if ((is_ANY_generic_type( first_type)) ||

   258

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

   259

   260

  /* ANY_ELEMENTARY */

   261

  if ((is_ANY_ELEMENTARY(first_type)) &&

   262

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

   263

   264

  /* ANY_DERIVED */

   265

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

   266

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

   267

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

   268

  }

   269

   270

  return (first_type == second_type);

   271

}

   272

   273

   274

bool get_datatype_info_c::is_type_valid(symbol_c *type) {

   275

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

   276

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

   277

  return true;

   278

}

   279

   280

   281

   282

   283

   284

   285

   286

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

   287

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

   288

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

   289

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

   290

   291

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

   292

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

   293

   294

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

   295

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

   296

   297

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

   298

}

   299

   300

   301

   302

   303

   304

   305

bool get_datatype_info_c::is_ref_to(symbol_c *type_symbol) {

   306

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

   307

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

   308

   309

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

   310

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

   311

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

   312

  return false;

   313

}

   314

   315

   316

   317

   318

bool get_datatype_info_c::is_sfc_initstep(symbol_c *type_symbol) {

   319

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

   320

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

   321

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

   322

  return false;

   323

}

   324

   325

   326

   327

bool get_datatype_info_c::is_sfc_step(symbol_c *type_symbol) {

   328

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

   329

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

   330

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

   331

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

   332

  return false;

   333

}

   334

   335

   336

   337

   338

bool get_datatype_info_c::is_function_block(symbol_c *type_symbol) {

   339

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

   340

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

   341

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

   342

  return false;

   343

}

   344

   345

   346

   347

   348

   349

bool get_datatype_info_c::is_subrange(symbol_c *type_symbol) {

   350

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

   351

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

   352

   353

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

   354

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

   355

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

   356

   357

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

   358

  return false;

   359

}

   360

   361

   362

   363

   364

   365

bool get_datatype_info_c::is_enumerated(symbol_c *type_symbol) {

   366

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

   367

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

   368

   369

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

   370

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

   371

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

   372

   373

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

   374

  return false;

   375

}

   376

   377

   378

   379

   380

   381

bool get_datatype_info_c::is_array(symbol_c *type_symbol) {

   382

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

   383

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

   384

   385

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

   386

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

   387

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

   388

   389

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

   390

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

   391

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

   392

  return false;

   393

}

   394

   395

   396

   397

   398

   399

bool get_datatype_info_c::is_structure(symbol_c *type_symbol) {

   400

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

   401

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

   402

   403

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

   404

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

   405

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

   406

   407

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

   408

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

   409

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

   410

  return false;

   411

}

   412

   413

   414

   415

   416

bool get_datatype_info_c::is_ANY_generic_type(symbol_c *type_symbol) {

   417

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

   418

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

   419

  if (typeid(*type_decl) == typeid(generic_type_any_c))              {return true;}   /*  The ANY keyword! */

   420

  return false;

   421

}

   422

   423

   424

bool get_datatype_info_c::is_ANY_ELEMENTARY(symbol_c *type_symbol) {

   425

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

   426

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

   427

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

   428

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

   429

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

   430

  return false;

   431

}

   432

   433

   434

bool get_datatype_info_c::is_ANY_SAFEELEMENTARY(symbol_c *type_symbol) {

   435

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

   436

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

   437

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

   438

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

   439

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

   440

  return false;

   441

}

   442

   443

   444

bool get_datatype_info_c::is_ANY_ELEMENTARY_compatible(symbol_c *type_symbol) {

   445

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

   446

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

   447

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

   448

  return false;

   449

}

   450

   451

   452

   453

   454

   455

   456

   457

bool get_datatype_info_c::is_ANY_MAGNITUDE(symbol_c *type_symbol) {

   458

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

   459

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

   460

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

   461

  return false;

   462

}

   463

   464

   465

bool get_datatype_info_c::is_ANY_SAFEMAGNITUDE(symbol_c *type_symbol) {

   466

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

   467

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

   468

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

   469

  return false;

   470

}

   471

   472

   473

bool get_datatype_info_c::is_ANY_MAGNITUDE_compatible(symbol_c *type_symbol) {

   474

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

   475

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

   476

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

   477

  return false;

   478

}

   479

   480

   481

   482

   483

   484

   485

   486

bool get_datatype_info_c::is_ANY_signed_MAGNITUDE(symbol_c *type_symbol) {

   487

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

   488

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

   489

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

   490

  return false;

   491

}

   492

   493

   494

bool get_datatype_info_c::is_ANY_signed_SAFEMAGNITUDE(symbol_c *type_symbol) {

   495

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

   496

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

   497

  return is_ANY_signed_SAFENUM(type_symbol);

   498

}

   499

   500

   501

bool get_datatype_info_c::is_ANY_signed_MAGNITUDE_compatible(symbol_c *type_symbol) {

   502

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

   503

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

   504

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

   505

  return false;