1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *

     4

 *  Copyright (C) 2009-2012  Mario de Sousa (msousa@fe.up.pt)

     5

 *  Copyright (C) 2012       Manuele Conti  (conti.ma@alice.it)

     6

 *

     7

 *  This program is free software: you can redistribute it and/or modify

     8

 *  it under the terms of the GNU General Public License as published by

     9

 *  the Free Software Foundation, either version 3 of the License, or

    10

 *  (at your option) any later version.

    11

 *

    12

 *  This program is distributed in the hope that it will be useful,

    13

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    14

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15

 *  GNU General Public License for more details.

    16

 *

    17

 *  You should have received a copy of the GNU General Public License

    18

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    19

 *

    20

 *

    21

 * This code is made available on the understanding that it will not be

    22

 * used in safety-critical situations without a full and competent review.

    23

 */

    24

    25

#include "datatype_functions.hh"

    26

#include "../absyntax_utils/absyntax_utils.hh"

    27

#include <vector>

    28

// #include <algorithm>

    29

    30

    31

    32

    33

    34

elementary_type_c *elementary_type_c::singleton = NULL;

    35

    36

const char *elementary_type_c::to_string(symbol_c *symbol) {

    37

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

    38

  if (NULL == singleton)    ERROR;

    39

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

    40

  if (NULL == res) {

    41

	  int i = 1;

    42

  }

    43

  return res;

    44

}

    45

    46

    47

    48

    49

    50

/* Macro that expand to subtypes */

    51

/* copied from matiec/lib/create_standard_functions_txt.sh */

    52

#define __ANY(DO)                 __ANY_DERIVED(DO) __ANY_ELEMENTARY(DO)

    53

#define __ANY_DERIVED(DO)

    54

#define __ANY_ELEMENTARY(DO)      __ANY_MAGNITUDE(DO) __ANY_BIT(DO) __ANY_STRING(DO) __ANY_DATE(DO)

    55

#define __ANY_MAGNITUDE(DO)       __ANY_NUM(DO) DO(time)

    56

#define __ANY_BIT(DO)             __ANY_NBIT(DO) DO(bool)

    57

#define __ANY_NBIT(DO)            DO(byte) DO(word) DO(dword) DO(lword)

    58

//#define __ANY_STRING(DO)          DO(string) DO(wstring)

    59

#define __ANY_STRING(DO)          DO(string)

    60

#define __ANY_DATE(DO)            DO(date) DO(tod) DO(dt)

    61

#define __ANY_NUM(DO)             __ANY_REAL(DO) __ANY_INT(DO)

    62

#define __ANY_REAL(DO)            DO(real) DO(lreal)

    63

#define __ANY_INT(DO)             __ANY_SINT(DO) __ANY_UINT(DO)

    64

#define __ANY_SINT(DO)            DO(sint) DO(int) DO(dint) DO(lint)

    65

#define __ANY_UINT(DO)            DO(usint) DO(uint) DO(udint) DO(ulint)

    66

    67

#define __ANY_1(DO,P1)            __ANY_DERIVED_1(DO,P1) __ANY_ELEMENTARY_1(DO,P1)

    68

#define __ANY_DERIVED_1(DO,P1)

    69

#define __ANY_ELEMENTARY_1(DO,P1) __ANY_MAGNITUDE_1(DO,P1) __ANY_BIT_1(DO,P1) __ANY_STRING_1(DO,P1) __ANY_DATE_1(DO,P1)

    70

#define __ANY_MAGNITUDE_1(DO,P1)  __ANY_NUM_1(DO,P1) DO(time,P1)

    71

#define __ANY_BIT_1(DO,P1)        __ANY_NBIT_1(DO,P1) DO(bool,P1)

    72

#define __ANY_NBIT_1(DO,P1)       DO(byte,P1) DO(word,P1) DO(dword,P1) DO(lword,P1)

    73

// #define __ANY_STRING_1(DO,P1)     DO(string,P1) DO(wstring,P1)

    74

#define __ANY_STRING_1(DO,P1)     DO(string,P1)

    75

#define __ANY_DATE_1(DO,P1)       DO(date,P1) DO(tod,P1) DO(dt,P1)

    76

#define __ANY_NUM_1(DO,P1)        __ANY_REAL_1(DO,P1) __ANY_INT_1(DO,P1)

    77

