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

    32

void *compute_standard_function_default(function_invocation_c *st_symbol = NULL, il_formal_funct_call_c *il_symbol = NULL) {

    33

  function_type_t current_function_type;

    34

  function_call_param_iterator_c *tmp_function_call_param_iterator;

    35

  if (st_symbol != NULL && il_symbol == NULL) {

    36

    current_function_type = get_function_type((identifier_c *)st_symbol->function_name);

    37

    tmp_function_call_param_iterator = new function_call_param_iterator_c(st_symbol);

    38

  }

    39

  else if (st_symbol == NULL && il_symbol != NULL) {

    40

    current_function_type = get_function_type((identifier_c *)il_symbol->function_name);

    41

    tmp_function_call_param_iterator = new function_call_param_iterator_c(il_symbol);

    42

  }

    43

  else

    44

    ERROR;

    45

  function_call_param_iterator_c function_call_param_iterator(*tmp_function_call_param_iterator);

    46

  search_expression_type_c* search_expression_type = this;

    47

    48

  switch(current_function_type){

    49

    50

/****

    51

 *REAL_TO_SINT

    52

 */

    53

    case function_real_to_sint :

    54

    {

    55

        symbol_c *last_type_symbol = NULL;

    56

    57

        {

    58

            identifier_c param_name("IN");

    59

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

    60

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

    61

    62

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

    63

            if (IN_param_value == NULL)

    64

              IN_param_value = function_call_param_iterator.next();

    65

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

    66

            last_type_symbol = last_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 ;

    67

    68

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

    69

            {

    70

    71

                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    72

                return return_type_symbol;

    73

    74

            }

    75

    76

    77

            ERROR;

    78

        }

    79

    80

    }/*function_real_to_sint*/

    81

    break;

    82

    83

/****

    84

 *REAL_TO_LINT

    85

 */

    86

    case function_real_to_lint :

    87

    {

    88

        symbol_c *last_type_symbol = NULL;

    89

    90

        {

    91

            identifier_c param_name("IN");

    92

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

    93

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

    94

    95

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

    96

            if (IN_param_value == NULL)

    97

              IN_param_value = function_call_param_iterator.next();

    98

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

    99

            last_type_symbol = last_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 ;

   100

   101

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

   102

            {

   103

   104

                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   105

                return return_type_symbol;

   106

   107

            }

   108

   109

   110

            ERROR;

   111

        }

   112

   113

    }/*function_real_to_lint*/

   114

    break;

   115

   116

/****

   117

 *REAL_TO_DINT

   118

 */

   119

    case function_real_to_dint :

   120

    {

   121

        symbol_c *last_type_symbol = NULL;

   122

   123

        {

   124

            identifier_c param_name("IN");

   125

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

   126

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

   127

   128

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

   129

            if (IN_param_value == NULL)

   130

              IN_param_value = function_call_param_iterator.next();

   131

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   132

            last_type_symbol = last_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 ;

   133

   134

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

   135

            {

   136

   137

                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   138

                return return_type_symbol;

   139

   140

            }

   141

   142

   143

            ERROR;

   144

        }

   145

   146

    }/*function_real_to_dint*/

   147

    break;

   148

   149

/****

   150

 *REAL_TO_DATE

   151

 */

   152

    case function_real_to_date :

   153

    {

   154

        symbol_c *last_type_symbol = NULL;

   155

   156

        {

   157

            identifier_c param_name("IN");

   158

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

   159

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

   160

   161

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

   162

            if (IN_param_value == NULL)

   163

              IN_param_value = function_call_param_iterator.next();

   164

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   165

            last_type_symbol = last_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 ;

   166

   167

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

   168

            {

   169

   170

                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   171

                return return_type_symbol;

   172

   173

            }

   174

   175

   176

            ERROR;

   177

        }

   178

   179

    }/*function_real_to_date*/

   180

    break;

   181

   182

/****

   183

 *REAL_TO_DWORD

   184

 */

   185

    case function_real_to_dword :

   186

    {

   187

        symbol_c *last_type_symbol = NULL;

   188

   189

        {

   190

            identifier_c param_name("IN");

   191

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

   192

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

   193

   194

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

   195

            if (IN_param_value == NULL)

   196

              IN_param_value = function_call_param_iterator.next();

   197

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   198

            last_type_symbol = last_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 ;

   199

   200

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

   201

            {

   202

   203

                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   204

                return return_type_symbol;

   205

   206

            }

   207

   208

   209

            ERROR;

   210

        }

   211

   212

    }/*function_real_to_dword*/

   213

    break;

   214

   215

/****

   216

 *REAL_TO_DT

   217

 */

   218

    case function_real_to_dt :

   219

    {

   220

        symbol_c *last_type_symbol = NULL;

   221

   222

        {

   223

            identifier_c param_name("IN");

   224

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

   225

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

   226

   227

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

   228

            if (IN_param_value == NULL)

   229

              IN_param_value = function_call_param_iterator.next();

   230

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   231

            last_type_symbol = last_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 ;

   232

   233

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

   234

            {

   235

   236

                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   237

                return return_type_symbol;

   238

   239

            }

   240

   241

   242

            ERROR;

   243

        }

   244

   245

    }/*function_real_to_dt*/

   246

    break;

   247

   248

/****

   249

 *REAL_TO_TOD

   250

 */

   251

    case function_real_to_tod :

   252

    {

   253

        symbol_c *last_type_symbol = NULL;

   254

   255

        {

   256

            identifier_c param_name("IN");

   257

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

   258

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

   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

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   264

            last_type_symbol = last_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 ;

   265

   266

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

   267

            {

   268

   269

                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   270

                return return_type_symbol;

   271

   272

            }

   273

   274

   275

            ERROR;

   276

        }

   277

   278

    }/*function_real_to_tod*/

   279

    break;

   280

   281

/****

   282

 *REAL_TO_UDINT

   283

 */

   284

    case function_real_to_udint :

   285

    {

   286

        symbol_c *last_type_symbol = NULL;

   287

   288

        {

   289

            identifier_c param_name("IN");

   290

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

   291

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

   292

   293

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

   294

            if (IN_param_value == NULL)

   295

              IN_param_value = function_call_param_iterator.next();

   296

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   297

            last_type_symbol = last_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 ;

   298

   299

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

   300

            {

   301

   302

                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   303

                return return_type_symbol;

   304

   305

            }

   306

   307

   308

            ERROR;

   309

        }

   310

   311

    }/*function_real_to_udint*/

   312

    break;

   313

   314

/****

   315

 *REAL_TO_WORD

   316

 */

   317

    case function_real_to_word :

   318

    {

   319

        symbol_c *last_type_symbol = NULL;

   320

   321

        {

   322

            identifier_c param_name("IN");

   323

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

   324

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

   325

   326

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

   327

            if (IN_param_value == NULL)

   328

              IN_param_value = function_call_param_iterator.next();

   329

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   330

            last_type_symbol = last_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 ;

   331

   332

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

   333

            {

   334

   335

                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   336

                return return_type_symbol;

   337

   338

            }

   339

   340

   341

            ERROR;

   342

        }

   343

   344

    }/*function_real_to_word*/

   345

    break;

   346

   347

/****

   348

 *REAL_TO_STRING

   349

 */

   350

    case function_real_to_string :

   351

    {

   352

        symbol_c *last_type_symbol = NULL;

   353

   354

        {

   355

            identifier_c param_name("IN");

   356

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

   357

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

   358

   359

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

   360

            if (IN_param_value == NULL)

   361

              IN_param_value = function_call_param_iterator.next();

   362

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   363

            last_type_symbol = last_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 ;

   364

   365

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

   366

            {

   367

   368

                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   369

                return return_type_symbol;

   370

   371

            }

   372

   373

   374

            ERROR;

   375

        }

   376

   377

    }/*function_real_to_string*/

   378

    break;

   379

   380

/****

   381

 *REAL_TO_LWORD

   382

 */

   383

    case function_real_to_lword :

   384

    {

   385

        symbol_c *last_type_symbol = NULL;

   386

   387

        {

   388

            identifier_c param_name("IN");

   389

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

   390

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

   391

   392

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

   393

            if (IN_param_value == NULL)

   394

              IN_param_value = function_call_param_iterator.next();

   395

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   396

            last_type_symbol = last_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 ;

   397

   398

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

   399

            {

   400

   401

                symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   402

                return return_type_symbol;

   403

   404

            }

   405

   406

   407

            ERROR;

   408

        }

   409

   410

    }/*function_real_to_lword*/

   411

    break;

   412

   413

/****

   414

 *REAL_TO_UINT

   415

 */

   416

    case function_real_to_uint :

   417

    {

   418

        symbol_c *last_type_symbol = NULL;

   419

   420

        {

   421

            identifier_c param_name("IN");

   422

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

   423

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

   424

   425

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

   426

            if (IN_param_value == NULL)

   427

              IN_param_value = function_call_param_iterator.next();

   428

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   429

            last_type_symbol = last_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 ;

   430

   431

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

   432

            {

   433

   434

                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   435

                return return_type_symbol;

   436

   437

            }

   438

   439

   440

            ERROR;

   441

        }

   442

   443

    }/*function_real_to_uint*/

   444

    break;

   445

   446

/****

   447

 *REAL_TO_LREAL

   448

 */

   449

    case function_real_to_lreal :

   450

    {

   451

        symbol_c *last_type_symbol = NULL;

   452

   453

        {

   454

            identifier_c param_name("IN");

   455

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

   456

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

   457

   458

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

   459

            if (IN_param_value == NULL)

   460

              IN_param_value = function_call_param_iterator.next();

   461

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   462

            last_type_symbol = last_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 ;

   463

   464

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

   465

            {

   466

   467

                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   468

                return return_type_symbol;

   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

            identifier_c param_name("IN");

   488

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

   489

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

   490

   491

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

   492

            if (IN_param_value == NULL)

   493

              IN_param_value = function_call_param_iterator.next();

   494

            symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);

   495

            last_type_symbol = last_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 ;

   496

   497

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

   498

            {