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 *search_expression_type_c::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_f(&param_name);

    61

            symbol_c *IN_type_symbol = NULL;

    62

    63

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

    64

            if (IN_param_value == NULL)

    65

              IN_param_value = function_call_param_iterator.next_nf();

    66

            if (IN_param_value != NULL) {

    67

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

    68

              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 ;

    69

            }

    70

    71

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

    72

            {

    73

    74

                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    75

                return return_type_symbol;

    76

    77

            }

    78

    79

    80

            ERROR;

    81

        }

    82

    83

    }/*function_real_to_sint*/

    84

    break;

    85

    86

/****

    87

 *REAL_TO_LINT

    88

 */

    89

    case function_real_to_lint :

    90

    {

    91

        symbol_c *last_type_symbol = NULL;

    92

    93

        {

    94

            identifier_c param_name("IN");

    95

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

    96

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

    97

            symbol_c *IN_type_symbol = NULL;

    98

    99

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

   100

            if (IN_param_value == NULL)

   101

              IN_param_value = function_call_param_iterator.next_nf();

   102

            if (IN_param_value != NULL) {

   103

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   104

              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 ;

   105

            }

   106

   107

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

   108

            {

   109

   110

                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   111

                return return_type_symbol;

   112

   113

            }

   114

   115

   116

            ERROR;

   117

        }

   118

   119

    }/*function_real_to_lint*/

   120

    break;

   121

   122

/****

   123

 *REAL_TO_DINT

   124

 */

   125

    case function_real_to_dint :

   126

    {

   127

        symbol_c *last_type_symbol = NULL;

   128

   129

        {

   130

            identifier_c param_name("IN");

   131

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

   132

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

   133

            symbol_c *IN_type_symbol = NULL;

   134

   135

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

   136

            if (IN_param_value == NULL)

   137

              IN_param_value = function_call_param_iterator.next_nf();

   138

            if (IN_param_value != NULL) {

   139

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   140

              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 ;

   141

            }

   142

   143

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

   144

            {

   145

   146

                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   147

                return return_type_symbol;

   148

   149

            }

   150

   151

   152

            ERROR;

   153

        }

   154

   155

    }/*function_real_to_dint*/

   156

    break;

   157

   158

/****

   159

 *REAL_TO_DATE

   160

 */

   161

    case function_real_to_date :

   162

    {

   163

        symbol_c *last_type_symbol = NULL;

   164

   165

        {

   166

            identifier_c param_name("IN");

   167

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

   168

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

   169

            symbol_c *IN_type_symbol = NULL;

   170

   171

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

   172

            if (IN_param_value == NULL)

   173

              IN_param_value = function_call_param_iterator.next_nf();

   174

            if (IN_param_value != NULL) {

   175

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   176

              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 ;

   177

            }

   178

   179

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

   180

            {

   181

   182

                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   183

                return return_type_symbol;

   184

   185

            }

   186

   187

   188

            ERROR;

   189

        }

   190

   191

    }/*function_real_to_date*/

   192

    break;

   193

   194

/****

   195

 *REAL_TO_DWORD

   196

 */

   197

    case function_real_to_dword :

   198

    {

   199

        symbol_c *last_type_symbol = NULL;

   200

   201

        {

   202

            identifier_c param_name("IN");

   203

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

   204

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

   205

            symbol_c *IN_type_symbol = NULL;

   206

   207

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

   208

            if (IN_param_value == NULL)

   209

              IN_param_value = function_call_param_iterator.next_nf();

   210

            if (IN_param_value != NULL) {

   211

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   212

              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 ;

   213

            }

   214

   215

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

   216

            {

   217

   218

                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   219

                return return_type_symbol;

   220

   221

            }

   222

   223

   224

            ERROR;

   225

        }

   226

   227

    }/*function_real_to_dword*/

   228

    break;

   229

   230

/****

   231

 *REAL_TO_DT

   232

 */

   233

    case function_real_to_dt :

   234

    {

   235

        symbol_c *last_type_symbol = NULL;

   236

   237

        {

   238

            identifier_c param_name("IN");

   239

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

   240

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

   241

            symbol_c *IN_type_symbol = NULL;

   242

   243

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

   244

            if (IN_param_value == NULL)

   245

              IN_param_value = function_call_param_iterator.next_nf();

   246

            if (IN_param_value != NULL) {

   247

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   248

              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 ;

   249

            }

   250

   251

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

   252

            {

   253

   254

                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   255

                return return_type_symbol;

   256

   257

            }

   258

   259

   260

            ERROR;

   261

        }

   262

   263

    }/*function_real_to_dt*/

   264

    break;

   265

   266