#define __ANY_REAL_1(DO,P1)       DO(real,P1) DO(lreal,P1)

    78

#define __ANY_INT_1(DO,P1)        __ANY_SINT_1(DO,P1) __ANY_UINT_1(DO,P1)

    79

#define __ANY_SINT_1(DO,P1)       DO(sint,P1) DO(int,P1) DO(dint,P1) DO(lint,P1)

    80

#define __ANY_UINT_1(DO,P1)       DO(usint,P1) DO(uint,P1) DO(udint,P1) DO(ulint,P1)

    81

    82

    93

    94

const struct widen_entry widen_ADD_table[] = {

    95

#define __add(TYPE)       \

    96

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

    97

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

    98

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

    99

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::safe##TYPE##_type_name, widen_entry::ok     },

   100

    __ANY_NUM(__add)

   101

#undef __add

   102

   103

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

   104

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

   105

    /*** Operations with TIME, DT and TOD... ***/

   106

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

   107

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

   108

    { &search_constant_type_c::time_type_name,          &search_constant_type_c::time_type_name,            &search_constant_type_c::time_type_name,     widen_entry::ok         },

   109

    { &search_constant_type_c::tod_type_name,           &search_constant_type_c::time_type_name,            &search_constant_type_c::tod_type_name,      widen_entry::deprecated },

   110

    /* NOTE: the standard des not explicitly support the following semantics. However, since 'addition' is supposed to be commutative, we add it anyway... */

   111

    /* not currently supported by stage4, so it is best no tto add it for now... */

   112

//  { &search_constant_type_c::time_type_name,          &search_constant_type_c::tod_type_name,             &search_constant_type_c::tod_type_name,      widen_entry::deprecated },

   113

    { &search_constant_type_c::dt_type_name,            &search_constant_type_c::time_type_name,            &search_constant_type_c::dt_type_name,       widen_entry::deprecated },         

   114

    /* NOTE: the standard des not explicitly support the following semantics. However, since 'addition' is supposed to be commutative, we add it anyway... */

   115

    /* not currently supported by stage4, so it is best no tto add it for now... */

   116

//  { &search_constant_type_c::time_type_name,          &search_constant_type_c::dt_type_name,              &search_constant_type_c::dt_type_name,       widen_entry::deprecated },         

   117

   118

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

   119

    /* SAFE version on the left... */

   120

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

   121

    { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::time_type_name,            &search_constant_type_c::time_type_name,     widen_entry::ok         },

   122

    { &search_constant_type_c::safetod_type_name,       &search_constant_type_c::time_type_name,            &search_constant_type_c::tod_type_name,      widen_entry::deprecated },

   123

    /* NOTE: the standard des not explicitly support the following semantics. However, since 'addition' is supposed to be commutative, we add it anyway... */

   124

    /* not currently supported by stage4, so it is best no tto add it for now... */

   125

//  { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::tod_type_name,             &search_constant_type_c::tod_type_name,      widen_entry::deprecated },

   126

    { &search_constant_type_c::safedt_type_name,        &search_constant_type_c::time_type_name,            &search_constant_type_c::dt_type_name,       widen_entry::deprecated },         

   127

    /* NOTE: the standard des not explicitly support the following semantics. However, since 'addition' is supposed to be commutative, we add it anyway... */

   128

    /* not currently supported by stage4, so it is best no tto add it for now... */

   129

//  { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::dt_type_name,              &search_constant_type_c::dt_type_name,       widen_entry::deprecated },         

   130

   131

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

   132

    /* SAFE version on the right... */

   133

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

   134

    { &search_constant_type_c::time_type_name,          &search_constant_type_c::safetime_type_name,        &search_constant_type_c::time_type_name,     widen_entry::ok         },

   135

    { &search_constant_type_c::tod_type_name,           &search_constant_type_c::safetime_type_name,        &search_constant_type_c::tod_type_name,      widen_entry::deprecated },

   136

    /* NOTE: the standard des not explicitly support the following semantics. However, since 'addition' is supposed to be commutative, we add it anyway... */

   137

    /* not currently supported by stage4, so it is best no tto add it for now... */

   138

//  { &search_constant_type_c::time_type_name,          &search_constant_type_c::safetod_type_name,         &search_constant_type_c::tod_type_name,      widen_entry::deprecated },

   139

    { &search_constant_type_c::dt_type_name,            &search_constant_type_c::safetime_type_name,        &search_constant_type_c::dt_type_name,       widen_entry::deprecated },         

   140

    /* NOTE: the standard des not explicitly support the following semantics. However, since 'addition' is supposed to be commutative, we add it anyway... */

   141

    /* not currently supported by stage4, so it is best no tto add it for now... */

   142

//  { &search_constant_type_c::time_type_name,          &search_constant_type_c::safedt_type_name,          &search_constant_type_c::dt_type_name,       widen_entry::deprecated },         

   143

   144

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

   145

    /* SAFE version on left and right... */

   146

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

   147

    { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::safetime_type_name,        &search_constant_type_c::safetime_type_name, widen_entry::ok         },

   148

    { &search_constant_type_c::safetod_type_name,       &search_constant_type_c::safetime_type_name,        &search_constant_type_c::safetod_type_name,  widen_entry::deprecated },

   149

    /* NOTE: the standard des not explicitly support the following semantics. However, since 'addition' is supposed to be commutative, we add it anyway... */

   150

    /* not currently supported by stage4, so it is best no tto add it for now... */

   151

//  { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::safetod_type_name,         &search_constant_type_c::safetod_type_name,  widen_entry::deprecated },

   152

    { &search_constant_type_c::safedt_type_name,        &search_constant_type_c::safetime_type_name,        &search_constant_type_c::safedt_type_name,   widen_entry::deprecated },         

   153

    /* NOTE: the standard des not explicitly support the following semantics. However, since 'addition' is supposed to be commutative, we add it anyway... */

   154

    /* not currently supported by stage4, so it is best no tto add it for now... */

   155

//  { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::safedt_type_name,          &search_constant_type_c::safedt_type_name,   widen_entry::deprecated },

   156

   157

    { NULL, NULL, NULL, widen_entry::ok },

   158

};

   159

   160

   161

   162

   163

   164

   165

   166

