1

     2

/****

     3

 * IEC 61131-3 standard function lib

     4

 * generated code, do not edit by hand

     5

 */

     6

switch(current_function_type){

     7

     8

/****

     9

 *BOOL_TO_SINT

    10

 */

    11

    case function_bool_to_sint :

    12

    {

    13

        symbol_c *last_type_symbol = NULL;

    14

    15

        {

    16

            identifier_c param_name("IN");

    17

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

    18

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

    19

    20

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

    21

            if (IN_param_value == NULL)

    22

              IN_param_value = function_call_param_iterator.next();

    23

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

    24

            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 ;

    25

    26

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

    27

            {

    28

    29

                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    30

                s4o.print("(");

    31

                return_type_symbol->accept(*this);

    32

                s4o.print(")");

    33

                IN_param_value->accept(*this);

    34

                return NULL;

    35

    36

            }

    37

    38

            ERROR;

    39

        }

    40

    41

    }/*function_bool_to_sint*/

    42

    break;

    43

    44

/****

    45

 *BOOL_TO_INT

    46

 */

    47

    case function_bool_to_int :

    48

    {

    49

        symbol_c *last_type_symbol = NULL;

    50

    51

        {

    52

            identifier_c param_name("IN");

    53

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

    54

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

    55

    56

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

    57

            if (IN_param_value == NULL)

    58

              IN_param_value = function_call_param_iterator.next();

    59

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

    60

            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 ;

    61

    62

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

    63

            {

    64

    65

                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

    66

                s4o.print("(");

    67

                return_type_symbol->accept(*this);

    68

                s4o.print(")");

    69

                IN_param_value->accept(*this);

    70

                return NULL;

    71

    72

            }

    73

    74

            ERROR;

    75

        }

    76

    77

    }/*function_bool_to_int*/

    78

    break;

    79

    80

/****

    81

 *BOOL_TO_DINT

    82

 */

    83

    case function_bool_to_dint :

    84

    {

    85

        symbol_c *last_type_symbol = NULL;

    86

    87

        {

    88

            identifier_c param_name("IN");

    89

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

    90

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

    91

    92

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

    93

            if (IN_param_value == NULL)

    94

              IN_param_value = function_call_param_iterator.next();

    95

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

    96

            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 ;

    97

    98

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

    99

            {

   100

   101

                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   102

                s4o.print("(");

   103

                return_type_symbol->accept(*this);

   104

                s4o.print(")");

   105

                IN_param_value->accept(*this);

   106

                return NULL;

   107

   108

            }

   109

   110

            ERROR;

   111

        }

   112

   113

    }/*function_bool_to_dint*/

   114

    break;

   115

   116

/****

   117

 *BOOL_TO_LINT

   118

 */

   119

    case function_bool_to_lint :

   120

    {

   121

        symbol_c *last_type_symbol = NULL;

   122

   123

        {

   124

            identifier_c param_name("IN");

   125

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

   126

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

   127

   128

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

   129

            if (IN_param_value == NULL)

   130

              IN_param_value = function_call_param_iterator.next();

   131

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

   132

            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 ;

   133

   134

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

   135

            {

   136

   137

                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   138

                s4o.print("(");

   139

                return_type_symbol->accept(*this);

   140

                s4o.print(")");

   141

                IN_param_value->accept(*this);

   142

                return NULL;

   143

   144

            }

   145

   146

            ERROR;

   147

        }

   148

   149

    }/*function_bool_to_lint*/

   150

    break;

   151

   152

/****

   153

 *BOOL_TO_USINT

   154

 */

   155

    case function_bool_to_usint :

   156

    {

   157

        symbol_c *last_type_symbol = NULL;

   158

   159

        {

   160

            identifier_c param_name("IN");

   161

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

   162

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

   163

   164

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

   165

            if (IN_param_value == NULL)

   166

              IN_param_value = function_call_param_iterator.next();

   167

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

   168

            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 ;

   169

   170

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

   171

            {

   172

   173

                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   174

                s4o.print("(");

   175

                return_type_symbol->accept(*this);

   176

                s4o.print(")");

   177

                IN_param_value->accept(*this);

   178

                return NULL;

   179

   180

            }

   181

   182

            ERROR;

   183

        }

   184

   185

    }/*function_bool_to_usint*/

   186

    break;

   187

   188

/****

   189

 *BOOL_TO_UINT

   190

 */

   191

    case function_bool_to_uint :

   192

    {

   193

        symbol_c *last_type_symbol = NULL;

   194

   195

        {

   196

            identifier_c param_name("IN");

   197

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

   198

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

   199

   200

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

   201

            if (IN_param_value == NULL)

   202

              IN_param_value = function_call_param_iterator.next();

   203

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

   204

            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 ;

   205

   206

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

   207

            {

   208

   209

                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   210

                s4o.print("(");

   211

                return_type_symbol->accept(*this);

   212

                s4o.print(")");

   213

                IN_param_value->accept(*this);

   214

                return NULL;

   215

   216

            }

   217

   218

            ERROR;

   219

        }

   220

   221

    }/*function_bool_to_uint*/

   222

    break;

   223

   224

/****

   225

 *BOOL_TO_UDINT

   226

 */

   227

    case function_bool_to_udint :

   228

    {

   229

        symbol_c *last_type_symbol = NULL;

   230

   231

        {

   232

            identifier_c param_name("IN");

   233

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

   234

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

   235

   236

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

   237

            if (IN_param_value == NULL)

   238

              IN_param_value = function_call_param_iterator.next();

   239

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

   240

            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 ;

   241

   242

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

   243

            {

   244

   245

                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   246

                s4o.print("(");

   247

                return_type_symbol->accept(*this);

   248

                s4o.print(")");

   249

                IN_param_value->accept(*this);

   250

                return NULL;

   251

   252

            }

   253

   254

            ERROR;

   255

        }

   256

   257

    }/*function_bool_to_udint*/

   258

    break;

   259

   260

/****

   261

 *BOOL_TO_ULINT

   262

 */

   263

    case function_bool_to_ulint :

   264

    {

   265

        symbol_c *last_type_symbol = NULL;

   266

   267

        {

   268

            identifier_c param_name("IN");

   269

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

   270

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

   271

   272

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

   273

            if (IN_param_value == NULL)

   274

              IN_param_value = function_call_param_iterator.next();

   275

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

   276

            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 ;

   277

   278

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

   279

            {

   280

   281

                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   282

                s4o.print("(");

   283

                return_type_symbol->accept(*this);

   284

                s4o.print(")");

   285

                IN_param_value->accept(*this);

   286

                return NULL;

   287

   288

            }

   289

   290

            ERROR;

   291

        }

   292

   293

    }/*function_bool_to_ulint*/

   294

    break;

   295

   296

/****

   297

 *BOOL_TO_REAL

   298

 */

   299

    case function_bool_to_real :

   300

    {

   301

        symbol_c *last_type_symbol = NULL;

   302

   303

        {

   304

            identifier_c param_name("IN");

   305

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

   306

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

   307

   308

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

   309

            if (IN_param_value == NULL)

   310

              IN_param_value = function_call_param_iterator.next();

   311

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

   312

            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 ;

   313

   314

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

   315

            {

   316

   317

                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   318

                s4o.print("(");

   319

                return_type_symbol->accept(*this);

   320

                s4o.print(")");

   321

                IN_param_value->accept(*this);

   322

                return NULL;

   323

   324

            }

   325

   326

            ERROR;

   327

        }

   328

   329

    }/*function_bool_to_real*/

   330

    break;

   331

   332

/****

   333

 *BOOL_TO_LREAL

   334

 */

   335

    case function_bool_to_lreal :

   336

    {

   337

        symbol_c *last_type_symbol = NULL;

   338

   339

        {

   340

            identifier_c param_name("IN");

   341

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

   342

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

   343

   344

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

   345

            if (IN_param_value == NULL)

   346

              IN_param_value = function_call_param_iterator.next();

   347

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

   348

            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 ;

   349

   350

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

   351

            {

   352

   353

                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   354

                s4o.print("(");

   355

                return_type_symbol->accept(*this);

   356

                s4o.print(")");

   357

                IN_param_value->accept(*this);

   358

                return NULL;

   359

   360

            }

   361

   362

            ERROR;

   363

        }

   364

   365

    }/*function_bool_to_lreal*/

   366

    break;

   367

   368

/****

   369

 *BOOL_TO_TIME

   370

 */

   371

    case function_bool_to_time :

   372

    {

   373

        symbol_c *last_type_symbol = NULL;

   374

   375

        {

   376

            identifier_c param_name("IN");

   377

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

   378

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

   379

   380

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

   381

            if (IN_param_value == NULL)

   382

              IN_param_value = function_call_param_iterator.next();

   383

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

   384

            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 ;

   385

   386

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

   387

            {

   388

   389

                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   390

                s4o.print("(");

   391

                return_type_symbol->accept(*this);

   392

                s4o.print(")__int_to_time(");

   393

                IN_param_value->accept(*this);

   394

                s4o.print(")");

   395

                return NULL;

   396

   397

            }

   398

   399

            ERROR;

   400

        }

   401

   402

    }/*function_bool_to_time*/

   403

    break;

   404

   405

/****

   406

 *BOOL_TO_DATE

   407

 */

   408

    case function_bool_to_date :

   409

    {

   410

        symbol_c *last_type_symbol = NULL;

   411

   412

        {

   413

            identifier_c param_name("IN");

   414

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

   415

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

   416

   417

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

   418

            if (IN_param_value == NULL)

   419

              IN_param_value = function_call_param_iterator.next();

   420

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

   421

            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 ;

   422

   423

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

   424

            {

   425

   426

                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   427

                s4o.print("(");

   428

                return_type_symbol->accept(*this);

   429

                s4o.print(")__int_to_time(");

   430

                IN_param_value->accept(*this);

   431

                s4o.print(")");

   432

                return NULL;

   433

   434

            }

   435

   436

            ERROR;

   437

        }

   438

   439

    }/*function_bool_to_date*/

   440

    break;

   441

   442

/****

   443

 *BOOL_TO_TOD

   444

 */

   445

    case function_bool_to_tod :

   446

    {

   447

        symbol_c *last_type_symbol = NULL;

   448

   449

        {

   450

            identifier_c param_name("IN");

   451

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

   452

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

   453

   454

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

   455

            if (IN_param_value == NULL)

   456

              IN_param_value = function_call_param_iterator.next();

   457

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

   458

            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 ;

   459

   460

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

   461

            {

   462

   463

                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   464

                s4o.print("(");

   465

                return_type_symbol->accept(*this);

   466

                s4o.print(")__int_to_time(");

   467

                IN_param_value->accept(*this);

   468

                s4o.print(")");

   469

                return NULL;

   470

   471

            }

   472

   473

            ERROR;

   474

        }

   475

   476

    }/*function_bool_to_tod*/

   477

    break;

   478

   479

/****

   480

 *BOOL_TO_DT

   481

 */

   482

    case function_bool_to_dt :

   483

    {

   484

        symbol_c *last_type_symbol = NULL;

   485

   486

        {

   487

            identifier_c param_name("IN");

   488

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

   489

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

   490

   491

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

   492

            if (IN_param_value == NULL)

   493

              IN_param_value = function_call_param_iterator.next();

   494

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

   495

            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 ;

   496

   497

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