1

/*

     2

 * (c) 2008 Edouard TISSERANT

     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

 * IEC 61131-3 standard function library

    27

 * generated code, do not edit by hand

    28

 */

    29

    30

    31

switch(current_function_type){

    32

    33

/****

    34

 *REAL_TO_SINT

    35

 */

    36

    case function_real_to_sint :

    37

    {

    38

        symbol_c *last_type_symbol = NULL;

    39

    40

        {

    41

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

    42

            symbol_c *IN_param_value = &this->default_variable_name;

    43

    44

            symbol_c *IN_type_symbol = param_data_type;

    45

            last_type_symbol = param_data_type;

    46

    53

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

    54

                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    55

                function_type_prefix = return_type_symbol;

    56

                break;

    57

    58

            }

    59

    60

    61

            ERROR;

    62

        }

    63

    64

    }/*function_real_to_sint*/

    65

    break;

    66

    67

/****

    68

 *REAL_TO_LINT

    69

 */

    70

    case function_real_to_lint :

    71

    {

    72

        symbol_c *last_type_symbol = NULL;

    73

    74

        {

    75

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

    76

            symbol_c *IN_param_value = &this->default_variable_name;

    77

    78

            symbol_c *IN_type_symbol = param_data_type;

    79

            last_type_symbol = param_data_type;

    80

    87

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

    88

                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

    89

                function_type_prefix = return_type_symbol;

    90

                break;

    91

    92

            }

    93

    94

    95

            ERROR;

    96

        }

    97

    98

    }/*function_real_to_lint*/

    99

    break;

   100

   101

/****

   102

 *REAL_TO_DINT

   103

 */

   104

    case function_real_to_dint :

   105

    {

   106

        symbol_c *last_type_symbol = NULL;

   107

   108

        {

   109

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

   110

            symbol_c *IN_param_value = &this->default_variable_name;

   111

   112

            symbol_c *IN_type_symbol = param_data_type;

   113

            last_type_symbol = param_data_type;

   114

   121

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   122

                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   123

                function_type_prefix = return_type_symbol;

   124

                break;

   125

   126

            }

   127

   128

   129

            ERROR;

   130

        }

   131

   132

    }/*function_real_to_dint*/

   133

    break;

   134

   135

/****

   136

 *REAL_TO_DATE

   137

 */

   138

    case function_real_to_date :

   139

    {

   140

        symbol_c *last_type_symbol = NULL;

   141

   142

        {

   143

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

   144

            symbol_c *IN_param_value = &this->default_variable_name;

   145

   146

            symbol_c *IN_type_symbol = param_data_type;

   147

            last_type_symbol = param_data_type;

   148

   150

            {

   151

   152

                function_name = (symbol_c*)(new pragma_c("__real_to_time"));

   156

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   157

                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   158

                function_type_prefix = return_type_symbol;

   159

                break;

   160

   161

            }

   162

   163

   164

            ERROR;

   165

        }

   166

   167

    }/*function_real_to_date*/

   168

    break;

   169

   170

/****

   171

 *REAL_TO_DWORD

   172

 */

   173

    case function_real_to_dword :

   174

    {

   175

        symbol_c *last_type_symbol = NULL;

   176

   177

        {

   178

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

   179

            symbol_c *IN_param_value = &this->default_variable_name;

   180

   181

            symbol_c *IN_type_symbol = param_data_type;

   182

            last_type_symbol = param_data_type;

   183

   190

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   191

                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   192

                function_type_prefix = return_type_symbol;

   193

                break;

   194

   195

            }

   196

   197

   198

            ERROR;

   199

        }

   200

   201

    }/*function_real_to_dword*/

   202

    break;

   203

   204

/****

   205

 *REAL_TO_DT

   206

 */

   207

    case function_real_to_dt :

   208

    {

   209

        symbol_c *last_type_symbol = NULL;

   210

   211

        {

   212

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

   213

            symbol_c *IN_param_value = &this->default_variable_name;

   214

   215

            symbol_c *IN_type_symbol = param_data_type;

   216

            last_type_symbol = param_data_type;

   217

   219

            {

   220

   221

                function_name = (symbol_c*)(new pragma_c("__real_to_time"));

   225

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   226

                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   227

                function_type_prefix = return_type_symbol;

   228

                break;

   229

   230

            }

   231

   232

   233

            ERROR;

   234

        }

   235

   236

    }/*function_real_to_dt*/

   237

    break;

   238

   239

/****

   240

 *REAL_TO_TOD

   241

 */

   242

    case function_real_to_tod :

   243

    {

   244

        symbol_c *last_type_symbol = NULL;

   245

   246

        {

   247

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

   248

            symbol_c *IN_param_value = &this->default_variable_name;

   249

   250

            symbol_c *IN_type_symbol = param_data_type;

   251

            last_type_symbol = param_data_type;

   252

   254

            {

   255

   256

                function_name = (symbol_c*)(new pragma_c("__real_to_time"));

   260

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   261

                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   262

                function_type_prefix = return_type_symbol;

   263

                break;

   264

   265

            }

   266

   267

   268

            ERROR;

   269

        }

   270

   271

    }/*function_real_to_tod*/

   272

    break;

   273

   274

