1

/*

     2

 * (c) 2009 Mario de Sousa

     3

 *

     4

 * Offered to the public under the terms of the GNU General Public License

     5

 * as published by the Free Software Foundation; either version 2 of the

     6

 * License, or (at your option) any later version.

     7

 *

     8

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

     9

 * WITHOUT ANY WARRANTY; without even the implied warranty of

    10

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11

 * Public License for more details.

    12

 *

    13

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

    14

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

    15

 */

    16

    17

/*

    18

 * An IEC 61131-3 IL and ST compiler.

    19

 *

    20

 * Based on the

    21

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    22

 *

    23

 */

    24

    25

    26

/* Verify whether the semantic rules of data type compatibility are being followed.

    27

 *

    28

 * For example:

    29

 */

    30

    31

#include "visit_expression_type.hh"

    32

#include <typeinfo>

    33

#include <list>

    34

#include <string>

    35

#include <string.h>

    36

#include <strings.h>

    37

    38

    39

    40

#define FIRST_(symbol1, symbol2) (((symbol1)->first_line   < (symbol2)->first_line)   ? (symbol1) :    \

    41

                                  ((symbol1)->first_line   > (symbol2)->first_line)   ? (symbol2) :    \

    42

                                  ((symbol1)->first_column < (symbol2)->first_column) ? (symbol1) :    \

    43

                                  ((symbol1)->first_column > (symbol2)->first_column) ? (symbol2) :    \

    44

                                  (symbol1))

    45

    46

#define  LAST_(symbol1, symbol2) (((symbol1)->last_line    < (symbol2)->last_line)    ? (symbol2) :    \

    47

                                  ((symbol1)->last_line    > (symbol2)->last_line)    ? (symbol1) :    \

    48

                                  ((symbol1)->last_column  < (symbol2)->last_column)  ? (symbol2) :    \

    49

                                  ((symbol1)->last_column  > (symbol2)->last_column)  ? (symbol1) :    \

    50

                                  (symbol1))

    51

    52

#define STAGE3_ERROR(symbol1, symbol2, msg) {                                          \

    53

    fprintf(stderr, "semantic error between (%d:%d) and (%d:%d): %s\n",                \

    54

           FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column, \

    55

           LAST_(symbol1,symbol2) ->last_line,  LAST_(symbol1,symbol2) ->last_column,  \

    56

           msg);                                                                       \

    57

    il_error = true;                                                                   \

    58

    error_found = true;                                                                \

    59

  }

    60

    61

    62

/* set to 1 to see debug info during execution */

    63

static int debug = 0;

    64

    65

    66

void *visit_expression_type_c::visit(program_declaration_c *symbol) {

    67

  search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

    68

  symbol->var_declarations->accept(*this);

    69

  if (debug) printf("checking semantics in body of program %s\n", ((token_c *)(symbol->program_type_name))->value);

    70

  il_parenthesis_level = 0;

    71

  il_error = false;

    72

  il_default_variable_type = NULL;

    73

  symbol->function_block_body->accept(*this);

    74

  il_default_variable_type = NULL;

    75

  delete search_varfb_instance_type;

    76

  search_varfb_instance_type = NULL;

    77

  return NULL;

    78

}

    79

    80

void *visit_expression_type_c::visit(function_declaration_c *symbol) {

    81

  search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

    82

  symbol->var_declarations_list->accept(*this);

    83

  if (debug) printf("checking semantics in body of function %s\n", ((token_c *)(symbol->derived_function_name))->value);

    84

  il_parenthesis_level = 0;

    85

  il_error = false;

    86

  il_default_variable_type = NULL;

    87

  symbol->function_body->accept(*this);

    88

  il_default_variable_type = NULL;

    89

  delete search_varfb_instance_type;

    90

  search_varfb_instance_type = NULL;

    91

  return NULL;

    92

}

    93

    94

void *visit_expression_type_c::visit(function_block_declaration_c *symbol) {

    95

  search_varfb_instance_type = new search_varfb_instance_type_c(symbol);

    96

  symbol->var_declarations->accept(*this);

    97

  if (debug) printf("checking semantics in body of FB %s\n", ((token_c *)(symbol->fblock_name))->value);

    98

  il_parenthesis_level = 0;

    99

  il_error = false;

   100

  il_default_variable_type = NULL;

   101

  symbol->fblock_body->accept(*this);

   102

  il_default_variable_type = NULL;

   103

  delete search_varfb_instance_type;

   104

  search_varfb_instance_type = NULL;

   105

  return NULL;

   106

}

   107

   108

   109

   110

   111

   112

   113

   114

   115

   116

