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

    47

            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

    48

            {

    49

    51

    52

                if (IN_type_symbol == NULL)

    53

                  IN_type_symbol = last_type_symbol;

    54

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

    55

                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    56

                function_type_prefix = return_type_symbol;

    58

                break;

    59

    60

            }

    61

    62

    63

            ERROR;

    64

        }

    65

    66

    }/*function_real_to_sint*/

    67

    break;

    68

    69

/****

    70

 *REAL_TO_LINT

    71

 */

    72

    case function_real_to_lint :

    73

    {

    74

        symbol_c *last_type_symbol = NULL;

    75

    76

        {

    77

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

    78

            symbol_c *IN_param_value = &this->default_variable_name;

    79

    80

            symbol_c *IN_type_symbol = param_data_type;

    81

            last_type_symbol = param_data_type;

    82

    83

            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

    84

            {

    85

    87

    88

                if (IN_type_symbol == NULL)

    89

                  IN_type_symbol = last_type_symbol;

    90

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

    91

                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

    92

                function_type_prefix = return_type_symbol;

    94

                break;

    95

    96

            }

    97

    98

    99

            ERROR;

   100

        }

   101

   102

    }/*function_real_to_lint*/

   103

    break;

   104

   105

/****

   106

 *REAL_TO_DINT

   107

 */

   108

    case function_real_to_dint :

   109

    {

   110

        symbol_c *last_type_symbol = NULL;

   111

   112

        {

   113

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

   114

            symbol_c *IN_param_value = &this->default_variable_name;

   115

   116

            symbol_c *IN_type_symbol = param_data_type;

   117

            last_type_symbol = param_data_type;

   118

   119

            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   120

            {

   121

   123

   124

                if (IN_type_symbol == NULL)

   125

                  IN_type_symbol = last_type_symbol;

   126

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   127

                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   128

                function_type_prefix = return_type_symbol;

   130

                break;

   131

   132

            }

   133

   134

   135

            ERROR;

   136

        }

   137

   138

    }/*function_real_to_dint*/

   139

    break;

   140

   141

/****

   142

 *REAL_TO_DATE

   143

 */

   144

    case function_real_to_date :

   145

    {

   146

        symbol_c *last_type_symbol = NULL;

   147

   148

        {

   149

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

   150

            symbol_c *IN_param_value = &this->default_variable_name;

   151

   152

            symbol_c *IN_type_symbol = param_data_type;

   153

            last_type_symbol = param_data_type;

   154

   155

            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   156

            {

   157

   158

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

   159

   160

                if (IN_type_symbol == NULL)

   161

                  IN_type_symbol = last_type_symbol;

   162

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   163

                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   164

                function_type_prefix = return_type_symbol;

   165

                break;

   166

   167

            }

   168

   169

   170

            ERROR;

   171

        }

   172

   173

    }/*function_real_to_date*/

   174

    break;

   175

   176

/****

   177

 *REAL_TO_DWORD

   178

 */

   179

    case function_real_to_dword :

   180

    {

   181

        symbol_c *last_type_symbol = NULL;

   182

   183

        {

   184

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

   185

            symbol_c *IN_param_value = &this->default_variable_name;

   186

   187

            symbol_c *IN_type_symbol = param_data_type;

   188

            last_type_symbol = param_data_type;

   189

   190

            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   191

            {

   192

   194

   195

                if (IN_type_symbol == NULL)

   196

                  IN_type_symbol = last_type_symbol;

   197

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   198

                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   199

                function_type_prefix = return_type_symbol;

   201

                break;

   202

   203

            }

   204

   205

   206

            ERROR;

   207

        }

   208

   209

    }/*function_real_to_dword*/

   210

    break;

   211

   212

/****

   213

 *REAL_TO_DT

   214

 */

   215

    case function_real_to_dt :

   216

    {

   217

        symbol_c *last_type_symbol = NULL;

   218

   219

        {

   220

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

   221

            symbol_c *IN_param_value = &this->default_variable_name;

   222

   223

            symbol_c *IN_type_symbol = param_data_type;

   224

            last_type_symbol = param_data_type;

   225

   226

            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   227

            {

   228

   229

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

   230

   231

                if (IN_type_symbol == NULL)

   232

                  IN_type_symbol = last_type_symbol;

   233

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   234

                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   235

                function_type_prefix = return_type_symbol;

   236

                break;

   237

   238

            }

   239

   240

   241

            ERROR;

   242

        }

   243

   244

    }/*function_real_to_dt*/

   245

    break;

   246

   247

