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

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

    17

            symbol_c *IN_param_value = &this->default_variable_name;

    18

    19

            symbol_c *IN_type_symbol = param_data_type;

    20

            last_type_symbol = param_data_type;

    21

    22

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

    23

            {

    24

    25

                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    26

                s4o.print("(");

    27

                return_type_symbol->accept(*this);

    28

                s4o.print(")");

    29

                IN_param_value->accept(*this);

    30

                return NULL;

    31

    32

            }

    33

    34

            ERROR;

    35

        }

    36

    37

    }/*function_bool_to_sint*/

    38

    break;

    39

    40

/****

    41

 *BOOL_TO_INT

    42

 */

    43

    case function_bool_to_int :

    44

    {

    45

        symbol_c *last_type_symbol = NULL;

    46

    47

        {

    48

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

    49

            symbol_c *IN_param_value = &this->default_variable_name;

    50

    51

            symbol_c *IN_type_symbol = param_data_type;

    52

            last_type_symbol = param_data_type;

    53

    54

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

    55

            {

    56

    57

                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

    58

                s4o.print("(");

    59

                return_type_symbol->accept(*this);

    60

                s4o.print(")");

    61

                IN_param_value->accept(*this);

    62

                return NULL;

    63

    64

            }

    65

    66

            ERROR;

    67

        }

    68

    69

    }/*function_bool_to_int*/

    70

    break;

    71

    72

/****

    73

 *BOOL_TO_DINT

    74

 */

    75

    case function_bool_to_dint :

    76

    {

    77

        symbol_c *last_type_symbol = NULL;

    78

    79

        {

    80

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

    81

            symbol_c *IN_param_value = &this->default_variable_name;

    82

    83

            symbol_c *IN_type_symbol = param_data_type;

    84

            last_type_symbol = param_data_type;

    85

    86

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

    87

            {

    88

    89

                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

    90

                s4o.print("(");

    91

                return_type_symbol->accept(*this);

    92

                s4o.print(")");

    93

                IN_param_value->accept(*this);

    94

                return NULL;

    95

    96

            }

    97

    98

            ERROR;

    99

        }

   100

   101

    }/*function_bool_to_dint*/

   102

    break;

   103

   104

/****

   105

 *BOOL_TO_LINT

   106

 */

   107

    case function_bool_to_lint :

   108

    {

   109

        symbol_c *last_type_symbol = NULL;

   110

   111

        {

   112

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

   113

            symbol_c *IN_param_value = &this->default_variable_name;

   114

   115

            symbol_c *IN_type_symbol = param_data_type;

   116

            last_type_symbol = param_data_type;

   117

   118

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

   119

            {

   120

   121

                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   122

                s4o.print("(");

   123

                return_type_symbol->accept(*this);

   124

                s4o.print(")");

   125

                IN_param_value->accept(*this);

   126

                return NULL;

   127

   128

            }

   129

   130

            ERROR;

   131

        }

   132

   133

    }/*function_bool_to_lint*/

   134

    break;

   135

   136

/****

   137

 *BOOL_TO_USINT

   138

 */

   139

    case function_bool_to_usint :

   140

    {

   141

        symbol_c *last_type_symbol = NULL;

   142

   143

        {

   144

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

   145

            symbol_c *IN_param_value = &this->default_variable_name;

   146

   147

            symbol_c *IN_type_symbol = param_data_type;

   148

            last_type_symbol = param_data_type;

   149

   150

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

   151

            {

   152

   153

                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   154

                s4o.print("(");

   155

                return_type_symbol->accept(*this);

   156

                s4o.print(")");

   157

                IN_param_value->accept(*this);

   158

                return NULL;

   159

   160

            }

   161

   162

            ERROR;

   163

        }

   164

   165

    }/*function_bool_to_usint*/

   166

    break;

   167

   168