visit_expression_type_c::visit_expression_type_c(symbol_c *ignore) {

   117

  error_found = false;

   118

}

   119

   120

visit_expression_type_c::~visit_expression_type_c(void) {

   121

}

   122

   123

bool visit_expression_type_c::get_error_found(void) {

   124

  return error_found;

   125

}

   126

   127

   128

   129

/* NOTE on data type handling and literals...

   130

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

   131

 *

   132

 * Literals that are explicitly type cast 

   133

 *   e.g.:   BYTE#42

   134

 *           INT#65

   135

 *           TIME#45h23m

   136

 *               etc...

   137

 *  are NOT considered literals in the following code.

   138

 *  Since they are type cast, and their data type is fixed and well known,

   139

 *  they are treated as a variable of that data type (except when determining lvalues)

   140

 *  In other words, when calling search_constant_type_c on these constants, it returns

   141

 *  a xxxxx_type_name_c, and not one of the xxxx_literal_c ! 

   142

 *

   143

 *  When the following code handles a literal, it is really a literal of unknown data type.

   144

 *    e.g.   42, may be considered an int, a byte, a word, etc... 

   145

 *

   146

 * NOTE: type_symbol == NULL is valid!

   147

 *       This will occur, for example, when and undefined/undeclared symbolic_variable is used in the program.

   148

 *       This will not be of any type, so we always return false.

   149

 */

   150

   151

/* A helper function... */

   152

bool visit_expression_type_c::is_ANY_ELEMENTARY_type(symbol_c *type_symbol) {

   153

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

   154

  return is_ANY_MAGNITUDE_type(type_symbol)

   155

      || is_ANY_BIT_type      (type_symbol)

   156

      || is_ANY_STRING_type   (type_symbol)

   157

      || is_ANY_DATE_type     (type_symbol);

   158

}

   159

   160

/* A helper function... */

   161

bool visit_expression_type_c::is_ANY_SAFEELEMENTARY_type(symbol_c *type_symbol) {

   162

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

   163

  return is_ANY_SAFEMAGNITUDE_type(type_symbol)

   164

      || is_ANY_SAFEBIT_type      (type_symbol)

   165

      || is_ANY_SAFESTRING_type   (type_symbol)

   166

      || is_ANY_SAFEDATE_type     (type_symbol);

   167

}

   168

   169

/* A helper function... */

   170

bool visit_expression_type_c::is_ANY_ELEMENTARY_compatible(symbol_c *type_symbol) {

   171

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

   172

  /* NOTE: doing 

   173

   *          return is_ANY_SAFEELEMENTARY_type() || is_ANY_ELEMENTARY_type()

   174

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

   175

   */

   176

  return is_ANY_MAGNITUDE_compatible(type_symbol)

   177

      || is_ANY_BIT_compatible      (type_symbol)

   178

      || is_ANY_STRING_compatible   (type_symbol)

   179

      || is_ANY_DATE_compatible     (type_symbol);

   180

}

   181

   182

   183

/* A helper function... */

   184

bool visit_expression_type_c::is_ANY_MAGNITUDE_type(symbol_c *type_symbol) {

   185

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

   186

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

   187

  return is_ANY_NUM_type(type_symbol);

   188

}

   189

   190

/* A helper function... */

   191

bool visit_expression_type_c::is_ANY_SAFEMAGNITUDE_type(symbol_c *type_symbol) {

   192

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

   193

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

   194

  return is_ANY_SAFENUM_type(type_symbol);

   195

}

   196

   197

/* A helper function... */

   198

bool visit_expression_type_c::is_ANY_MAGNITUDE_compatible(symbol_c *type_symbol) {

   199

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

   200

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

   201

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

   202

   203

  return is_ANY_NUM_compatible(type_symbol);

   204

}

   205

   206

/* A helper function... */

   207

bool visit_expression_type_c::is_ANY_NUM_type(symbol_c *type_symbol) {

   208

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

   209

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

   210

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

   211

  return false;

   212

}

   213

   214

/* A helper function... */

   215

bool visit_expression_type_c::is_ANY_SAFENUM_type(symbol_c *type_symbol) {

   216

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

   217

  return is_ANY_SAFEREAL_type(type_symbol) 

   218

      || is_ANY_SAFEINT_type (type_symbol);

   219

}

   220

   221

/* A helper function... */

   222

bool visit_expression_type_c::is_ANY_NUM_compatible(symbol_c *type_symbol) {

   223

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

   224

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

   225

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

   226

  return false;  

   227

}

   228

   229

/* A helper function... */

   230