/****

   248

 *REAL_TO_TOD

   249

 */

   250

    case function_real_to_tod :

   251

    {

   252

        symbol_c *last_type_symbol = NULL;

   253

   254

        {

   255

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

   256

            symbol_c *IN_param_value = &this->default_variable_name;

   257

   258

            symbol_c *IN_type_symbol = param_data_type;

   259

            last_type_symbol = param_data_type;

   260

   261

            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   262

            {

   263

   264

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

   265

   266

                if (IN_type_symbol == NULL)

   267

                  IN_type_symbol = last_type_symbol;

   268

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   269

                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   270

                function_type_prefix = return_type_symbol;

   271

                break;

   272

   273

            }

   274

   275

   276

            ERROR;

   277

        }

   278

   279

    }/*function_real_to_tod*/

   280

    break;

   281

   282

/****

   283

 *REAL_TO_UDINT

   284

 */

   285

    case function_real_to_udint :

   286

    {

   287

        symbol_c *last_type_symbol = NULL;

   288

   289

        {

   290

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

   291

            symbol_c *IN_param_value = &this->default_variable_name;

   292

   293

            symbol_c *IN_type_symbol = param_data_type;

   294

            last_type_symbol = param_data_type;

   295

   296

            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   297

            {

   298

   300

   301

                if (IN_type_symbol == NULL)

   302

                  IN_type_symbol = last_type_symbol;

   303

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   304

                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   305

                function_type_prefix = return_type_symbol;

   307

                break;

   308

   309

            }

   310

   311

   312

            ERROR;

   313

        }

   314

   315

    }/*function_real_to_udint*/

   316

    break;

   317

   318

/****

   319

 *REAL_TO_WORD

   320

 */

   321

    case function_real_to_word :

   322

    {

   323

        symbol_c *last_type_symbol = NULL;

   324

   325

        {

   326

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

   327

            symbol_c *IN_param_value = &this->default_variable_name;

   328

   329

            symbol_c *IN_type_symbol = param_data_type;

   330

            last_type_symbol = param_data_type;

   331

   332

            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   333

            {

   334

   336

   337

                if (IN_type_symbol == NULL)

   338

                  IN_type_symbol = last_type_symbol;

   339

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   340

                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   341

                function_type_prefix = return_type_symbol;

   343

                break;

   344

   345

            }

   346

   347

   348

            ERROR;

   349

        }

   350

   351

    }/*function_real_to_word*/

   352

    break;

   353

   354

/****

   355

 *REAL_TO_STRING

   356

 */

   357

    case function_real_to_string :

   358

    {

   359

        symbol_c *last_type_symbol = NULL;

   360

   361

        {

   362

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

   363

            symbol_c *IN_param_value = &this->default_variable_name;

   364

   365

            symbol_c *IN_type_symbol = param_data_type;

   366

            last_type_symbol = param_data_type;

   367

   368

            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   369

            {

   370

   371

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

   372

   373

                if (IN_type_symbol == NULL)

   374

                  IN_type_symbol = last_type_symbol;

   375

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   376

                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   377

                function_type_prefix = return_type_symbol;

   378

                break;

   379

   380

            }

   381

   382

   383

            ERROR;

   384

        }

   385

   386

    }/*function_real_to_string*/

   387

    break;

   388

   389

/****

   390

 *REAL_TO_LWORD

   391

 */

   392

    case function_real_to_lword :

   393

    {

   394

        symbol_c *last_type_symbol = NULL;

   395

   396

        {

   397

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

   398

            symbol_c *IN_param_value = &this->default_variable_name;

   399

   400

            symbol_c *IN_type_symbol = param_data_type;

   401

            last_type_symbol = param_data_type;

   402

   403

            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   404

            {

   405

   407

   408

                if (IN_type_symbol == NULL)

   409

                  IN_type_symbol = last_type_symbol;

   410

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   411

                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   412

                function_type_prefix = return_type_symbol;

   414

                break;

   415

   416

            }

   417

   418

   419

            ERROR;

   420

        }

   421

   422

    }/*function_real_to_lword*/

   423

    break;

   424

   425

/****

   426

 *REAL_TO_UINT

   427

 */

   428

    case function_real_to_uint :

   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(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   440

            {

   441

   443

   444

                if (IN_type_symbol == NULL)

   445

                  IN_type_symbol = last_type_symbol;

   446

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   447

                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   448

                function_type_prefix = return_type_symbol;

   450

                break;

   451

   452

            }

   453

   454

   455

            ERROR;

   456

        }

   457

   458

    }/*function_real_to_uint*/

   459

    break;

   460

   461

/****

   462

 *REAL_TO_LREAL

   463

 */

   464

    case function_real_to_lreal :

   465

    {

   466

        symbol_c *last_type_symbol = NULL;

   467

   468

        {

   469

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

   470

            symbol_c *IN_param_value = &this->default_variable_name;

   471

   472

            symbol_c *IN_type_symbol = param_data_type;

   473

            last_type_symbol = param_data_type;

   474

   475

            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))

   476

            {

   477

   479

   480

                if (IN_type_symbol == NULL)

   481

                  IN_type_symbol = last_type_symbol;

   482

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   483

                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   484

                function_type_prefix = return_type_symbol;

   486

                break;

   487

   488

            }

   489

   490

   491

            ERROR;

   492

        }

   493