26

/****

    27

 * IEC 61131-3 standard function lib

    28

 * generated code, do not edit by hand

    29

 */

    30

    31

void *compute_standard_function_st(function_invocation_c *symbol) {

    32

    33

  function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);

    34

  function_call_param_iterator_c function_call_param_iterator(symbol);

    35

  search_expression_type_c* search_expression_type = this;

    36

    37

  switch(current_function_type){

    38

    39

/****

    40

 *BOOL_TO_SINT

    41

 */

    42

    case function_bool_to_sint :

    43

    {

    44

        symbol_c *last_type_symbol = NULL;

    45

    46

        {

    47

            identifier_c param_name("IN");

    48

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

    49

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

    50

    51

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

    52

            if (IN_param_value == NULL)

    53

              IN_param_value = function_call_param_iterator.next();

    54

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

    55

            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 ;

    56

    57

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

    58

            {

    59

    60

                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    61

                return return_type_symbol;

    62

    63

            }

    64

    65

            ERROR;

    66

        }

    67

    68

    }/*function_bool_to_sint*/

    69

    break;

    70

    71

/****

    72

 *BOOL_TO_INT

    73

 */

    74

    case function_bool_to_int :

    75

    {

    76

        symbol_c *last_type_symbol = NULL;

    77

    78

        {

    79

            identifier_c param_name("IN");

    80

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

    81

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

    82

    83

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

    84

            if (IN_param_value == NULL)

    85

              IN_param_value = function_call_param_iterator.next();

    86

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

    87

            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 ;

    88

    89

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

    90

            {

    91

    92

                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

    93

                return return_type_symbol;

    94

    95

            }

    96

    97

            ERROR;

    98

        }

    99

   100

    }/*function_bool_to_int*/

   101

    break;

   102

   103

/****

   104

 *BOOL_TO_DINT

   105

 */

   106

    case function_bool_to_dint :

   107

    {

   108

        symbol_c *last_type_symbol = NULL;

   109

   110

        {

   111

            identifier_c param_name("IN");

   112

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

   113

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

   114

   115

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

   116

            if (IN_param_value == NULL)

   117

              IN_param_value = function_call_param_iterator.next();

   118

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

   119

            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 ;

   120

   121

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

   122

            {

   123

   124

                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   125

                return return_type_symbol;

   126

   127

            }

   128

   129

            ERROR;

   130

        }

   131

   132

    }/*function_bool_to_dint*/

   133

    break;

   134

   135

/****

   136

 *BOOL_TO_LINT

   137

 */

   138

    case function_bool_to_lint :

   139

    {

   140

        symbol_c *last_type_symbol = NULL;

   141

   142

        {

   143

            identifier_c param_name("IN");

   144

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

   145

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

   146

   147

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

   148

            if (IN_param_value == NULL)

   149

              IN_param_value = function_call_param_iterator.next();

   150

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

   151

            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 ;

   152

   153

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

   154

            {

   155

   156

                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   157

                return return_type_symbol;

   158

   159

            }

   160

   161

            ERROR;

   162

        }

   163

   164

    }/*function_bool_to_lint*/

   165

    break;

   166

   167

/****

   168

 *BOOL_TO_USINT

   169

 */

   170

    case function_bool_to_usint :

   171

    {

   172

        symbol_c *last_type_symbol = NULL;

   173

   174

        {

   175

            identifier_c param_name("IN");

   176

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

   177

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

   178

   179

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

   180

            if (IN_param_value == NULL)

   181

              IN_param_value = function_call_param_iterator.next();

   182

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

   183

            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 ;

   184

   185

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

   186

            {

   187

   188

                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   189

                return return_type_symbol;

   190

   191

            }

   192

   193

            ERROR;

   194

        }

   195

   196

    }/*function_bool_to_usint*/

   197

    break;

   198

   199

/****

   200

 *BOOL_TO_UINT

   201

 */

   202

    case function_bool_to_uint :

   203

    {

   204

        symbol_c *last_type_symbol = NULL;

   205

   206

        {

   207

            identifier_c param_name("IN");

   208

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

   209

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

   210

   211

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

   212

            if (IN_param_value == NULL)

   213

              IN_param_value = function_call_param_iterator.next();

   214

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

   215

            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 ;

   216

   217

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

   218

            {

   219

   220

                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   221

                return return_type_symbol;

   222

   223

            }

   224

   225

            ERROR;

   226

        }

   227

   228

    }/*function_bool_to_uint*/

   229

    break;

   230

   231

/****

   232

 *BOOL_TO_UDINT

   233

 */

   234

    case function_bool_to_udint :

   235

    {

   236

        symbol_c *last_type_symbol = NULL;

   237

   238

        {

   239

            identifier_c param_name("IN");

   240

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

   241

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

   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();

   246

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

   247

            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 ;

   248

   249

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

   250

            {

   251

   252

                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   253

                return return_type_symbol;

   254

   255

            }

   256

   257

            ERROR;

   258

        }

   259

   260

    }/*function_bool_to_udint*/

   261

    break;

   262

   263

/****

   264

 *BOOL_TO_ULINT

   265

 */

   266

    case function_bool_to_ulint :

   267

    {

   268

        symbol_c *last_type_symbol = NULL;

   269

   270

        {

   271

            identifier_c param_name("IN");

   272

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

   273

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

   274

   275

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

   276

            if (IN_param_value == NULL)

   277

              IN_param_value = function_call_param_iterator.next();

   278

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

   279

            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 ;

   280

   281

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

   282

            {

   283

   284

                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   285

                return return_type_symbol;

   286

   287

            }

   288

   289

            ERROR;

   290

        }

   291

   292

    }/*function_bool_to_ulint*/

   293

    break;

   294

   295

/****

   296

 *BOOL_TO_REAL

   297

 */

   298

    case function_bool_to_real :

   299

    {

   300

        symbol_c *last_type_symbol = NULL;

   301

   302

        {

   303

            identifier_c param_name("IN");

   304

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

   305

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

   306

   307

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

   308

            if (IN_param_value == NULL)

   309

              IN_param_value = function_call_param_iterator.next();

   310

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

   311

            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 ;

   312

   313

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

   314

            {

   315

   316

                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   317

                return return_type_symbol;

   318

   319

            }

   320

   321

            ERROR;

   322

        }

   323

   324

    }/*function_bool_to_real*/

   325

    break;

   326

   327

/****

   328

 *BOOL_TO_LREAL

   329

 */

   330

    case function_bool_to_lreal :

   331

    {

   332

        symbol_c *last_type_symbol = NULL;

   333

   334

        {

   335

            identifier_c param_name("IN");

   336

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

   337

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

   338

   339

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

   340

            if (IN_param_value == NULL)

   341

              IN_param_value = function_call_param_iterator.next();

   342

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

   343

            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 ;

   344

   345

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

   346

            {

   347

   348

                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   349

                return return_type_symbol;

   350

   351

            }

   352

   353

            ERROR;

   354

        }

   355

   356

    }/*function_bool_to_lreal*/

   357

    break;

   358

   359

/****

   360

 *BOOL_TO_TIME

   361

 */

   362

    case function_bool_to_time :

   363

    {

   364

        symbol_c *last_type_symbol = NULL;

   365

   366

        {

   367

            identifier_c param_name("IN");

   368

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

   369

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

   370

   371

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

   372

            if (IN_param_value == NULL)

   373

              IN_param_value = function_call_param_iterator.next();

   374

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

   375

            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 ;

   376

   377

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

   378

            {

   379

   380

                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   381

                return return_type_symbol;

   382

   383

            }

   384

   385

            ERROR;

   386

        }

   387

   388

    }/*function_bool_to_time*/

   389

    break;

   390

   391

/****

   392

 *BOOL_TO_DATE

   393

 */

   394

    case function_bool_to_date :

   395

    {

   396

        symbol_c *last_type_symbol = NULL;

   397

   398

        {

   399

            identifier_c param_name("IN");

   400

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

   401

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

   402

   403

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

   404

            if (IN_param_value == NULL)

   405

              IN_param_value = function_call_param_iterator.next();

   406

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

   407

            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 ;

   408

   409

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

   410

            {

   411

   412

                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   413

                return return_type_symbol;

   414

   415

            }

   416

   417

            ERROR;

   418

        }

   419

   420

    }/*function_bool_to_date*/

   421

    break;

   422

   423

/****

   424

 *BOOL_TO_TOD

   425

 */

   426

    case function_bool_to_tod :

   427

    {

   428

        symbol_c *last_type_symbol = NULL;

   429

   430

        {

   431

            identifier_c param_name("IN");

   432

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

   433

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

   434

   435

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

   436

            if (IN_param_value == NULL)

   437

              IN_param_value = function_call_param_iterator.next();

   438

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

   439

            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 ;

   440

   441

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

   442

            {

   443

   444

                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   445

                return return_type_symbol;

   446

   447

            }

   448

   449

            ERROR;

   450

        }

   451

   452

    }/*function_bool_to_tod*/

   453

    break;

   454

   455

/****

   456

 *BOOL_TO_DT

   457

 */

   458

    case function_bool_to_dt :

   459

    {

   460

        symbol_c *last_type_symbol = NULL;

   461

   462

        {

   463

            identifier_c param_name("IN");

   464

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

   465

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

   466

   467

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

   468

            if (IN_param_value == NULL)

   469

              IN_param_value = function_call_param_iterator.next();

   470

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

   471

            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 ;

   472

   473

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

   474

            {

   475

   476

                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   477

                return return_type_symbol;

   478

   479

            }

   480

   481

            ERROR;

   482

        }

   483

   484

    }/*function_bool_to_dt*/

   485

    break;

   486

   487

/****

   488

 *BOOL_TO_STRING

   489

 */

   490

    case function_bool_to_string :

   491

    {

   492

        symbol_c *last_type_symbol = NULL;

   493

   494

        {

   495

            identifier_c param_name("IN");