bool visit_expression_type_c::is_ANY_DATE_type(symbol_c *type_symbol) {

   231

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

   232

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

   233

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

   234

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

   235

  return false;

   236

}

   237

   238

/* A helper function... */

   239

bool visit_expression_type_c::is_ANY_SAFEDATE_type(symbol_c *type_symbol) {

   240

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

   241

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

   242

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

   243

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

   244

  return false;

   245

}

   246

   247

/* A helper function... */

   248

bool visit_expression_type_c::is_ANY_DATE_compatible(symbol_c *type_symbol) {

   249

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

   250

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

   251

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

   252

  return false;

   253

}

   254

   255

/* A helper function... */

   256

bool visit_expression_type_c::is_ANY_STRING_type(symbol_c *type_symbol) {

   257

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

   258

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

   259

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

   260

// TODO literal_string ???

   261

  return false;

   262

}

   263

   264

/* A helper function... */

   265

bool visit_expression_type_c::is_ANY_SAFESTRING_type(symbol_c *type_symbol) {

   266

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

   267

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

   268

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

   269

  return false;

   270

}

   271

   272

/* A helper function... */

   273

bool visit_expression_type_c::is_ANY_STRING_compatible(symbol_c *type_symbol) {

   274

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

   275

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

   276

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

   277

  return false;

   278

}

   279

   280

/* A helper function... */

   281

bool visit_expression_type_c::is_ANY_INT_type(symbol_c *type_symbol) {

   282

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

   283

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

   284

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

   285

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

   286

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

   287

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

   288

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

   289

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

   290

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

   291

  return false;

   292

}

   293

   294

/* A helper function... */

   295

bool visit_expression_type_c::is_ANY_SAFEINT_type(symbol_c *type_symbol) {

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

  return false;

   306

}

   307

   308

/* A helper function... */

   309

bool visit_expression_type_c::is_ANY_INT_compatible(symbol_c *type_symbol) {

   310

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

   311

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

   312

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

   313

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

   314

  return false;

   315

}

   316

   317

/* A helper function... */

   318

bool visit_expression_type_c::is_ANY_REAL_type(symbol_c *type_symbol) {

   319

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

   320

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

   321

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

   322

  return false;

   323

}

   324

   325

/* A helper function... */

   326

bool visit_expression_type_c::is_ANY_SAFEREAL_type(symbol_c *type_symbol) {

   327

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

   328

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

   329

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

   330

  return false;

   331

}

   332

   333

/* A helper function... */

   334

bool visit_expression_type_c::is_ANY_REAL_compatible(symbol_c *type_symbol) {

   335

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

   336

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

   337

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

   338

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

   339

  return false;

   340

}

   341

   342

/* A helper function... */

   343

bool visit_expression_type_c::is_ANY_BIT_type(symbol_c *type_symbol) {

   344

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

   345

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

   346

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

   347

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

   348

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

   349

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

   350

  return false;

   351

}

   352

   353

/* A helper function... */

   354

bool visit_expression_type_c::is_ANY_SAFEBIT_type(symbol_c *type_symbol) {

   355

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

   356

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

   357

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

   358

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

   359

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

   360

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

   361

  return false;

   362

}

   363

   364

/* A helper function... */

   365

bool visit_expression_type_c::is_ANY_BIT_compatible(symbol_c *type_symbol) {

   366

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

   367

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

   368

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

   369

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

   370

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

   371

  return false;

   372

}

   373

   374

/* A helper function... */

   375

bool visit_expression_type_c::is_BOOL_type(symbol_c *type_symbol) {

   376

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

   377

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

   378

  return false;

   379

}

   380

   381

/* A helper function... */

   382

bool visit_expression_type_c::is_SAFEBOOL_type(symbol_c *type_symbol){

   383

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

   384

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

   385

  return false;  

   386

}

   387

   388

/* A helper function... */

   389

bool visit_expression_type_c::is_ANY_BOOL_compatible(symbol_c *type_symbol) {

   390

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

   391

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

   392

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

   393

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

   394

  return false;

   395

}

   396

   397

   398

#define is_type(type_name_symbol, type_name_class)  (typeid(*type_name_symbol) == typeid(type_name_class))

   399

   400

   401

#define sizeoftype(symbol) get_sizeof_datatype_c::getsize(symbol)

   402

   403

   404

/* A helper function... */

   405

bool visit_expression_type_c::is_literal_integer_type(symbol_c *type_symbol) {

   406

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

   407

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

   408

  return is_nonneg_literal_integer_type(type_symbol);

   409

}

   410

   411

   412

/* A helper function... */

   413

