1

     2

/****

     3

 * IEC 61131-3 standard function lib

     4

 * generated code, do not edit by hand

     5

 */

     6

switch(current_function_type){

     7

     8

/****

     9

 *REAL_TO_REAL

    10

 */

    11

	case function_real_to_real :

    12

	{

    13

		symbol_c *last_type_symbol = NULL;

    14

    15

		{

    16

			identifier_c param_name("IN");

    17

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

    18

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

    19

    20

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

    21

			if (IN_param_value == NULL)

    22

			  IN_param_value = function_call_param_iterator.next();

    23

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

    24

			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 ;

    25

    26

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

    27

			{

    28

    29

				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;

    30

				s4o.print("(");

    31

				return_type_symbol->accept(*this);

    32

				s4o.print(")");

    33

				IN_param_value->accept(*this);

    34

				return NULL;

    35

    36

			}

    37

    38

			ERROR;

    39

		}

    40

    41

	}/*function_real_to_real*/

    42

	break;

    43

    44

/****

    45

 *REAL_TO_SINT

    46

 */

    47

	case function_real_to_sint :

    48

	{

    49

		symbol_c *last_type_symbol = NULL;

    50

    51

		{

    52

			identifier_c param_name("IN");

    53

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

    54

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

    55

    56

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

    57

			if (IN_param_value == NULL)

    58

			  IN_param_value = function_call_param_iterator.next();

    59

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

    60

			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 ;

    61

    62

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

    63

			{

    64

    65

				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;

    66

				s4o.print("(");

    67

				return_type_symbol->accept(*this);

    68

				s4o.print(")");

    69

				IN_param_value->accept(*this);

    70

				return NULL;

    71

    72

			}

    73

    74

			ERROR;

    75

		}

    76

    77

	}/*function_real_to_sint*/

    78

	break;

    79

    80

/****

    81

 *REAL_TO_LINT

    82

 */

    83

	case function_real_to_lint :

    84

	{

    85

		symbol_c *last_type_symbol = NULL;

    86

    87

		{

    88

			identifier_c param_name("IN");

    89

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

    90

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

    91

    92

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

    93

			if (IN_param_value == NULL)

    94

			  IN_param_value = function_call_param_iterator.next();

    95

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

    96

			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 ;

    97

    98

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

    99

			{

   100

   101

				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;

   102

				s4o.print("(");

   103

				return_type_symbol->accept(*this);

   104

				s4o.print(")");

   105

				IN_param_value->accept(*this);

   106

				return NULL;

   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 (typeid(*last_type_symbol) == typeid(real_type_name_c))

   135

			{

   136

   137

				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;

   138

				s4o.print("(");

   139

				return_type_symbol->accept(*this);

   140

				s4o.print(")");

   141

				IN_param_value->accept(*this);

   142

				return NULL;

   143

   144

			}

   145

   146

			ERROR;

   147

		}

   148

   149

	}/*function_real_to_dint*/

   150

	break;

   151

   152

/****

   153

 *REAL_TO_DATE

   154

 */

   155

	case function_real_to_date :

   156

	{

   157

		symbol_c *last_type_symbol = NULL;

   158

   159

		{

   160

			identifier_c param_name("IN");

   161

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

   162

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

   163

   164

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

   165

			if (IN_param_value == NULL)

   166

			  IN_param_value = function_call_param_iterator.next();

   167

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

   168

			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 ;

   169

   170

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   171

			{

   172

   173

				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;

   174

				s4o.print("(");

   175

				return_type_symbol->accept(*this);

   176

				s4o.print(")time_to_real(");

   177

				IN_param_value->accept(*this);

   178

				s4o.print(")");

   179

				return NULL;

   180

   181

			}

   182

   183

			ERROR;

   184

		}

   185

   186

	}/*function_real_to_date*/

   187

	break;

   188

   189

/****

   190

 *REAL_TO_DWORD

   191

 */

   192

	case function_real_to_dword :

   193

	{

   194

		symbol_c *last_type_symbol = NULL;

   195

   196

		{

   197

			identifier_c param_name("IN");

   198

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

   199

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

   200

   201

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

   202

			if (IN_param_value == NULL)

   203

			  IN_param_value = function_call_param_iterator.next();

   204

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

   205

			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 ;

   206

   207

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   208

			{

   209

   210

				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;

   211

				s4o.print("(");

   212

				return_type_symbol->accept(*this);

   213

				s4o.print(")");

   214

				IN_param_value->accept(*this);

   215

				return NULL;

   216

   217

			}

   218

   219

			ERROR;

   220

		}

   221

   222

	}/*function_real_to_dword*/

   223

	break;

   224

   225

/****

   226

 *REAL_TO_DT

   227

 */

   228

	case function_real_to_dt :

   229

	{

   230

		symbol_c *last_type_symbol = NULL;

   231

   232

		{

   233

			identifier_c param_name("IN");

   234

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

   235

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

   236

   237

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

   238

			if (IN_param_value == NULL)

   239

			  IN_param_value = function_call_param_iterator.next();

   240

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

   241

			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 ;

   242

   243

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   244

			{

   245

   246

				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;

   247

				s4o.print("(");

   248

				return_type_symbol->accept(*this);

   249

				s4o.print(")time_to_real(");

   250

				IN_param_value->accept(*this);

   251

				s4o.print(")");

   252

				return NULL;

   253

   254

			}

   255

   256

			ERROR;

   257

		}

   258

   259

	}/*function_real_to_dt*/

   260

	break;

   261

   262

/****

   263

 *REAL_TO_TOD

   264

 */

   265

	case function_real_to_tod :

   266

	{

   267

		symbol_c *last_type_symbol = NULL;

   268

   269

		{

   270

			identifier_c param_name("IN");

   271

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

   272

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

   273

   274

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

   275

			if (IN_param_value == NULL)

   276

			  IN_param_value = function_call_param_iterator.next();

   277

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

   278

			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 ;

   279

   280

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   281

			{

   282

   283

				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;

   284

				s4o.print("(");

   285

				return_type_symbol->accept(*this);

   286

				s4o.print(")time_to_real(");

   287

				IN_param_value->accept(*this);

   288

				s4o.print(")");

   289

				return NULL;

   290

   291

			}

   292

   293

			ERROR;

   294

		}

   295

   296

	}/*function_real_to_tod*/

   297

	break;

   298

   299

/****

   300

 *REAL_TO_UDINT

   301

 */

   302

	case function_real_to_udint :

   303

	{

   304

		symbol_c *last_type_symbol = NULL;

   305

   306

		{

   307

			identifier_c param_name("IN");

   308

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

   309

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

   310

   311

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

   312

			if (IN_param_value == NULL)

   313

			  IN_param_value = function_call_param_iterator.next();

   314

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

   315

			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 ;

   316

   317

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   318

			{

   319

   320

				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;

   321

				s4o.print("(");

   322

				return_type_symbol->accept(*this);

   323

				s4o.print(")");

   324

				IN_param_value->accept(*this);

   325

				return NULL;

   326

   327

			}

   328

   329

			ERROR;

   330

		}

   331

   332

	}/*function_real_to_udint*/

   333

	break;

   334

   335

/****

   336

 *REAL_TO_WORD

   337

 */

   338

	case function_real_to_word :

   339

	{

   340

		symbol_c *last_type_symbol = NULL;

   341

   342

		{

   343

			identifier_c param_name("IN");

   344

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

   345

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

   346

   347

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

   348

			if (IN_param_value == NULL)

   349

			  IN_param_value = function_call_param_iterator.next();

   350

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

   351

			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 ;

   352

   353

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   354

			{

   355

   356

				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;

   357

				s4o.print("(");

   358

				return_type_symbol->accept(*this);

   359

				s4o.print(")");

   360

				IN_param_value->accept(*this);

   361

				return NULL;

   362

   363

			}

   364

   365

			ERROR;

   366

		}

   367

   368

	}/*function_real_to_word*/

   369

	break;

   370

   371

/****

   372

 *REAL_TO_WSTRING

   373

 */

   374

	case function_real_to_wstring :

   375

	{

   376

		symbol_c *last_type_symbol = NULL;

   377

   378

		{

   379

			identifier_c param_name("IN");

   380

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

   381

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

   382

   383

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

   384

			if (IN_param_value == NULL)

   385

			  IN_param_value = function_call_param_iterator.next();

   386

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

   387

			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 ;

   388

   389

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   390

			{

   391

   392

				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;

   393

				s4o.print("(");

   394

				return_type_symbol->accept(*this);

   395

				s4o.print(")string_to_int(");

   396

				IN_param_value->accept(*this);

   397

				s4o.print(", 10)");

   398

				return NULL;

   399

   400

			}

   401

   402

			ERROR;

   403

		}

   404

   405

	}/*function_real_to_wstring*/

   406

	break;

   407

   408

/****

   409

 *REAL_TO_STRING

   410

 */

   411

	case function_real_to_string :

   412

	{

   413

		symbol_c *last_type_symbol = NULL;

   414

   415

		{

   416

			identifier_c param_name("IN");

   417

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

   418

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

   419

   420

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

   421

			if (IN_param_value == NULL)

   422

			  IN_param_value = function_call_param_iterator.next();

   423

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

   424

			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 ;

   425

   426

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   427

			{

   428

   429

				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;

   430

				s4o.print("(");

   431

				return_type_symbol->accept(*this);

   432

				s4o.print(")string_to_int(");

   433

				IN_param_value->accept(*this);

   434

				s4o.print(", 10)");

   435

				return NULL;

   436

   437

			}

   438

   439

			ERROR;

   440

		}

   441

   442

	}/*function_real_to_string*/

   443

	break;

   444

   445

/****

   446

 *REAL_TO_LWORD

   447

 */

   448

	case function_real_to_lword :

   449

	{

   450

		symbol_c *last_type_symbol = NULL;

   451

   452

		{

   453

			identifier_c param_name("IN");

   454

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

   455

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

   456

   457

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

   458

			if (IN_param_value == NULL)

   459

			  IN_param_value = function_call_param_iterator.next();

   460

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

   461

			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 ;

   462

   463

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   464

			{

   465

   466

				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;

   467

				s4o.print("(");

   468

				return_type_symbol->accept(*this);

   469

				s4o.print(")");

   470

				IN_param_value->accept(*this);

   471

				return NULL;

   472

   473

			}

   474

   475

			ERROR;

   476

		}

   477

   478

	}/*function_real_to_lword*/

   479

	break;

   480

   481

/****

   482

 *REAL_TO_UINT

   483

 */

   484

	case function_real_to_uint :

   485

	{

   486

		symbol_c *last_type_symbol = NULL;

   487

   488

		{

   489

			identifier_c param_name("IN");

   490

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

   491

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

   492

   493

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

   494

			if (IN_param_value == NULL)

   495

			  IN_param_value = function_call_param_iterator.next();

   496

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

   497

			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 ;

   498

   499

			if (typeid(*last_type_symbol) == typeid(real_type_name_c))

   500

			{

   501

   502

				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;

   503

				s4o.print("(");

   504

				return_type_symbol->accept(*this);

   505

				s4o.print(")");

   506

				IN_param_value->accept(*this);

   507

				return NULL;

   508

   509

			}

   510

   511

			ERROR;

   512

		}

   513

   514

	}/*function_real_to_uint*/

   515

	break;

   516

   517

/****

   518

 *REAL_TO_LREAL

   519

 */

   520

	case function_real_to_lreal :

   521

	{

   522

		symbol_c *last_type_symbol = NULL;

   523

   524

		{

   525

			identifier_c param_name("IN");

   526

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

   527

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

   528

   529

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

   530