/****

   169

 *BOOL_TO_UINT

   170

 */

   171

    case function_bool_to_uint :

   172

    {

   173

        symbol_c *last_type_symbol = NULL;

   174

   175

        {

   176

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

   177

            symbol_c *IN_param_value = &this->default_variable_name;

   178

   179

            symbol_c *IN_type_symbol = param_data_type;

   180

            last_type_symbol = param_data_type;

   181

   182

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

   183

            {

   184

   185

                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   186

                s4o.print("(");

   187

                return_type_symbol->accept(*this);

   188

                s4o.print(")");

   189

                IN_param_value->accept(*this);

   190

                return NULL;

   191

   192

            }

   193

   194

            ERROR;

   195

        }

   196

   197

    }/*function_bool_to_uint*/

   198

    break;

   199

   200

/****

   201

 *BOOL_TO_UDINT

   202

 */

   203

    case function_bool_to_udint :

   204

    {

   205

        symbol_c *last_type_symbol = NULL;

   206

   207

        {

   208

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

   209

            symbol_c *IN_param_value = &this->default_variable_name;

   210

   211

            symbol_c *IN_type_symbol = param_data_type;

   212

            last_type_symbol = param_data_type;

   213

   214

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

   215

            {

   216

   217

                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   218

                s4o.print("(");

   219

                return_type_symbol->accept(*this);

   220

                s4o.print(")");

   221

                IN_param_value->accept(*this);

   222

                return NULL;

   223

   224

            }

   225

   226

            ERROR;

   227

        }

   228

   229

    }/*function_bool_to_udint*/

   230

    break;

   231

   232

/****

   233

 *BOOL_TO_ULINT

   234

 */

   235

    case function_bool_to_ulint :

   236

    {

   237

        symbol_c *last_type_symbol = NULL;

   238

   239

        {

   240

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

   241

            symbol_c *IN_param_value = &this->default_variable_name;

   242

   243

            symbol_c *IN_type_symbol = param_data_type;

   244

            last_type_symbol = param_data_type;

   245

   246

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

   247

            {

   248

   249

                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   250

                s4o.print("(");

   251

                return_type_symbol->accept(*this);

   252

                s4o.print(")");

   253

                IN_param_value->accept(*this);

   254

                return NULL;

   255

   256

            }

   257

   258

            ERROR;

   259

        }

   260

   261

    }/*function_bool_to_ulint*/

   262

    break;

   263

   264

