1

/*

     2

 * (c) 2003 Mario de Sousa

     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

/****

    27

 * IEC 61131-3 standard function lib

    28

 * generated code, do not edit by hand

    29

 */

    30

switch(current_function_type){

    31

    32

/****

    33

 *BOOL_TO_SINT

    34

 */

    35

    case function_bool_to_sint :

    36

    {

    37

        symbol_c *last_type_symbol = NULL;

    38

    39

        {

    40

            identifier_c param_name("IN");

    41

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

    42

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

    43

    44

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

    45

            if (IN_param_value == NULL)

    46

              IN_param_value = function_call_param_iterator.next();

    47

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

    48

            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 ;

    49

    50

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

    51

            {

    52

    53

                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    54

                s4o.print("(");

    55

                return_type_symbol->accept(*this);

    56

                s4o.print(")");

    57

                IN_param_value->accept(*this);

    58

                return NULL;

    59

    60

            }

    61

    62

            ERROR;

    63

        }

    64

    65

    }/*function_bool_to_sint*/

    66

    break;

    67

    68

/****

    69

 *BOOL_TO_INT

    70

 */

    71

    case function_bool_to_int :

    72

    {

    73

        symbol_c *last_type_symbol = NULL;

    74

    75

        {

    76

            identifier_c param_name("IN");

    77

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

    78

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

    79

    80

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

    81

            if (IN_param_value == NULL)

    82

              IN_param_value = function_call_param_iterator.next();

    83

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

    84

            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 ;

    85

    86

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

    87

            {

    88

    89

                symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;

    90

                s4o.print("(");

    91

                return_type_symbol->accept(*this);

    92

                s4o.print(")");

    93

                IN_param_value->accept(*this);

    94

                return NULL;

    95

    96

            }

    97

    98

            ERROR;

    99

        }

   100

   101

    }/*function_bool_to_int*/

   102

    break;

   103

   104

/****

   105

 *BOOL_TO_DINT

   106

 */

   107

    case function_bool_to_dint :

   108

    {

   109

        symbol_c *last_type_symbol = NULL;

   110

   111

        {

   112

            identifier_c param_name("IN");

   113

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

   114

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

   115

   116

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

   117

            if (IN_param_value == NULL)

   118

              IN_param_value = function_call_param_iterator.next();

   119

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

   120

            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 ;

   121

   122

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

   123

            {

   124

   125

                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   126

                s4o.print("(");

   127

                return_type_symbol->accept(*this);

   128

                s4o.print(")");

   129

                IN_param_value->accept(*this);

   130

                return NULL;

   131

   132

            }

   133

   134

            ERROR;

   135

        }

   136

   137

    }/*function_bool_to_dint*/

   138

    break;

   139

   140

/****

   141

 *BOOL_TO_LINT

   142

 */

   143

    case function_bool_to_lint :

   144

    {

   145

        symbol_c *last_type_symbol = NULL;

   146

   147

        {

   148

            identifier_c param_name("IN");

   149

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

   150

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

   151

   152

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

   153

            if (IN_param_value == NULL)

   154

              IN_param_value = function_call_param_iterator.next();

   155

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

   156

            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 ;

   157

   158

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

   159

            {

   160

   161

                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   162

                s4o.print("(");

   163

                return_type_symbol->accept(*this);

   164

                s4o.print(")");

   165

                IN_param_value->accept(*this);

   166

                return NULL;

   167

   168

            }

   169

   170

            ERROR;

   171

        }

   172

   173

    }/*function_bool_to_lint*/

   174

    break;

   175

   176

/****

   177

 *BOOL_TO_USINT

   178

 */

   179

    case function_bool_to_usint :

   180

    {

   181

        symbol_c *last_type_symbol = NULL;

   182

   183

        {

   184

            identifier_c param_name("IN");

   185

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

   186

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

   187

   188

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

   189

            if (IN_param_value == NULL)

   190

              IN_param_value = function_call_param_iterator.next();

   191

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

   192

            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 ;

   193

   194

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

   195

            {

   196

   197

                symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;

   198

                s4o.print("(");

   199

                return_type_symbol->accept(*this);

   200

                s4o.print(")");

   201

                IN_param_value->accept(*this);

   202

                return NULL;

   203

   204

            }

   205

   206

            ERROR;

   207

        }

   208

   209

    }/*function_bool_to_usint*/

   210

    break;

   211

   212

/****

   213

 *BOOL_TO_UINT

   214

 */

   215

    case function_bool_to_uint :

   216

    {

   217

        symbol_c *last_type_symbol = NULL;

   218

   219

        {

   220

            identifier_c param_name("IN");

   221

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

   222

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

   223

   224

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

   225

            if (IN_param_value == NULL)

   226

              IN_param_value = function_call_param_iterator.next();

   227

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

   228

            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 ;

   229

   230

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

   231

            {

   232

   233

                symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   234

                s4o.print("(");

   235

                return_type_symbol->accept(*this);

   236

                s4o.print(")");

   237

                IN_param_value->accept(*this);

   238

                return NULL;

   239

   240

            }

   241

   242

            ERROR;

   243

        }

   244

   245

    }/*function_bool_to_uint*/

   246

    break;

   247

   248

/****

   249

 *BOOL_TO_UDINT

   250

 */

   251

    case function_bool_to_udint :

   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::bool_type_name, last_type_symbol))

   267

            {

   268

   269

                symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   270

                s4o.print("(");

   271

                return_type_symbol->accept(*this);

   272

                s4o.print(")");

   273

                IN_param_value->accept(*this);

   274

                return NULL;

   275

   276

            }

   277

   278

            ERROR;

   279

        }

   280

   281

    }/*function_bool_to_udint*/

   282

    break;

   283

   284