const struct widen_entry widen_SUB_table[] = {

   167

#define __sub(TYPE)       \

   168

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   169

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   170

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   171

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::safe##TYPE##_type_name, widen_entry::ok     },

   172

    __ANY_NUM(__sub)

   173

#undef __sub

   174

   175

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

   176

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

   177

    /*** Operations with TIME, DT and TOD... ***/

   178

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

   179

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

   180

    { &search_constant_type_c::time_type_name,          &search_constant_type_c::time_type_name,            &search_constant_type_c::time_type_name,     widen_entry::ok         },

   181

    { &search_constant_type_c::date_type_name,          &search_constant_type_c::date_type_name,            &search_constant_type_c::time_type_name,     widen_entry::deprecated },

   182

    { &search_constant_type_c::tod_type_name,           &search_constant_type_c::time_type_name,            &search_constant_type_c::tod_type_name,      widen_entry::deprecated },

   183

    { &search_constant_type_c::tod_type_name,           &search_constant_type_c::tod_type_name,             &search_constant_type_c::time_type_name,     widen_entry::deprecated },

   184

    { &search_constant_type_c::dt_type_name,            &search_constant_type_c::time_type_name,            &search_constant_type_c::dt_type_name,       widen_entry::deprecated },

   185

    { &search_constant_type_c::dt_type_name,            &search_constant_type_c::dt_type_name,              &search_constant_type_c::time_type_name,     widen_entry::deprecated },        

   186

   187

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

   188

    /* SAFE version on the left... */

   189

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

   190

    { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::time_type_name,            &search_constant_type_c::time_type_name,     widen_entry::ok         },

   191

    { &search_constant_type_c::safedate_type_name,      &search_constant_type_c::date_type_name,            &search_constant_type_c::time_type_name,     widen_entry::deprecated },

   192

    { &search_constant_type_c::safetod_type_name,       &search_constant_type_c::time_type_name,            &search_constant_type_c::tod_type_name,      widen_entry::deprecated },

   193

    { &search_constant_type_c::safetod_type_name,       &search_constant_type_c::tod_type_name,             &search_constant_type_c::time_type_name,     widen_entry::deprecated },

   194

    { &search_constant_type_c::safedt_type_name,        &search_constant_type_c::time_type_name,            &search_constant_type_c::dt_type_name,       widen_entry::deprecated },

   195

    { &search_constant_type_c::safedt_type_name,        &search_constant_type_c::dt_type_name,              &search_constant_type_c::time_type_name,     widen_entry::deprecated },        

   196

   197

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

   198

    /* SAFE version on the right... */

   199

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

   200

    { &search_constant_type_c::time_type_name,          &search_constant_type_c::safetime_type_name,        &search_constant_type_c::time_type_name,     widen_entry::ok         },

   201

    { &search_constant_type_c::date_type_name,          &search_constant_type_c::safedate_type_name,        &search_constant_type_c::time_type_name,     widen_entry::deprecated },

   202

    { &search_constant_type_c::tod_type_name,           &search_constant_type_c::safetime_type_name,        &search_constant_type_c::tod_type_name,      widen_entry::deprecated },

   203

    { &search_constant_type_c::tod_type_name,           &search_constant_type_c::safetod_type_name,         &search_constant_type_c::time_type_name,     widen_entry::deprecated },

   204

    { &search_constant_type_c::dt_type_name,            &search_constant_type_c::safetime_type_name,        &search_constant_type_c::dt_type_name,       widen_entry::deprecated },

   205

    { &search_constant_type_c::dt_type_name,            &search_constant_type_c::safedt_type_name,          &search_constant_type_c::time_type_name,     widen_entry::deprecated },        

   206

   207

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

   208

    /* SAFE version on left and right... */

   209

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

   210

    { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::safetime_type_name,        &search_constant_type_c::safetime_type_name, widen_entry::ok         },

   211

    { &search_constant_type_c::safedate_type_name,      &search_constant_type_c::safedate_type_name,        &search_constant_type_c::safetime_type_name, widen_entry::deprecated },

   212

    { &search_constant_type_c::safetod_type_name,       &search_constant_type_c::safetime_type_name,        &search_constant_type_c::safetod_type_name,  widen_entry::deprecated },

   213

    { &search_constant_type_c::safetod_type_name,       &search_constant_type_c::safetod_type_name,         &search_constant_type_c::safetime_type_name, widen_entry::deprecated },

   214

    { &search_constant_type_c::safedt_type_name,        &search_constant_type_c::safetime_type_name,        &search_constant_type_c::safedt_type_name,   widen_entry::deprecated },

   215

    { &search_constant_type_c::safedt_type_name,        &search_constant_type_c::safedt_type_name,          &search_constant_type_c::safetime_type_name, widen_entry::deprecated },        

   216

   217

    { NULL, NULL, NULL, widen_entry::ok },

   218

};

   219

   220

   221

   222

   223

   224

   225

   226