/****

   265

 *BOOL_TO_REAL

   266

 */

   267

    case function_bool_to_real :

   268

    {

   269

        symbol_c *last_type_symbol = NULL;

   270

   271

        {

   272

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

   273

            symbol_c *IN_param_value = &this->default_variable_name;

   274

   275

            symbol_c *IN_type_symbol = param_data_type;

   276

            last_type_symbol = param_data_type;

   277

   278

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

   279

            {

   280

   281

                symbol_c * return_type_symbol = &search_constant_type_c::real_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_real*/

   294

    break;

   295

   296

/****

   297

 *BOOL_TO_LREAL

   298

 */

   299

    case function_bool_to_lreal :

   300

    {

   301

        symbol_c *last_type_symbol = NULL;

   302

   303

        {

   304

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

   305

            symbol_c *IN_param_value = &this->default_variable_name;

   306

   307

            symbol_c *IN_type_symbol = param_data_type;

   308

            last_type_symbol = param_data_type;

   309

   310

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

   311

            {

   312

   313

                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   314

                s4o.print("(");

   315

                return_type_symbol->accept(*this);

   316

                s4o.print(")");

   317

                IN_param_value->accept(*this);

   318

                return NULL;

   319

   320

            }

   321

   322

            ERROR;

   323

        }

   324

   325

    }/*function_bool_to_lreal*/

   326

    break;

   327

   328

/****

   329

 *BOOL_TO_TIME

   330

 */

   331

    case function_bool_to_time :

   332

    {

   333

        symbol_c *last_type_symbol = NULL;

   334

   335

        {

   336

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

   337

            symbol_c *IN_param_value = &this->default_variable_name;

   338

   339

            symbol_c *IN_type_symbol = param_data_type;

   340

            last_type_symbol = param_data_type;

   341

   342

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

   343

            {

   344

   345

                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   346

                s4o.print("(");

   347

                return_type_symbol->accept(*this);

   348

                s4o.print(")__int_to_time(");

   349

                IN_param_value->accept(*this);

   350

                s4o.print(")");

   351

                return NULL;

   352

   353

            }

   354

   355

            ERROR;

   356

        }

   357

   358

    }/*function_bool_to_time*/

   359

    break;

   360

   361

/****

   362

 *BOOL_TO_DATE

   363

 */

   364

    case function_bool_to_date :

   365

    {

   366

        symbol_c *last_type_symbol = NULL;

   367

   368

        {

   369

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

   370

            symbol_c *IN_param_value = &this->default_variable_name;

   371

   372

            symbol_c *IN_type_symbol = param_data_type;

   373

            last_type_symbol = param_data_type;

   374

   375

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

   376

            {

   377

   378

                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   379

                s4o.print("(");

   380

                return_type_symbol->accept(*this);

   381

                s4o.print(")__int_to_time(");

   382

                IN_param_value->accept(*this);

   383

                s4o.print(")");

   384

                return NULL;

   385

   386

            }

   387

   388

            ERROR;

   389

        }

   390

   391

    }/*function_bool_to_date*/

   392

    break;

   393

   394

/****

   395

 *BOOL_TO_TOD

   396

 */

   397

    case function_bool_to_tod :

   398

    {

   399

        symbol_c *last_type_symbol = NULL;

   400

   401

        {

   402

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

   403

            symbol_c *IN_param_value = &this->default_variable_name;

   404

   405

            symbol_c *IN_type_symbol = param_data_type;

   406

            last_type_symbol = param_data_type;

   407

   408

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

   409

            {

   410

   411

                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   412

                s4o.print("(");

   413

                return_type_symbol->accept(*this);

   414

                s4o.print(")__int_to_time(");

   415

                IN_param_value->accept(*this);

   416

                s4o.print(")");

   417

                return NULL;

   418

   419

            }

   420

   421

            ERROR;

   422

        }

   423

   424

    }/*function_bool_to_tod*/

   425

    break;

   426

   427

/****

   428

 *BOOL_TO_DT

   429

 */

   430

    case function_bool_to_dt :

   431

    {

   432

        symbol_c *last_type_symbol = NULL;

   433

   434

        {

   435

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

   436

            symbol_c *IN_param_value = &this->default_variable_name;

   437

   438

            symbol_c *IN_type_symbol = param_data_type;

   439

            last_type_symbol = param_data_type;

   440

   441

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

   442

            {

   443

   444

                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   445

                s4o.print("(");

   446

                return_type_symbol->accept(*this);

   447

                s4o.print(")__int_to_time(");

   448

                IN_param_value->accept(*this);

   449

                s4o.print(")");

   450

                return NULL;

   451

   452

            }

   453

   454

            ERROR;

   455

        }

   456

   457

    }/*function_bool_to_dt*/

   458

    break;

   459

   460

/****

   461

 *BOOL_TO_STRING

   462

 */

   463

    case function_bool_to_string :

   464

    {

   465

        symbol_c *last_type_symbol = NULL;

   466

   467

        {

   468

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

   469

            symbol_c *IN_param_value = &this->default_variable_name;

   470

   471

            symbol_c *IN_type_symbol = param_data_type;

   472

            last_type_symbol = param_data_type;

   473

   474

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

   475

            {

   476

   477

                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   478

                s4o.print("(");

   479

                return_type_symbol->accept(*this);

   480

                s4o.print(")__bool_to_string(");

   481

                IN_param_value->accept(*this);

   482

                s4o.print(")");

   483

                return NULL;

   484

   485

            }

   486

   487

            ERROR;

   488

        }

   489

   490

    }/*function_bool_to_string*/

   491

    break;

   492

   493

/****

   494

 *BOOL_TO_BYTE

   495

 */

   496

    case function_bool_to_byte :

   497

    {