/****

   285

 *BOOL_TO_ULINT

   286

 */

   287

    case function_bool_to_ulint :

   288

    {

   289

        symbol_c *last_type_symbol = NULL;

   290

   291

        {

   292

            identifier_c param_name("IN");

   293

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

   294

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

   295

   296

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

   297

            if (IN_param_value == NULL)

   298

              IN_param_value = function_call_param_iterator.next();

   299

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

   300

            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 ;

   301

   302

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

   303

            {

   304

   305

                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;

   306

                s4o.print("(");

   307

                return_type_symbol->accept(*this);

   308

                s4o.print(")");

   309

                IN_param_value->accept(*this);

   310

                return NULL;

   311

   312

            }

   313

   314

            ERROR;

   315

        }

   316

   317

    }/*function_bool_to_ulint*/

   318

    break;

   319

   320

/****

   321

 *BOOL_TO_REAL

   322

 */

   323

    case function_bool_to_real :

   324

    {

   325

        symbol_c *last_type_symbol = NULL;

   326

   327

        {

   328

            identifier_c param_name("IN");

   329

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

   330

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

   331

   332

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

   333

            if (IN_param_value == NULL)

   334

              IN_param_value = function_call_param_iterator.next();

   335

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

   336

            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 ;

   337

   338

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

   339

            {

   340

   341

                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

   342

                s4o.print("(");

   343

                return_type_symbol->accept(*this);

   344

                s4o.print(")");

   345

                IN_param_value->accept(*this);

   346

                return NULL;

   347

   348

            }

   349

   350

            ERROR;

   351

        }

   352

   353

    }/*function_bool_to_real*/

   354

    break;

   355

   356