const struct widen_entry widen_MUL_table[] = {

   227

#define __mul(TYPE)       \

   228

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   229

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   230

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   231

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::safe##TYPE##_type_name, widen_entry::ok     },

   232

    __ANY_NUM(__mul)

   233

#undef __mul

   234

   235

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

   236

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

   237

    /*** Operations with TIME, DT and TOD... ***/

   238

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

   239

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

   240

#define __multime(TYPE)       \

   241

    { &search_constant_type_c::time_type_name,          &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::time_type_name,     widen_entry::deprecated }, \

   242

    { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::time_type_name,     widen_entry::deprecated }, \

   243

    { &search_constant_type_c::time_type_name,          &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::time_type_name,     widen_entry::deprecated }, \

   244

    { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::safetime_type_name, widen_entry::deprecated }, \

   245

    /* NOTE: the standard des not explicitly support the following semantics. However, since 'multiplication' is supposed to be commutative, we add it anyway... */                 \

   246

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::time_type_name,            &search_constant_type_c::time_type_name,     widen_entry::deprecated }, \

   247

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::time_type_name,            &search_constant_type_c::time_type_name,     widen_entry::deprecated }, \

   248

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::safetime_type_name,        &search_constant_type_c::time_type_name,     widen_entry::deprecated }, \

   249

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::safetime_type_name,        &search_constant_type_c::safetime_type_name, widen_entry::deprecated },

   250

    __ANY_NUM(__multime)

   251

#undef __multime

   252

   253

    { NULL, NULL, NULL, widen_entry::ok },

   254

};

   255

   256

   257

   258

   259

   260