bool visit_expression_type_c::is_nonneg_literal_integer_type(symbol_c *type_symbol) {

   414

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

   415

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

   416

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

   417

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

   418

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

   419

  return false;

   420

}

   421

   422

   423

/* A helper function... */

   424

bool visit_expression_type_c::is_literal_real_type(symbol_c *type_symbol) {

   425

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

   426

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

   427

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

   428

  return false;

   429

}

   430

   431

   432

/* A helper function... */

   433

bool visit_expression_type_c::is_literal_bool_type(symbol_c *type_symbol) {

   434

  bool_type_name_c bool_t;

   435

   436

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

   437

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

   438

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

   439

  if (is_nonneg_literal_integer_type(type_symbol))

   440

    if (sizeoftype(&bool_t) >= sizeoftype(type_symbol))  {return true;}

   441

  return false;

   442

}

   443

   444

/* Determine the common data type between two data types.

   445

 * If no common data type found, return NULL.

   446

 *

   447

 * If data types are identical, return the first (actually any would do...).

   448

 * If any of the data types is a literal, we confirm that 

   449

 *   the literal uses less bits than the fixed size data type.

   450

 *   e.g. BYTE and 1024 returns NULL

   451

 *        BYTE and 255  returns BYTE

   452

 *

   453

 * If two literals, then return the literal that requires more bits...

   454

 */

   455

   456

symbol_c *visit_expression_type_c::common_type__(symbol_c *first_type, symbol_c *second_type) {

   457

  if (first_type == NULL && second_type == NULL) {return NULL;}

   458

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

   459

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

   460

   461

  if (is_literal_integer_type(first_type) && is_literal_integer_type(second_type))

   462

    {return ((sizeoftype(first_type) > sizeoftype(second_type))? first_type:second_type);}

   463

   464

  if (is_literal_real_type(first_type) && is_literal_real_type(second_type))

   465

    {return ((sizeoftype(first_type) > sizeoftype(second_type))? first_type:second_type);}

   466

   467

  if (is_literal_bool_type(first_type) && is_literal_bool_type(second_type))

   468

    {return first_type;}

   469

   470

  /* The following check can only be made after the is_literal_XXXX checks */

   471

  /* When two literals of the same type, with identical typeid's are checked,

   472

   * we must return the one that occupies more bits... This is done above.

   473

   */

   474

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

   475

   476

  /* NOTE Although a BOOL is also an ANY_BIT, we must check it explicitly since some

   477

   *       literal bool values are not literal integers...

   478

   */ 

   479

  if (is_BOOL_type(first_type)        && is_literal_bool_type(second_type))    {return first_type;}

   480

  if (is_BOOL_type(second_type)       && is_literal_bool_type(first_type))     {return second_type;}

   481

   482

  if (is_SAFEBOOL_type(first_type)    && is_literal_bool_type(second_type))    {return first_type;}

   483

  if (is_SAFEBOOL_type(second_type)   && is_literal_bool_type(first_type))     {return second_type;}

   484

   485

  if (is_SAFEBOOL_type(first_type)    && is_BOOL_type(second_type))            {return second_type;}

   486

  if (is_SAFEBOOL_type(second_type)   && is_BOOL_type(first_type))             {return first_type;}

   487

   488

  if (is_ANY_BIT_type(first_type)     && is_nonneg_literal_integer_type(second_type))

   489

    {return ((sizeoftype(first_type)  >= sizeoftype(second_type))? first_type :NULL);}

   490

  if (is_ANY_BIT_type(second_type)    && is_nonneg_literal_integer_type(first_type))

   491

    {return ((sizeoftype(second_type) >= sizeoftype(first_type)) ? second_type:NULL);}

   492

   493

  if (is_ANY_SAFEBIT_type(first_type)     && is_nonneg_literal_integer_type(second_type))

   494

    {return ((sizeoftype(first_type)  >= sizeoftype(second_type))? first_type :NULL);}

   495

  if (is_ANY_SAFEBIT_type(second_type)    && is_nonneg_literal_integer_type(first_type))

   496

    {return ((sizeoftype(second_type) >= sizeoftype(first_type)) ? second_type:NULL);}

   497

   498

  if  (is_ANY_SAFEBIT_type(first_type)    && is_ANY_BIT_type(second_type))

   499

    {return ((sizeoftype(first_type) == sizeoftype(second_type))? second_type:NULL);}

   500

  if  (is_ANY_SAFEBIT_type(second_type)   && is_ANY_BIT_type(first_type))

   501

    {return ((sizeoftype(first_type) == sizeoftype(second_type))? first_type :NULL);}

   502

   503

  if (is_ANY_INT_type(first_type)     && is_literal_integer_type(second_type))