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

            identifier_c param_name("IN");

    42

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

    43

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

    44

            symbol_c *IN_type_symbol = NULL;

    45

    46

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

    47

            if (IN_param_value == NULL)

    48

              IN_param_value = function_call_param_iterator.next();

    49

            if (IN_param_value != NULL) {

    50

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

    51

              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

    52

            }

    53

    54

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

    55

            {

    56

    58

    59

                if (IN_type_symbol == NULL)

    60

                  IN_type_symbol = last_type_symbol;

    61

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

    62

                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    63

                function_type_prefix = return_type_symbol;

    65

                break;

    66

    67

            }

    68

    69

    70

            ERROR;

    71

        }

    72

    73

    }/*function_real_to_sint*/

    74

    break;

    75

    76

/****

    77

 *REAL_TO_LINT

    78

 */

    79

    case function_real_to_lint :

    80

    {

    81

        symbol_c *last_type_symbol = NULL;

    82

    83

        {

    84

            identifier_c param_name("IN");

    85

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

    86

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

    87

            symbol_c *IN_type_symbol = NULL;

    88

    89

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

    90

            if (IN_param_value == NULL)

    91

              IN_param_value = function_call_param_iterator.next();

    92

            if (IN_param_value != NULL) {

    93

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

    94

              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

    95

            }

    96

    97

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

    98

            {

    99

   101

   102

                if (IN_type_symbol == NULL)

   103

                  IN_type_symbol = last_type_symbol;

   104

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   105

                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   106

                function_type_prefix = return_type_symbol;

   108

                break;

   109

   110

            }

   111

   112

   113

            ERROR;

   114

        }

   115

   116

    }/*function_real_to_lint*/

   117

    break;

   118

   119

/****

   120

 *REAL_TO_DINT

   121

 */

   122

    case function_real_to_dint :

   123

    {

   124

        symbol_c *last_type_symbol = NULL;

   125

   126

        {

   127

            identifier_c param_name("IN");

   128

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

   129

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   130

            symbol_c *IN_type_symbol = NULL;

   131

   132

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

   133

            if (IN_param_value == NULL)

   134

              IN_param_value = function_call_param_iterator.next();

   135

            if (IN_param_value != NULL) {

   136

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   137

              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   138

            }

   139

   140

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

   141

            {

   142

   144

   145

                if (IN_type_symbol == NULL)

   146

                  IN_type_symbol = last_type_symbol;

   147

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   148

                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   149

                function_type_prefix = return_type_symbol;

   151

                break;

   152

   153

            }

   154

   155

   156

            ERROR;

   157

        }

   158

   159

    }/*function_real_to_dint*/

   160

    break;

   161

   162

/****

   163

 *REAL_TO_DATE

   164

 */

   165

    case function_real_to_date :

   166

    {

   167

        symbol_c *last_type_symbol = NULL;

   168

   169

        {

   170

            identifier_c param_name("IN");

   171

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

   172

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   173

            symbol_c *IN_type_symbol = NULL;

   174

   175

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

   176

            if (IN_param_value == NULL)

   177

              IN_param_value = function_call_param_iterator.next();

   178

            if (IN_param_value != NULL) {

   179

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   180

              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   181

            }

   182

   183

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

   184

            {

   185

   186

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

   187

   188

                if (IN_type_symbol == NULL)

   189

                  IN_type_symbol = last_type_symbol;

   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::date_type_name;

   192

                function_type_prefix = return_type_symbol;

   193

                break;

   194

   195

            }

   196

   197

   198

            ERROR;

   199

        }

   200

   201

    }/*function_real_to_date*/

   202

    break;

   203

   204

/****

   205

 *REAL_TO_DWORD

   206

 */

   207

    case function_real_to_dword :

   208

    {

   209

        symbol_c *last_type_symbol = NULL;

   210

   211

        {

   212

            identifier_c param_name("IN");

   213

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

   214

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   215

            symbol_c *IN_type_symbol = NULL;

   216

   217

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

   218

            if (IN_param_value == NULL)

   219

              IN_param_value = function_call_param_iterator.next();

   220

            if (IN_param_value != NULL) {

   221

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   222

              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   223

            }

   224

   225

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

   226

            {

   227

   229

   230

                if (IN_type_symbol == NULL)

   231

                  IN_type_symbol = last_type_symbol;

   232

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   233

                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   234

                function_type_prefix = return_type_symbol;

   236

                break;

   237

   238

            }

   239

   240

   241

            ERROR;

   242

        }

   243

   244

    }/*function_real_to_dword*/

   245

    break;

   246

   247

/****

   248

 *REAL_TO_DT

   249

 */

   250

    case function_real_to_dt :

   251

    {

   252

        symbol_c *last_type_symbol = NULL;

   253

   254

        {

   255

            identifier_c param_name("IN");

   256

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

   257

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   258

            symbol_c *IN_type_symbol = NULL;

   259

   260

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

   261

            if (IN_param_value == NULL)

   262

              IN_param_value = function_call_param_iterator.next();

   263

            if (IN_param_value != NULL) {

   264

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   265

              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   266

            }

   267

   268

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

   269

            {

   270

   271

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

   272

   273

                if (IN_type_symbol == NULL)

   274

                  IN_type_symbol = last_type_symbol;

   275

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   276

                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   277

                function_type_prefix = return_type_symbol;

   278

                break;

   279

   280

            }

   281

   282

   283

            ERROR;

   284

        }

   285

   286

    }/*function_real_to_dt*/

   287

    break;

   288

   289