const struct widen_entry widen_DIV_table[] = {

   261

#define __div(TYPE)       \

   262

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   263

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   264

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   265

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::safe##TYPE##_type_name, widen_entry::ok     },

   266

    __ANY_NUM(__div)

   267

#undef __div

   268

   269

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

   270

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

   271

    /*** Operations with TIME, DT and TOD... ***/

   272

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

   273

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

   274

#define __divtime(TYPE)       \

   275

    { &search_constant_type_c::time_type_name,          &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::time_type_name,     widen_entry::deprecated }, \

   276

    { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::time_type_name,     widen_entry::deprecated }, \

   277

    { &search_constant_type_c::time_type_name,          &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::time_type_name,     widen_entry::deprecated }, \

   278

    { &search_constant_type_c::safetime_type_name,      &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::safetime_type_name, widen_entry::deprecated },

   279

    __ANY_NUM(__divtime)

   280

#undef __divtime

   281

   282

    { NULL, NULL, NULL, widen_entry::ok },

   283

 };

   284

   285

   286

   287

   288

const struct widen_entry widen_MOD_table[] = {

   289

#define __mod(TYPE)       \

   290

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   291

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   292

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   293

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::safe##TYPE##_type_name, widen_entry::ok     },

   294

    __ANY_NUM(__mod)

   295

#undef __mod

   296

   297

    { NULL, NULL, NULL, widen_entry::ok },

   298

};

   299

   300

   301

   302

   318

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

   319

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

   320

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

   321

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

   322

/*******  TABLE 26: Standard bitwise Boolean functions  *******/

   323

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

   324

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

   325

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

   326

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

   327

/* table used by AND and ANDN operators, and and_expression */

   328

const struct widen_entry widen_AND_table[] = {

   329

#define __and(TYPE)       \

   330

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   331

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   332

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   333

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::safe##TYPE##_type_name, widen_entry::ok     },

   334

    __ANY_BIT(__and)

   335

#undef __and

   336

   337

    { NULL, NULL, NULL, widen_entry::ok },

   338

};

   339

   340

/* table used by OR and ORN operators, and or_expression */

   341

const struct widen_entry widen_OR_table[] = {

   342

#define __or(TYPE)       \

   343

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   344

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   345

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   346

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::safe##TYPE##_type_name, widen_entry::ok     },

   347

    __ANY_BIT(__or)

   348

#undef __or

   349

   350

    { NULL, NULL, NULL, widen_entry::ok },

   351

};

   352

   353

   354

/* table used by XOR and XORN operators, and xor_expression */

   355

const struct widen_entry widen_XOR_table[] = {

   356

#define __xor(TYPE)       \

   357

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   358

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   359

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::TYPE##_type_name,       widen_entry::ok     }, \

   360

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::safe##TYPE##_type_name, widen_entry::ok     },

   361

    __ANY_BIT(__xor)

   362

#undef __xor

   363

   364

    { NULL, NULL, NULL, widen_entry::ok },

   365

};

   366

   367

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

   368

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

   369

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

   370

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

   371

/*******  TABLE 28: Standard comparison functions       *******/

   372

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

   373

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

   374

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

   375

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

   376

/* table used by GT, GE, EQ, LE, LT, and NE  operators, and equivalent ST expressions. */

   377

