16

 *BOOL_TO_SINT

    17

 */

    18

    case function_bool_to_sint :

    19

    {

    20

        symbol_c *last_type_symbol = NULL;

    21

    22

        {

    23

            identifier_c param_name("IN");

    24

            /* Get the value from a foo(<param_name> = <param_value>) style call */

    25

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

    26

    27

            /* Get the value from a foo(<param_value>) style call */

    28

            if (IN_param_value == NULL)

    29

              IN_param_value = function_call_param_iterator.next();

    30

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

    31

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

    32

    33

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

    34

            {

    35

    36

                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    37

                return return_type_symbol;

    38

    39

            }

    40

    41

            ERROR;

    42

        }

    43

    44

    }/*function_bool_to_sint*/

    45

    break;

    46

    47

/****

    48

 *BOOL_TO_INT

    49

 */

    50

    case function_bool_to_int :

    51

    {

    52

        symbol_c *last_type_symbol = NULL;

    53

    54

        {

    55

            identifier_c param_name("IN");

    56

            /* Get the value from a foo(<param_name> = <param_value>) style call */

    57

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

    58

    59

            /* Get the value from a foo(<param_value>) style call */

    60

            if (IN_param_value == NULL)

    61

              IN_param_value = function_call_param_iterator.next();

    62

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

    63

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

    64

    65

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

    66

            {

    67

    68

                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

    69

                return return_type_symbol;

    70

    71

            }

    72

    73

            ERROR;

    74

        }

    75

    76

    }/*function_bool_to_int*/

    77

    break;

    78

    79

/****

    80

 *BOOL_TO_DINT

    81

 */

    82

    case function_bool_to_dint :

    83

    {

    84

        symbol_c *last_type_symbol = NULL;

    85

    86

        {

    87

            identifier_c param_name("IN");

    88

            /* Get the value from a foo(<param_name> = <param_value>) style call */

    89

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

    90

    91

            /* Get the value from a foo(<param_value>) style call */

    92

            if (IN_param_value == NULL)

    93

              IN_param_value = function_call_param_iterator.next();

    94

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

    95

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

    96

    97

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

    98

            {

    99

   100

                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   101

                return return_type_symbol;

   102

   103

            }

   104

   105

            ERROR;

   106

        }

   107

   108

    }/*function_bool_to_dint*/

   109

    break;

   110

   111

/****

   112

 *BOOL_TO_LINT

   113

 */

   114

    case function_bool_to_lint :

   115

    {

   116

        symbol_c *last_type_symbol = NULL;

   117

   118

        {

   119

            identifier_c param_name("IN");

   120

            /* Get the value from a foo(<param_name> = <param_value>) style call */

   121

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   122

   123

            /* Get the value from a foo(<param_value>) style call */

   124

            if (IN_param_value == NULL)

   125

              IN_param_value = function_call_param_iterator.next();

   126

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   127

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   128

   129

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   130

            {

   131

   132

                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   133

                return return_type_symbol;

   134

   135

            }

   136

   137

            ERROR;

   138

        }

   139

   140

    }/*function_bool_to_lint*/

   141

    break;

   142

   143

/****

   144

 *BOOL_TO_USINT

   145

 */

   146

    case function_bool_to_usint :

   147

    {

   148

        symbol_c *last_type_symbol = NULL;

   149

   150

        {

   151

            identifier_c param_name("IN");

   152

            /* Get the value from a foo(<param_name> = <param_value>) style call */

   153

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   154

   155

            /* Get the value from a foo(<param_value>) style call */

   156

            if (IN_param_value == NULL)

   157

              IN_param_value = function_call_param_iterator.next();

   158

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   159

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   160

   161

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   162

            {

   163

   164

                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   165

                return return_type_symbol;

   166

   167

            }

   168

   169

            ERROR;

   170

        }

   171

   172

    }/*function_bool_to_usint*/

   173

    break;

   174

   175