/****

   290

 *REAL_TO_TOD

   291

 */

   292

    case function_real_to_tod :

   293

    {

   294

        symbol_c *last_type_symbol = NULL;

   295

   296

        {

   297

            identifier_c param_name("IN");

   298

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

   299

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   300

            symbol_c *IN_type_symbol = NULL;

   301

   302

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

   303

            if (IN_param_value == NULL)

   304

              IN_param_value = function_call_param_iterator.next();

   305

            if (IN_param_value != NULL) {

   306

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   307

              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   308

            }

   309

   310

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

   311

            {

   312

   313

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

   314

   315

                if (IN_type_symbol == NULL)

   316

                  IN_type_symbol = last_type_symbol;

   317

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   318

                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   319

                function_type_prefix = return_type_symbol;

   320

                break;

   321

   322

            }

   323

   324

   325

            ERROR;

   326

        }

   327

   328

    }/*function_real_to_tod*/

   329

    break;

   330

   331

/****

   332

 *REAL_TO_UDINT

   333

 */

   334

    case function_real_to_udint :

   335

    {

   336

        symbol_c *last_type_symbol = NULL;

   337

   338

        {

   339

            identifier_c param_name("IN");

   340

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

   341

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   342

            symbol_c *IN_type_symbol = NULL;

   343

   344

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

   345

            if (IN_param_value == NULL)

   346

              IN_param_value = function_call_param_iterator.next();

   347

            if (IN_param_value != NULL) {

   348

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   349

              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   350

            }

   351

   352

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

   353

            {

   354

   356

   357

                if (IN_type_symbol == NULL)

   358

                  IN_type_symbol = last_type_symbol;

   359

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   360

                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   361

                function_type_prefix = return_type_symbol;

   363

                break;

   364

   365

            }

   366

   367

   368

            ERROR;

   369

        }

   370

   371

    }/*function_real_to_udint*/

   372

    break;

   373

   374

/****

   375

 *REAL_TO_WORD

   376

 */

   377

    case function_real_to_word :

   378

    {

   379

        symbol_c *last_type_symbol = NULL;

   380

   381

        {

   382

            identifier_c param_name("IN");

   383

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

   384

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   385

            symbol_c *IN_type_symbol = NULL;

   386

   387

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

   388

            if (IN_param_value == NULL)

   389

              IN_param_value = function_call_param_iterator.next();

   390

            if (IN_param_value != NULL) {

   391

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   392

              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   393

            }

   394

   395

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

   396

            {

   397

   399

   400

                if (IN_type_symbol == NULL)

   401

                  IN_type_symbol = last_type_symbol;

   402

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   403

                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   404

                function_type_prefix = return_type_symbol;

   406

                break;

   407

   408

            }

   409

   410

   411

            ERROR;

   412

        }

   413

   414

    }/*function_real_to_word*/

   415

    break;

   416

   417

/****

   418

 *REAL_TO_STRING

   419

 */

   420

    case function_real_to_string :

   421

    {

   422

        symbol_c *last_type_symbol = NULL;

   423

   424

        {

   425

            identifier_c param_name("IN");

   426

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

   427

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   428

            symbol_c *IN_type_symbol = NULL;

   429

   430

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

   431

            if (IN_param_value == NULL)

   432

              IN_param_value = function_call_param_iterator.next();

   433

            if (IN_param_value != NULL) {

   434

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   435

              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   436

            }

   437

   438

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

   439

            {

   440

   441

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

   442

   443

                if (IN_type_symbol == NULL)

   444

                  IN_type_symbol = last_type_symbol;

   445

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   446

                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   447

                function_type_prefix = return_type_symbol;

   448

                break;

   449

   450

            }

   451

   452

   453

            ERROR;

   454

        }

   455

   456

    }/*function_real_to_string*/

   457

    break;

   458

   459

/****

   460

 *REAL_TO_LWORD

   461

 */

   462

    case function_real_to_lword :

   463

    {

   464

        symbol_c *last_type_symbol = NULL;

   465

   466

        {

   467

            identifier_c param_name("IN");

   468

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

   469

            symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);

   470

            symbol_c *IN_type_symbol = NULL;

   471

   472

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

   473

            if (IN_param_value == NULL)

   474

              IN_param_value = function_call_param_iterator.next();

   475

            if (IN_param_value != NULL) {

   476

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   477

              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;

   478

            }

   479

   480

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

   481

            {

   482

   484

   485

                if (IN_type_symbol == NULL)

   486

                  IN_type_symbol = last_type_symbol;

   487

                ADD_PARAM_LIST(IN_param_value, IN_type_symbol, function_param_iterator_c::direction_in)

   488

                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   489

                function_type_prefix = return_type_symbol;

   491

                break;

   492

   493

            }

   494