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

 *REAL_TO_LREAL

    10

 */

    11

    case function_real_to_lreal :

    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(real_type_name_c))

    23

            {

    24

    25

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

    38

    break;

    39

    40

/****

    41

 *REAL_TO_SINT

    42

 */

    43

    case function_real_to_sint :

    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(real_type_name_c))

    55

            {

    56

    57

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

    70

    break;

    71

    72

/****

    73

 *REAL_TO_INT

    74

 */

    75

    case function_real_to_int :

    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(real_type_name_c))

    87

            {

    88

    89

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

   102

    break;

   103

   104

/****

   105

 *REAL_TO_DINT

   106

 */

   107

    case function_real_to_dint :

   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(real_type_name_c))

   119

            {

   120

   121

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

   134

    break;

   135

   136

/****

   137

 *REAL_TO_LINT

   138

 */

   139

    case function_real_to_lint :

   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(real_type_name_c))

   151

            {

   152

   153

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

   166

    break;

   167

   168

/****

   169

 *REAL_TO_USINT

   170

 */

   171

    case function_real_to_usint :

   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(real_type_name_c))

   183

            {

   184

   185

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

   198

    break;

   199

   200

/****

   201

 *REAL_TO_UINT

   202

 */

   203

    case function_real_to_uint :

   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(real_type_name_c))

   215

            {

   216

   217

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

   230

    break;

   231

   232

/****

   233

 *REAL_TO_UDINT

   234

 */

   235

    case function_real_to_udint :

   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(real_type_name_c))

   247

            {

   248

   249

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

   262

    break;

   263

   264

/****

   265

 *REAL_TO_ULINT

   266

 */

   267

    case function_real_to_ulint :

   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(real_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_real_to_ulint*/

   294

    break;

   295

   296

/****

   297

 *REAL_TO_TIME

   298

 */

   299

    case function_real_to_time :

   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(real_type_name_c))

   311

            {

   312

   313

                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   314

                s4o.print("(");

   315

                return_type_symbol->accept(*this);

   317

                IN_param_value->accept(*this);

   318

                s4o.print(")");

   319

                return NULL;

   320

   321

            }

   322

   323

            ERROR;

   324

        }

   325

   326

    }/*function_real_to_time*/

   327

    break;

   328

   329

/****

   330

 *REAL_TO_BOOL

   331

 */

   332

    case function_real_to_bool :

   333

    {

   334

        symbol_c *last_type_symbol = NULL;

   335

   336

        {

   337

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

   338

            symbol_c *IN_param_value = &this->default_variable_name;

   339

   340

            symbol_c *IN_type_symbol = param_data_type;

   341

            last_type_symbol = param_data_type;

   342

   343

            if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   344

            {

   345

   346

                symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;

   347

                s4o.print("(");

   348

                return_type_symbol->accept(*this);

   349

                s4o.print(")");

   350

                IN_param_value->accept(*this);

   351

                return NULL;

   352

   353

            }

   354

   355

            ERROR;

   356

        }

   357

   358

    }/*function_real_to_bool*/

   359

    break;

   360

   361

/****

   362

 *REAL_TO_BYTE

   363

 */

   364

    case function_real_to_byte :

   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(real_type_name_c))

   376

            {

   377

   378

                symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;

   379

                s4o.print("(");

   380

                return_type_symbol->accept(*this);

   381

                s4o.print(")");

   382

                IN_param_value->accept(*this);

   383

                return NULL;

   384

   385

            }

   386

   387

            ERROR;

   388

        }

   389

   390

    }/*function_real_to_byte*/

   391

    break;

   392

   393

/****

   394

 *REAL_TO_WORD

   395

 */

   396

    case function_real_to_word :

   397

    {

   398

        symbol_c *last_type_symbol = NULL;

   399

   400

        {

   401

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

   402

            symbol_c *IN_param_value = &this->default_variable_name;

   403

   404

            symbol_c *IN_type_symbol = param_data_type;

   405

            last_type_symbol = param_data_type;

   406

   407

            if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   408

            {

   409

   410

                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   411

                s4o.print("(");

   412

                return_type_symbol->accept(*this);

   413

                s4o.print(")");

   414

                IN_param_value->accept(*this);

   415

                return NULL;

   416

   417

            }

   418

   419

            ERROR;

   420

        }

   421

   422

    }/*function_real_to_word*/

   423

    break;

   424

   425

/****

   426

 *REAL_TO_DWORD

   427

 */

   428

    case function_real_to_dword :

   429

    {

   430

        symbol_c *last_type_symbol = NULL;

   431

   432

        {

   433

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

   434

            symbol_c *IN_param_value = &this->default_variable_name;

   435

   436

            symbol_c *IN_type_symbol = param_data_type;

   437

            last_type_symbol = param_data_type;

   438

   439

            if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   440

            {

   441

   442

                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   443

                s4o.print("(");

   444

                return_type_symbol->accept(*this);

   445

                s4o.print(")");

   446

                IN_param_value->accept(*this);

   447

                return NULL;

   448

   449

            }

   450

   451

            ERROR;

   452

        }

   453

   454

    }/*function_real_to_dword*/

   455

    break;

   456

   457

/****

   458

 *REAL_TO_LWORD

   459

 */

   460

    case function_real_to_lword :

   461

    {

   462

        symbol_c *last_type_symbol = NULL;

   463

   464

        {

   465

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

   466

            symbol_c *IN_param_value = &this->default_variable_name;

   467

   468

            symbol_c *IN_type_symbol = param_data_type;

   469

            last_type_symbol = param_data_type;

   470

   471

            if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   472

            {

   473

   474

                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   475

                s4o.print("(");

   476

                return_type_symbol->accept(*this);

   477

                s4o.print(")");

   478

                IN_param_value->accept(*this);

   479

                return NULL;

   480

   481

            }

   482

   483

            ERROR;

   484

        }

   485

   486

    }/*function_real_to_lword*/

   487

    break;

   488

   489

/****

   490

 *REAL_TO_STRING

   491

 */

   492

    case function_real_to_string :

   493

    {

   494

        symbol_c *last_type_symbol = NULL;

   495

   496

        {

   497

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

   498

            symbol_c *IN_param_value = &this->default_variable_name;

   499

   500

            symbol_c *IN_type_symbol = param_data_type;

   501

            last_type_symbol = param_data_type;

   502

   503

            if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   504

            {

   505

   506

                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   507

                s4o.print("(");

   508

                return_type_symbol->accept(*this);

   512

                return NULL;

   513

   514

            }

   515

   516

            ERROR;

   517

        }

   518

   519

    }/*function_real_to_string*/

   520

    break;

   521

   522

/****

   526

    {

   527

        symbol_c *last_type_symbol = NULL;

   528

   529