/****

   275

 *REAL_TO_UDINT

   276

 */

   277

    case function_real_to_udint :

   278

    {

   279

        symbol_c *last_type_symbol = NULL;

   280

   281

        {

   282

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

   283

            symbol_c *IN_param_value = &this->default_variable_name;

   284

   285

            symbol_c *IN_type_symbol = param_data_type;

   286

            last_type_symbol = param_data_type;

   287

   294

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   295

                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   296

                function_type_prefix = return_type_symbol;

   297

                break;

   298

   299

            }

   300

   301

   302

            ERROR;

   303

        }

   304

   305

    }/*function_real_to_udint*/

   306

    break;

   307

   308

/****

   309

 *REAL_TO_WORD

   310

 */

   311

    case function_real_to_word :

   312

    {

   313

        symbol_c *last_type_symbol = NULL;

   314

   315

        {

   316

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

   317

            symbol_c *IN_param_value = &this->default_variable_name;

   318

   319

            symbol_c *IN_type_symbol = param_data_type;

   320

            last_type_symbol = param_data_type;

   321

   328

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   329

                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   330

                function_type_prefix = return_type_symbol;

   331

                break;

   332

   333

            }

   334

   335

   336

            ERROR;

   337

        }

   338

   339

    }/*function_real_to_word*/

   340

    break;

   341

   342

/****

   343

 *REAL_TO_STRING

   344

 */

   345

    case function_real_to_string :

   346

    {

   347

        symbol_c *last_type_symbol = NULL;

   348

   349

        {

   350

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

   351

            symbol_c *IN_param_value = &this->default_variable_name;

   352

   353

            symbol_c *IN_type_symbol = param_data_type;

   354

            last_type_symbol = param_data_type;

   355

   357

            {

   358

   359

                function_name = (symbol_c*)(new pragma_c("__real_to_string"));

   363

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   364

                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   365

                function_type_prefix = return_type_symbol;

   366

                break;

   367

   368

            }

   369

   370

   371

            ERROR;

   372

        }

   373

   374

    }/*function_real_to_string*/

   375

    break;

   376

   377

/****

   378

 *REAL_TO_LWORD

   379

 */

   380

    case function_real_to_lword :

   381

    {

   382

        symbol_c *last_type_symbol = NULL;

   383

   384

        {

   385

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

   386

            symbol_c *IN_param_value = &this->default_variable_name;

   387

   388

            symbol_c *IN_type_symbol = param_data_type;

   389

            last_type_symbol = param_data_type;

   390

   397

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   398

                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   399

                function_type_prefix = return_type_symbol;

   400

                break;

   401

   402

            }

   403

   404

   405

            ERROR;

   406

        }

   407

   408

    }/*function_real_to_lword*/

   409

    break;

   410

   411

/****

   412

 *REAL_TO_UINT

   413

 */

   414

    case function_real_to_uint :

   415

    {

   416

        symbol_c *last_type_symbol = NULL;

   417

   418

        {

   419

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

   420

            symbol_c *IN_param_value = &this->default_variable_name;

   421

   422

            symbol_c *IN_type_symbol = param_data_type;

   423

            last_type_symbol = param_data_type;

   424

   431

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   432

                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   433

                function_type_prefix = return_type_symbol;

   434

                break;

   435

   436

            }

   437

   438

   439

            ERROR;

   440

        }

   441

   442

    }/*function_real_to_uint*/

   443

    break;

   444

   445

/****

   446

 *REAL_TO_LREAL

   447

 */

   448

    case function_real_to_lreal :

   449

    {

   450

        symbol_c *last_type_symbol = NULL;

   451

   452

        {

   453

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

   454

            symbol_c *IN_param_value = &this->default_variable_name;

   455

   456

            symbol_c *IN_type_symbol = param_data_type;

   457

            last_type_symbol = param_data_type;

   458

   465

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   466

                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   467

                function_type_prefix = return_type_symbol;

   468

                break;

   469

   470

            }

   471

   472

   473

            ERROR;

   474

        }

   475

   476

    }/*function_real_to_lreal*/

   477

    break;

   478

   479

/****

   480

 *REAL_TO_BYTE

   481

 */

   482

    case function_real_to_byte :

   483

    {

   484

        symbol_c *last_type_symbol = NULL;

   485

   486

        {

   487

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

   488

            symbol_c *IN_param_value = &this->default_variable_name;

   489

   490

            symbol_c *IN_type_symbol = param_data_type;

   491

            last_type_symbol = param_data_type;

   492