/****

   357

 *BOOL_TO_LREAL

   358

 */

   359

    case function_bool_to_lreal :

   360

    {

   361

        symbol_c *last_type_symbol = NULL;

   362

   363

        {

   364

            identifier_c param_name("IN");

   365

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

   366

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

   367

   368

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

   369

            if (IN_param_value == NULL)

   370

              IN_param_value = function_call_param_iterator.next();

   371

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

   372

            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 ;

   373

   374

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

   375

            {

   376

   377

                symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;

   378

                s4o.print("(");

   379

                return_type_symbol->accept(*this);

   380

                s4o.print(")");

   381

                IN_param_value->accept(*this);

   382

                return NULL;

   383

   384

            }

   385

   386

            ERROR;

   387

        }

   388

   389

    }/*function_bool_to_lreal*/

   390

    break;

   391

   392

/****

   393

 *BOOL_TO_TIME

   394

 */

   395

    case function_bool_to_time :

   396

    {

   397

        symbol_c *last_type_symbol = NULL;

   398

   399

        {

   400

            identifier_c param_name("IN");

   401

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

   402

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

   403

   404

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

   405

            if (IN_param_value == NULL)

   406

              IN_param_value = function_call_param_iterator.next();

   407

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

   408

            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 ;

   409

   410

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

   411

            {

   412

   413

                symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;

   414

                s4o.print("(");

   415

                return_type_symbol->accept(*this);

   416

                s4o.print(")__int_to_time(");

   417

                IN_param_value->accept(*this);

   418

                s4o.print(")");

   419

                return NULL;

   420

   421

            }

   422

   423

            ERROR;

   424

        }

   425

   426

    }/*function_bool_to_time*/

   427

    break;

   428

   429

/****

   430

 *BOOL_TO_DATE

   431

 */

   432

    case function_bool_to_date :

   433

    {

   434

        symbol_c *last_type_symbol = NULL;

   435

   436

        {

   437

            identifier_c param_name("IN");

   438

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

   439

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

   440

   441

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

   442

            if (IN_param_value == NULL)

   443

              IN_param_value = function_call_param_iterator.next();

   444

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

   445

            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 ;

   446

   447

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

   448

            {

   449

   450

                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   451

                s4o.print("(");

   452

                return_type_symbol->accept(*this);

   453

                s4o.print(")__int_to_time(");

   454

                IN_param_value->accept(*this);

   455

                s4o.print(")");

   456

                return NULL;

   457

   458

            }

   459

   460

            ERROR;

   461

        }

   462

   463

    }/*function_bool_to_date*/

   464

    break;

   465

   466

/****

   467

 *BOOL_TO_TOD

   468

 */

   469

    case function_bool_to_tod :

   470

    {

   471

        symbol_c *last_type_symbol = NULL;

   472

   473

        {

   474

            identifier_c param_name("IN");

   475

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

   476

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

   477

   478

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

   479

            if (IN_param_value == NULL)

   480

              IN_param_value = function_call_param_iterator.next();

   481

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

   482

            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 ;

   483

   484

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

   485

            {

   486

   487

                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   488

                s4o.print("(");

   489

                return_type_symbol->accept(*this);

   490

                s4o.print(")__int_to_time(");

   491

                IN_param_value->accept(*this);

   492

                s4o.print(")");

   493

                return NULL;

   494

   495

            }

   496

   497

            ERROR;

   498

        }

   499

   500

    }/*function_bool_to_tod*/

   501

    break;

   502

   503

/****

   504

 *BOOL_TO_DT

   505

 */

   506

    case function_bool_to_dt :

   507

    {

   508

        symbol_c *last_type_symbol = NULL;

   509

   510

        {

   511

            identifier_c param_name("IN");

   512

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

   513

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

   514

   515

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

   516

            if (IN_param_value == NULL)

   517

              IN_param_value = function_call_param_iterator.next();

   518

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

   519

            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 ;

   520

   521

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

   522

            {

   523

   524

                symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   525

                s4o.print("(");

   526

                return_type_symbol->accept(*this);

   527

                s4o.print(")__int_to_time(");

   528

                IN_param_value->accept(*this);

   529

                s4o.print(")");

   530

                return NULL;