/****

   176

 *BOOL_TO_UINT

   177

 */

   178

    case function_bool_to_uint :

   179

    {

   180

        symbol_c *last_type_symbol = NULL;

   181

   182

        {

   183

            identifier_c param_name("IN");

   184

            /* Get the value from a foo(<param_name> = <param_value>) style call */

   185

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   186

   187

            /* Get the value from a foo(<param_value>) style call */

   188

            if (IN_param_value == NULL)

   189

              IN_param_value = function_call_param_iterator.next();

   190

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   191

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   192

   193

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   194

            {

   195

   196

                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   197

                return return_type_symbol;

   198

   199

            }

   200

   201

            ERROR;

   202

        }

   203

   204

    }/*function_bool_to_uint*/

   205

    break;

   206

   207

/****

   208

 *BOOL_TO_UDINT

   209

 */

   210

    case function_bool_to_udint :

   211

    {

   212

        symbol_c *last_type_symbol = NULL;

   213

   214

        {

   215

            identifier_c param_name("IN");

   216

            /* Get the value from a foo(<param_name> = <param_value>) style call */

   217

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   218

   219

            /* Get the value from a foo(<param_value>) style call */

   220

            if (IN_param_value == NULL)

   221

              IN_param_value = function_call_param_iterator.next();

   222

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   223

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   224

   225

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   226

            {

   227

   228

                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   229

                return return_type_symbol;

   230

   231

            }

   232

   233

            ERROR;

   234

        }

   235

   236

    }/*function_bool_to_udint*/

   237

    break;

   238

   239

/****

   240

 *BOOL_TO_ULINT

   241

 */

   242

    case function_bool_to_ulint :

   243

    {

   244

        symbol_c *last_type_symbol = NULL;

   245

   246

        {

   247

            identifier_c param_name("IN");

   248

            /* Get the value from a foo(<param_name> = <param_value>) style call */

   249

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   250

   251

            /* Get the value from a foo(<param_value>) style call */

   252

            if (IN_param_value == NULL)

   253

              IN_param_value = function_call_param_iterator.next();

   254

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   255

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   256

   257

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   258

            {

   259

   260

                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   261

                return return_type_symbol;

   262

   263

            }

   264

   265

            ERROR;

   266

        }

   267

   268

    }/*function_bool_to_ulint*/

   269

    break;

   270

   271

/****

   272

 *BOOL_TO_REAL

   273

 */

   274

    case function_bool_to_real :

   275

    {

   276

        symbol_c *last_type_symbol = NULL;

   277

   278

        {

   279

            identifier_c param_name("IN");

   280

            /* Get the value from a foo(<param_name> = <param_value>) style call */

   281

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   282

   283

            /* Get the value from a foo(<param_value>) style call */

   284

            if (IN_param_value == NULL)

   285

              IN_param_value = function_call_param_iterator.next();

   286

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   287

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   288

   289

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   290

            {

   291

   292

                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   293

                return return_type_symbol;

   294

   295

            }

   296

   297

            ERROR;

   298

        }

   299

   300

    }/*function_bool_to_real*/

   301

    break;

   302

   303

/****

   304

 *BOOL_TO_LREAL

   305

 */

   306

    case function_bool_to_lreal :

   307

    {

   308

        symbol_c *last_type_symbol = NULL;

   309

   310

        {

   311

            identifier_c param_name("IN");

   312

            /* Get the value from a foo(<param_name> = <param_value>) style call */

   313

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   314

   315

            /* Get the value from a foo(<param_value>) style call */

   316

            if (IN_param_value == NULL)

   317

              IN_param_value = function_call_param_iterator.next();

   318

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   319

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   320

   321

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   322

            {

   323

   324

                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   325

                return return_type_symbol;

   326

   327

            }

   328

   329

            ERROR;

   330

        }

   331

   332

    }/*function_bool_to_lreal*/

   333

    break;

   334

   335