/****

   267

 *REAL_TO_TOD

   268

 */

   269

    case function_real_to_tod :

   270

    {

   271

        symbol_c *last_type_symbol = NULL;

   272

   273

        {

   274

            identifier_c param_name("IN");

   275

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

   276

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

   277

            symbol_c *IN_type_symbol = NULL;

   278

   279

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

   280

            if (IN_param_value == NULL)

   281

              IN_param_value = function_call_param_iterator.next_nf();

   282

            if (IN_param_value != NULL) {

   283

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   284

              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 ;

   285

            }

   286

   287

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

   288

            {

   289

   290

                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   291

                return return_type_symbol;

   292

   293

            }

   294

   295

   296

            ERROR;

   297

        }

   298

   299

    }/*function_real_to_tod*/

   300

    break;

   301

   302

/****

   303

 *REAL_TO_UDINT

   304

 */

   305

    case function_real_to_udint :

   306

    {

   307

        symbol_c *last_type_symbol = NULL;

   308

   309

        {

   310

            identifier_c param_name("IN");

   311

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

   312

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

   313

            symbol_c *IN_type_symbol = NULL;

   314

   315

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

   316

            if (IN_param_value == NULL)

   317

              IN_param_value = function_call_param_iterator.next_nf();

   318

            if (IN_param_value != NULL) {

   319

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   320

              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 ;

   321

            }

   322

   323

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

   324

            {

   325

   326

                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   327

                return return_type_symbol;

   328

   329

            }

   330

   331

   332

            ERROR;

   333

        }

   334

   335

    }/*function_real_to_udint*/

   336

    break;

   337

   338

/****

   339

 *REAL_TO_WORD

   340

 */

   341

    case function_real_to_word :

   342

    {

   343

        symbol_c *last_type_symbol = NULL;

   344

   345

        {

   346

            identifier_c param_name("IN");

   347

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

   348

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

   349

            symbol_c *IN_type_symbol = NULL;

   350

   351

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

   352

            if (IN_param_value == NULL)

   353

              IN_param_value = function_call_param_iterator.next_nf();

   354

            if (IN_param_value != NULL) {

   355

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   356

              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 ;

   357

            }

   358

   359

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

   360

            {

   361

   362

                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   363

                return return_type_symbol;

   364

   365

            }

   366

   367

   368

            ERROR;

   369

        }

   370

   371

    }/*function_real_to_word*/

   372

    break;

   373

   374

/****

   375

 *REAL_TO_STRING

   376

 */

   377

    case function_real_to_string :

   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_f(&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_nf();

   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

   398

                symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   399

                return return_type_symbol;

   400

   401

            }

   402

   403

   404

            ERROR;

   405

        }

   406

   407

    }/*function_real_to_string*/

   408

    break;

   409

   410

/****

   411

 *REAL_TO_LWORD

   412

 */

   413

    case function_real_to_lword :

   414

    {

   415

        symbol_c *last_type_symbol = NULL;

   416

   417

        {

   418

            identifier_c param_name("IN");

   419

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

   420

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

   421

            symbol_c *IN_type_symbol = NULL;

   422

   423

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

   424

            if (IN_param_value == NULL)

   425

              IN_param_value = function_call_param_iterator.next_nf();

   426

            if (IN_param_value != NULL) {

   427

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   428

              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 ;

   429

            }

   430

   431

            if(IN_type_symbol == NULL || 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::lword_type_name;

   435

                return return_type_symbol;

   436

   437

            }

   438

   439

   440

            ERROR;

   441

        }

   442

   443

    }/*function_real_to_lword*/

   444

    break;

   445

   446

/****

   447

 *REAL_TO_UINT

   448

 */

   449

    case function_real_to_uint :

   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_f(&param_name);

   457

            symbol_c *IN_type_symbol = NULL;

   458

   459

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

   460

            if (IN_param_value == NULL)

   461

              IN_param_value = function_call_param_iterator.next_nf();

   462

            if (IN_param_value != NULL) {

   463

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   464

              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 ;

   465

            }

   466

   467

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

   468

            {

   469

   470

                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   471

                return return_type_symbol;

   472

   473

            }

   474

   475

   476

            ERROR;

   477

        }

   478

   479

    }/*function_real_to_uint*/

   480

    break;

   481

   482

/****

   483

 *REAL_TO_LREAL

   484

 */

   485

    case function_real_to_lreal :

   486

    {

   487

        symbol_c *last_type_symbol = NULL;

   488

   489

        {

   490

            identifier_c param_name("IN");

   491

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

   492

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

   493

            symbol_c *IN_type_symbol = NULL;

   494

   495

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

   496

            if (IN_param_value == NULL)

   497

              IN_param_value = function_call_param_iterator.next_nf();

   498

            if (IN_param_value != NULL) {

   499

              IN_type_symbol = search_expression_type->get_type(IN_param_value);

   500

              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 ;

   501

            }

   502

   503

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

   504

            {

   505

   506

                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   507

                return return_type_symbol;

   508

   509

            }

   510

   511

   512

            ERROR;

   513

        }

   514

   515

    }/*function_real_to_lreal*/

   516

    break;

   517

   518

/****

   519

 *REAL_TO_BYTE

   520

 */

   521

    case function_real_to_byte :

   522

    {