const struct widen_entry widen_CMP_table[] = {

   378

#define __cmp(TYPE)       \

   379

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::bool_type_name,         widen_entry::ok     }, \

   380

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::TYPE##_type_name,          &search_constant_type_c::bool_type_name,         widen_entry::ok     }, \

   381

    { &search_constant_type_c::TYPE##_type_name,        &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::bool_type_name,         widen_entry::ok     }, \

   382

    { &search_constant_type_c::safe##TYPE##_type_name,  &search_constant_type_c::safe##TYPE##_type_name,    &search_constant_type_c::safebool_type_name,     widen_entry::ok     },

   383

    __ANY_ELEMENTARY(__cmp)

   384

#undef __cmp

   385

   386

    { NULL, NULL, NULL, widen_entry::ok },

   387

};

   388

   389

   390

/* Search for a datatype inside a candidate_datatypes list.

   391

 * Returns: position of datatype in the list, or -1 if not found.

   392

 */

   393

int search_in_candidate_datatype_list(symbol_c *datatype, std::vector <symbol_c *> candidate_datatypes) {

   394

	if (NULL == datatype) 

   395

		return -1;

   396

   397

	for(unsigned int i = 0; i < candidate_datatypes.size(); i++)

   398

		if (is_type_equal(datatype, candidate_datatypes[i]))

   399

			return i;

   400

	/* Not found ! */

   401

	return -1;

   402

}

   403

   404

   405

   406

   407

   408

   409

   410

/* Intersect two candidate_datatype_lists.

   411

 * Remove from list1 (origin, dest.) all elements that are not found in list2 (with).

   412

 * In essence, list1 will contain the result of the intersection of list1 with list2.

   413

 * In other words, modify list1 so it only contains the elelements that are simultaneously in list1 and list2!

   414

 */

   415

void intersect_candidate_datatype_list(symbol_c *list1 /*origin, dest.*/, symbol_c *list2 /*with*/) {

   416

	if ((NULL == list1) || (NULL == list2))

   417

		/* In principle, we should never call it with NULL values. Best to abort the compiler just in case! */

   418

		return;

   419

   420

	for(std::vector<symbol_c *>::iterator i = list1->candidate_datatypes.begin(); i < list1->candidate_datatypes.end(); ) {

   421

		/* Note that we do _not_ increment i in the for() loop!

   422

		 * When we erase an element from position i, a new element will take it's place, that must also be tested! 

   423

		 */

   424

		if (search_in_candidate_datatype_list(*i, list2->candidate_datatypes) < 0)

   425

			/* remove this element! This will change the value of candidate_datatypes.size() */

   426

			list1->candidate_datatypes.erase(i);

   427

		else i++;

   428

	}

   429

}

   430

   431

   432

   433

   434

/* intersect the candidate_datatype lists of all prev_il_intructions, and set the local candidate_datatype list to the result! */

   435

void intersect_prev_candidate_datatype_lists(il_instruction_c *symbol) {

   436

	if (symbol->prev_il_instruction.empty())

   437

		return;

   438

   439

	symbol->candidate_datatypes = symbol->prev_il_instruction[0]->candidate_datatypes;

   440

	for (unsigned int i = 1; i < symbol->prev_il_instruction.size(); i++) {

   441

		intersect_candidate_datatype_list(symbol /*origin, dest.*/, symbol->prev_il_instruction[i] /*with*/);

   442

	}  

   443

}

   444

   445

   446

   447

   448

/* A helper function... */

   449

bool is_ANY_ELEMENTARY_type(symbol_c *type_symbol) {

   450

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

   451

  return is_ANY_MAGNITUDE_type(type_symbol)

   452

      || is_ANY_BIT_type      (type_symbol)

   453

      || is_ANY_STRING_type   (type_symbol)

   454

      || is_ANY_DATE_type     (type_symbol);

   455

}

   456

   457

/* A helper function... */

   458

bool is_ANY_SAFEELEMENTARY_type(symbol_c *type_symbol) {

   459

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

   460

  return is_ANY_SAFEMAGNITUDE_type(type_symbol)

   461

      || is_ANY_SAFEBIT_type      (type_symbol)

   462

      || is_ANY_SAFESTRING_type   (type_symbol)

   463

      || is_ANY_SAFEDATE_type     (type_symbol);

   464

}

   465

   466

/* A helper function... */

   467

bool is_ANY_ELEMENTARY_compatible(symbol_c *type_symbol) {

   468

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

   469

  /* NOTE: doing

   470

   *          return is_ANY_SAFEELEMENTARY_type() || is_ANY_ELEMENTARY_type()

   471

   *       is incorrect, as the literals would never be considered compatible...

   472

   */

   473

  return is_ANY_MAGNITUDE_compatible(type_symbol)

   474

      || is_ANY_BIT_compatible      (type_symbol)

   475

      || is_ANY_STRING_compatible   (type_symbol)

   476

      || is_ANY_DATE_compatible     (type_symbol);

   477

}

   478

   479

   480

/* A helper function... */

   481

bool is_ANY_MAGNITUDE_type(symbol_c *type_symbol) {

   482

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

   483

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

   484

  return is_ANY_NUM_type(type_symbol);

   485

}

   486

   487

/* A helper function... */

   488

bool is_ANY_signed_MAGNITUDE_type(symbol_c *type_symbol) {

   489

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

   490

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

   491

  return is_ANY_signed_NUM_type(type_symbol);

   492

}

   493

   494

/* A helper function... */

   495

bool is_ANY_SAFEMAGNITUDE_type(symbol_c *type_symbol) {

   496

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