/****

   336

 *BOOL_TO_TIME

   337

 */

   338

    case function_bool_to_time :

   339

    {

   340

        symbol_c *last_type_symbol = NULL;

   341

   342

        {

   343

            identifier_c param_name("IN");

   344

            /* Get the value from a foo(<param_name> = <param_value>) style call */

   345

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   346

   347

            /* Get the value from a foo(<param_value>) style call */

   348

            if (IN_param_value == NULL)

   349

              IN_param_value = function_call_param_iterator.next();

   350

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   351

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   352

   353

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   354

            {

   355

   356

                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   357

                return return_type_symbol;

   358

   359

            }

   360

   361

            ERROR;

   362

        }

   363

   364

    }/*function_bool_to_time*/

   365

    break;

   366

   367

/****

   368

 *BOOL_TO_DATE

   369

 */

   370

    case function_bool_to_date :

   371

    {

   372

        symbol_c *last_type_symbol = NULL;

   373

   374

        {

   375

            identifier_c param_name("IN");

   376

            /* Get the value from a foo(<param_name> = <param_value>) style call */

   377

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   378

   379

            /* Get the value from a foo(<param_value>) style call */

   380

            if (IN_param_value == NULL)

   381

              IN_param_value = function_call_param_iterator.next();

   382

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   383

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   384

   385

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   386

            {

   387

   388

                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   389

                return return_type_symbol;

   390

   391

            }

   392

   393

            ERROR;

   394

        }

   395

   396

    }/*function_bool_to_date*/

   397

    break;

   398

   399

/****

   400

 *BOOL_TO_TOD

   401

 */

   402

    case function_bool_to_tod :

   403

    {

   404

        symbol_c *last_type_symbol = NULL;

   405

   406

        {

   407

            identifier_c param_name("IN");

   408

            /* Get the value from a foo(<param_name> = <param_value>) style call */

   409

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   410

   411

            /* Get the value from a foo(<param_value>) style call */

   412

            if (IN_param_value == NULL)

   413

              IN_param_value = function_call_param_iterator.next();

   414

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   415

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   416

   417

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   418

            {

   419

   420

                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   421

                return return_type_symbol;

   422

   423

            }

   424

   425

            ERROR;

   426

        }

   427

   428

    }/*function_bool_to_tod*/

   429

    break;

   430

   431

/****

   432

 *BOOL_TO_DT

   433

 */

   434

    case function_bool_to_dt :

   435

    {

   436

        symbol_c *last_type_symbol = NULL;

   437

   438

        {

   439

            identifier_c param_name("IN");

   440

            /* Get the value from a foo(<param_name> = <param_value>) style call */

   441

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   442

   443

            /* Get the value from a foo(<param_value>) style call */

   444

            if (IN_param_value == NULL)

   445

              IN_param_value = function_call_param_iterator.next();

   446

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   447

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   448

   449

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   450

            {

   451

   452

                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   453

                return return_type_symbol;

   454

   455

            }

   456

   457

            ERROR;

   458

        }

   459

   460

    }/*function_bool_to_dt*/

   461

    break;

   462

   463

/****

   464

 *BOOL_TO_STRING

   465

 */

   466

    case function_bool_to_string :

   467

    {

   468

        symbol_c *last_type_symbol = NULL;

   469

   470

        {

   471

            identifier_c param_name("IN");

   472

            /* Get the value from a foo(<param_name> = <param_value>) style call */

   473

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   474

   475

            /* Get the value from a foo(<param_value>) style call */

   476

            if (IN_param_value == NULL)

   477

              IN_param_value = function_call_param_iterator.next();

   478

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   479

            last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   480

   481

            if (typeid(*last_type_symbol) == typeid(bool_type_name_c))

   482

            {

   483

   484

                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   485

                return return_type_symbol;

   486

   487

            }

   488

   489

            ERROR;

   490

        }

   491

   492

    }/*function_bool_to_string*/

   493

    break;

   494

   495

/****

   496

 *BOOL_TO_BYTE

   497