1

/*

     2

 * (c) 2003 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

/****

    27

 * IEC 61131-3 standard function lib

    28

 * generated code, do not edit by hand

    29

 */

    30

switch(current_function_type){

    31

    32

/****

    33

 *BOOL_TO_SINT

    34

 */

    35

    case function_bool_to_sint :

    36

    {

    37

        symbol_c *last_type_symbol = NULL;

    38

    39

        {

    40

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

    41

            symbol_c *IN_param_value = &this->default_variable_name;

    42

    43

            symbol_c *IN_type_symbol = param_data_type;

    44

            last_type_symbol = param_data_type;

    45

    46

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

    47

            {

    48

    49

                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    50

                s4o.print("(");

    51

                return_type_symbol->accept(*this);

    52

                s4o.print(")");

    53

                IN_param_value->accept(*this);

    54

                return NULL;

    55

    56

            }

    57

    58

            ERROR;

    59

        }

    60

    61

    }/*function_bool_to_sint*/

    62

    break;

    63

    64

/****

    65

 *BOOL_TO_INT

    66

 */

    67

    case function_bool_to_int :

    68

    {

    69

        symbol_c *last_type_symbol = NULL;

    70

    71

        {

    72

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

    73

            symbol_c *IN_param_value = &this->default_variable_name;

    74

    75

            symbol_c *IN_type_symbol = param_data_type;

    76

            last_type_symbol = param_data_type;

    77

    78

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

    79

            {

    80

    81

                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

    82

                s4o.print("(");

    83

                return_type_symbol->accept(*this);

    84

                s4o.print(")");

    85

                IN_param_value->accept(*this);

    86

                return NULL;

    87

    88

            }

    89

    90

            ERROR;

    91

        }

    92

    93

    }/*function_bool_to_int*/

    94

    break;

    95

    96

/****

    97

 *BOOL_TO_DINT

    98

 */

    99

    case function_bool_to_dint :

   100

    {

   101

        symbol_c *last_type_symbol = NULL;

   102

   103

        {

   104

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

   105

            symbol_c *IN_param_value = &this->default_variable_name;

   106

   107

            symbol_c *IN_type_symbol = param_data_type;

   108

            last_type_symbol = param_data_type;

   109

   110

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   111

            {

   112

   113

                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   114

                s4o.print("(");

   115

                return_type_symbol->accept(*this);

   116

                s4o.print(")");

   117

                IN_param_value->accept(*this);

   118

                return NULL;

   119

   120

            }

   121

   122

            ERROR;

   123

        }

   124

   125

    }/*function_bool_to_dint*/

   126

    break;

   127

   128

/****

   129

 *BOOL_TO_LINT

   130

 */

   131

    case function_bool_to_lint :

   132

    {

   133

        symbol_c *last_type_symbol = NULL;

   134

   135

        {

   136

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

   137

            symbol_c *IN_param_value = &this->default_variable_name;

   138

   139

            symbol_c *IN_type_symbol = param_data_type;

   140

            last_type_symbol = param_data_type;

   141

   142

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   143

            {

   144

   145

                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   146

                s4o.print("(");

   147

                return_type_symbol->accept(*this);

   148

                s4o.print(")");

   149

                IN_param_value->accept(*this);

   150

                return NULL;

   151

   152

            }

   153

   154

            ERROR;

   155

        }

   156

   157

    }/*function_bool_to_lint*/

   158

    break;

   159

   160

/****

   161

 *BOOL_TO_USINT

   162

 */

   163

    case function_bool_to_usint :

   164

    {

   165

        symbol_c *last_type_symbol = NULL;

   166

   167

        {

   168

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

   169

            symbol_c *IN_param_value = &this->default_variable_name;

   170

   171

            symbol_c *IN_type_symbol = param_data_type;

   172

            last_type_symbol = param_data_type;

   173

   174

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   175

            {

   176

   177

                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   178

                s4o.print("(");

   179

                return_type_symbol->accept(*this);

   180

                s4o.print(")");

   181

                IN_param_value->accept(*this);

   182

                return NULL;

   183

   184

            }

   185

   186

            ERROR;

   187

        }

   188

   189

    }/*function_bool_to_usint*/

   190

    break;

   191

   192

/****

   193

 *BOOL_TO_UINT

   194

 */

   195

    case function_bool_to_uint :

   196

    {

   197

        symbol_c *last_type_symbol = NULL;

   198

   199

        {

   200

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

   201

            symbol_c *IN_param_value = &this->default_variable_name;

   202

   203

            symbol_c *IN_type_symbol = param_data_type;

   204

            last_type_symbol = param_data_type;

   205

   206

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   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

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

   233

            symbol_c *IN_param_value = &this->default_variable_name;

   234

   235

            symbol_c *IN_type_symbol = param_data_type;

   236

            last_type_symbol = param_data_type;

   237

   238

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   239

            {

   240

   241

                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   242

                s4o.print("(");

   243

                return_type_symbol->accept(*this);

   244

                s4o.print(")");

   245

                IN_param_value->accept(*this);

   246

                return NULL;

   247

   248

            }

   249

   250

            ERROR;

   251

        }

   252

   253

    }/*function_bool_to_udint*/

   254

    break;

   255

   256

/****

   257

 *BOOL_TO_ULINT

   258

 */

   259

    case function_bool_to_ulint :

   260

    {

   261

        symbol_c *last_type_symbol = NULL;

   262

   263

        {

   264

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

   265

            symbol_c *IN_param_value = &this->default_variable_name;

   266

   267

            symbol_c *IN_type_symbol = param_data_type;

   268

            last_type_symbol = param_data_type;

   269

   270

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   271

            {

   272

   273

                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   274

                s4o.print("(");

   275

                return_type_symbol->accept(*this);

   276

                s4o.print(")");

   277

                IN_param_value->accept(*this);

   278

                return NULL;

   279

   280

            }

   281

   282

            ERROR;

   283

        }

   284

   285

    }/*function_bool_to_ulint*/

   286

    break;

   287

   288

/****

   289

 *BOOL_TO_REAL

   290

 */

   291

    case function_bool_to_real :

   292

    {

   293

        symbol_c *last_type_symbol = NULL;

   294

   295

        {

   296

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

   297

            symbol_c *IN_param_value = &this->default_variable_name;

   298

   299

            symbol_c *IN_type_symbol = param_data_type;

   300

            last_type_symbol = param_data_type;

   301

   302

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   303

            {

   304

   305

                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   306

                s4o.print("(");

   307

                return_type_symbol->accept(*this);

   308

                s4o.print(")");

   309

                IN_param_value->accept(*this);

   310

                return NULL;

   311

   312

            }

   313

   314

            ERROR;

   315

        }

   316

   317

    }/*function_bool_to_real*/

   318

    break;

   319

   320

/****

   321

 *BOOL_TO_LREAL

   322

 */

   323

    case function_bool_to_lreal :

   324

    {

   325

        symbol_c *last_type_symbol = NULL;

   326

   327

        {

   328

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

   329

            symbol_c *IN_param_value = &this->default_variable_name;

   330

   331

            symbol_c *IN_type_symbol = param_data_type;

   332

            last_type_symbol = param_data_type;

   333

   334

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   335

            {

   336

   337

                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   338

                s4o.print("(");

   339

                return_type_symbol->accept(*this);

   340

                s4o.print(")");

   341

                IN_param_value->accept(*this);

   342

                return NULL;

   343

   344

            }

   345

   346

            ERROR;

   347

        }

   348

   349

    }/*function_bool_to_lreal*/

   350

    break;

   351

   352

/****

   353

 *BOOL_TO_TIME

   354

 */

   355

    case function_bool_to_time :

   356

    {

   357

        symbol_c *last_type_symbol = NULL;

   358

   359

        {

   360

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

   361

            symbol_c *IN_param_value = &this->default_variable_name;

   362

   363

            symbol_c *IN_type_symbol = param_data_type;

   364

            last_type_symbol = param_data_type;

   365

   366

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   367

            {

   368

   369

                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   370

                s4o.print("(");

   371

                return_type_symbol->accept(*this);

   372

                s4o.print(")__int_to_time(");

   373

                IN_param_value->accept(*this);

   374

                s4o.print(")");

   375

                return NULL;

   376

   377

            }

   378

   379

            ERROR;

   380

        }

   381

   382

    }/*function_bool_to_time*/

   383

    break;

   384

   385

/****

   386

 *BOOL_TO_DATE

   387

 */

   388

    case function_bool_to_date :

   389

    {

   390

        symbol_c *last_type_symbol = NULL;

   391

   392

        {

   393

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

   394

            symbol_c *IN_param_value = &this->default_variable_name;

   395

   396

            symbol_c *IN_type_symbol = param_data_type;

   397

            last_type_symbol = param_data_type;

   398

   399

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   400

            {

   401

   402

                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   403

                s4o.print("(");

   404

                return_type_symbol->accept(*this);

   405

                s4o.print(")__int_to_time(");

   406

                IN_param_value->accept(*this);

   407

                s4o.print(")");

   408

                return NULL;

   409

   410

            }

   411

   412

            ERROR;

   413

        }

   414

   415

    }/*function_bool_to_date*/

   416

    break;

   417

   418

/****

   419

 *BOOL_TO_TOD

   420

 */

   421

    case function_bool_to_tod :

   422

    {

   423

        symbol_c *last_type_symbol = NULL;

   424

   425

        {

   426

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

   427

            symbol_c *IN_param_value = &this->default_variable_name;

   428

   429

            symbol_c *IN_type_symbol = param_data_type;

   430

            last_type_symbol = param_data_type;

   431

   432

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   433

            {

   434

   435

                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   436

                s4o.print("(");

   437

                return_type_symbol->accept(*this);

   438

                s4o.print(")__int_to_time(");

   439

                IN_param_value->accept(*this);

   440

                s4o.print(")");

   441

                return NULL;

   442

   443

            }

   444

   445

            ERROR;

   446

        }

   447

   448

    }/*function_bool_to_tod*/

   449

    break;

   450

   451

/****

   452

 *BOOL_TO_DT

   453

 */

   454

    case function_bool_to_dt :

   455

    {

   456

        symbol_c *last_type_symbol = NULL;

   457

   458

        {

   459

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

   460

            symbol_c *IN_param_value = &this->default_variable_name;

   461

   462

            symbol_c *IN_type_symbol = param_data_type;

   463

            last_type_symbol = param_data_type;

   464

   465

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   466

            {

   467

   468

                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   469

                s4o.print("(");

   470

                return_type_symbol->accept(*this);

   471

                s4o.print(")__int_to_time(");

   472

                IN_param_value->accept(*this);

   473

                s4o.print(")");

   474

                return NULL;

   475

   476

            }

   477

   478

            ERROR;

   479

        }

   480

   481

    }/*function_bool_to_dt*/

   482

    break;

   483

   484

/****

   485

 *BOOL_TO_STRING

   486

 */

   487

    case function_bool_to_string :

   488

    {

   489

        symbol_c *last_type_symbol = NULL;

   490

   491

        {

   492

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

   493

            symbol_c *IN_param_value = &this->default_variable_name;

   494

   495

            symbol_c *IN_type_symbol = param_data_type;

   496

            last_type_symbol = param_data_type;

   497

   498

            if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol))

   499

            {

   500

   501

                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   502

                s4o.print("(");

   503

                return_type_symbol->accept(*this);

   504

                s4o.print(")__bool_to_string(");

   505

                IN_param_value->accept(*this);

   506

                s4o.print(")");

   507

                return NULL;

   508

   509

            }

   510

   511

            ERROR;

   512

        }

   513

   514

    }/*function_bool_to_string*/

   515

    break;

   516

   517

/****

   518

 *BOOL_TO_BYTE

   519

 */

   520

    case function_bool_to_byte :

   521

    {

   522

        symbol_c *last_type_symbol = NULL;

   523

   524

        {

   525

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

   526

            symbol_c *IN_param_value = &this->default_variable_name;

   527

   528

            symbol_c *IN_type_symbol = param_data_type;

   529

            last_type_symbol = param_data_type;

   530