1

/*

     2

 * copyright 2008 Edouard TISSERANT

     3

 * copyright 2011 Mario de Sousa (msousa@fe.up.pt)

     4

 *

     5

 * Offered to the public under the terms of the GNU Lesser General Public

     6

 * License as published by the Free Software Foundation; either version 2

     7

 * of the License, or (at your option) any later version.

     8

 *

     9

 * This program is distributed in the hope that it will be useful, but

    10

 * WITHOUT ANY WARRANTY; without even the implied warranty of

    11

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser

    12

 * General Public License for more details.

    13

 *

    14

 * This code is made available on the understanding that it will not be

    15

 * used in safety-critical situations without a full and competent review.

    16

 */

    17

    18

/****

    19

 * IEC 61131-3 standard function library

    20

 */

    21

    22

/* NOTE: This file is full of (what may seem at first) very strange macros.

    23

 *       If you want to know what all these strange macros are doing,

    24

 *       just parse this file through a C preprocessor (e.g. cpp), 

    25

 *       and analyse the output!

    26

 *       $gcc -E iec_std_lib.h 

    27

 */

    28

    29

#ifndef _IEC_STD_FUNCTIONS_H

    30

#define _IEC_STD_FUNCTIONS_H

    31

    32

    33

/*****************************************************************/

    34

/*****************************************************************/

    35

/*****                                                       *****/

    36

/*****                 IEC 61131-3                           *****/

    37

/*****      S T A N D A R D     F U N C T I O N S            *****/

    38

/*****                                                       *****/

    39

/*****************************************************************/

    40

/*****************************************************************/

    41

    42

/* NOTE: If you want to know what all these strange macros are doing,

    43

 *       just parse this file through a C preprocessor, and analyse the output!

    44

 *       $gcc -E iec_std_lib.h 

    45

 */

    46

    47

/* NOTE: We only define and declare the explicitly typed standard functions

    48

 *       (e.g., SIN_REAL, SIN_LREAL, ..., ADD_SINT, ADD_INT, ADD_LINT, ...)

    49

 *       We do not declare/define the overloaded functions

    50

 *       (SIN, ADD, ...). 

    51

 *       When handling a call to an overloaded function, the iec2c compiler 

    52

 *       will determine in stage3 the data type of the parameter being passed, 

    53

 *       and in stage4 generate the C code to call the correct

    54

 *       typed standard function.

    55

 */

    56

    57

/* NOTE on explicit typing of:

    58

 *           - Table 25 - Standard bit shift functions

    59

 *           - Table 29 - Character string Functions

    60

 *

    61

 *  In section 2.5.1.4 (Typing, overloading, and type conversion) of the IEC 61131-3 (version 2)

    62

 *  of the standard, it is stated:

    63

 * "A standard function, [...] is said to be overloaded when it

    64

 * can operate on input data elements of various types within a generic type designator as defined in

    65

 * 2.3.2. For instance, an overloaded addition function on generic type ANY_NUM can operate on data

    66

 * of types LREAL, REAL, DINT, INT, and SINT."

    67

 * [...]

    68

 * "When a function which normally represents an overloaded operator is to be typed, i.e., the types

    69

 * of its inputs and outputs restricted to a particular elementary or derived data type as defined in

    70

 * 2.3, this shall be done by appending an "underline" character followed by the required type, as

    71

 * shown in table 21."

    72

 *

    73

 * However, this explanation (as well as the example in table 21) only refers to functions where the same

    74

 * generic data type is used for the single input and the output parameter.

    75

 * How can we create explicitly types functions when this is not the case?

    76

 * It does not seem to be covered by the standard.

    77

 *

    78

 * For this reason, we do not define the LEN_SINT, LEN_INT, LEN_STRING, LEN_[ANY_INT], LEN_[ANY_STRING] functions...

    79

 */

    80

    81

    82

/********************/

    83

/*   EN/ENO PARAMS  */

    84

/********************/

    85

    86

#define EN_ENO_PARAMS BOOL EN, BOOL *ENO

    87

#define EN_ENO EN, ENO

    88

    89

#define TEST_EN(TYPENAME)\

    90

  if (!EN) {\

    91

    if (ENO != NULL)\

    92

      *ENO = __BOOL_LITERAL(FALSE);\

    93

    return __INIT_##TYPENAME;\

    94

  }\

    95

  else if (ENO != NULL)\

    96

    *ENO = __BOOL_LITERAL(TRUE);

    97

    98

#define TEST_EN_COND(TYPENAME, COND)\

    99

  if (!EN || (COND)) {\

   100

    if (ENO != NULL)\

   101

      *ENO = __BOOL_LITERAL(FALSE);\

   102

    return __INIT_##TYPENAME;\

   103

  }\

   104

  else if (ENO != NULL)\

   105

    *ENO = __BOOL_LITERAL(TRUE);

   106

   107

   108

   109

/*****************************************/  

   110

/*****************************************/  

   111

/*  2.5.1.5.1 Type Conversion Functions  */

   112

/*****************************************/  

   113

/*****************************************/  

   114

   115

#define __convert_type(from_TYPENAME,to_TYPENAME, oper) \

   116

static inline to_TYPENAME from_TYPENAME##_TO_##to_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\

   117

  TEST_EN(to_TYPENAME)\

   118

  return (to_TYPENAME)oper(op);\

   119

}

   120

   121

/******** [ANY_NUM | ANY_NBIT]_TO_BOOL   ************/

   122

#define __convert_num_to_bool(TYPENAME) \

   123

static inline BOOL TYPENAME##_TO_BOOL(EN_ENO_PARAMS, TYPENAME op){\

   124

  TEST_EN(BOOL)\

   125

  return op == 0 ? 0 : 1;\

   126

}

   127

__ANY_NUM(__convert_num_to_bool)

   128

__ANY_NBIT(__convert_num_to_bool)

   129

   130

/******** [TIME | ANY_DATE]_TO_BOOL   ************/

   131

#define __convert_time_to_bool(TYPENAME) \

   132

static inline BOOL TYPENAME##_TO_BOOL(EN_ENO_PARAMS, TYPENAME op){\

   133

  TEST_EN(BOOL)\

   134

  return op.tv_sec == 0 && op.tv_nsec == 0 ? 0 : 1;\

   135

}

   136

__convert_time_to_bool(TIME)

   137

__ANY_DATE(__convert_time_to_bool)

   138

   139

#define __to_anynum_(from_TYPENAME)   __ANY_NUM_1(__iec_,from_TYPENAME)

   140

#define __to_anyint_(from_TYPENAME)   __ANY_INT_1(__iec_,from_TYPENAME)

   141

#define __to_anybit_(from_TYPENAME)   __ANY_BIT_1(__iec_,from_TYPENAME)

   142

#define __to_anynbit_(from_TYPENAME) __ANY_NBIT_1(__iec_,from_TYPENAME)

   143

#define __to_anysint_(from_TYPENAME) __ANY_SINT_1(__iec_,from_TYPENAME)

   144

#define __to_anyuint_(from_TYPENAME) __ANY_UINT_1(__iec_,from_TYPENAME)

   145

#define __to_anyreal_(from_TYPENAME) __ANY_REAL_1(__iec_,from_TYPENAME)

   146

#define __to_anydate_(from_TYPENAME) __ANY_DATE_1(__iec_,from_TYPENAME)

   147

   148

/******** [ANY_BIT]_TO_[ANY_NUM | ANT_NBIT]   ************/

   149

#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __move_##to_TYPENAME)

   150

__ANY_BIT(__to_anynum_)

   151

__ANY_BIT(__to_anynbit_)

   152

#undef __iec_

   153

   154

/******** [ANY_INT]_TO_[ANY_NUM | ANT_NBIT]   ************/

   155

#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __move_##to_TYPENAME)

   156

__ANY_INT(__to_anynum_)

   157

__ANY_INT(__to_anynbit_)

   158

#undef __iec_

   159

   160

/******** [ANY_REAL]_TO_[ANY_NBIT]   ************/

   161

#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_bit)

   162

__ANY_REAL(__to_anynbit_)

   163

#undef __iec_

   164

   165

/******** [ANY_REAL]_TO_[ANY_NINT]   ************/

   166

#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_sint)

   167

__ANY_REAL(__to_anysint_)

   168

#undef __iec_

   169

#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_uint)

   170

__ANY_REAL(__to_anyuint_)

   171

#undef __iec_

   172

   173

/******** [ANY_REAL]_TO_[ANY_REAL]   ************/ 

   174

#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __move_##to_TYPENAME)

   175

__ANY_REAL(__to_anyreal_)

   176

#undef __iec_

   177

   178

/******** [ANY_BIT | ANY_INT]_TO_[TIME | ANY_DATE]   ************/ 

   179

#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, TIME, __int_to_time)

   180

__ANY_BIT(__iec_)

   181

__ANY_INT(__iec_)

   182

#undef __iec_

   183

#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __int_to_time)

   184

__ANY_BIT(__to_anydate_)

   185

__ANY_INT(__to_anydate_)

   186

#undef __iec_

   187

   188

/******** [ANY_REAL]_TO_[TIME | ANY_DATE]   ************/ 

   189

#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, TIME, __real_to_time)

   190

__ANY_REAL(__iec_)

   191

#undef __iec_

   192

#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_time)

   193

__ANY_REAL(__to_anydate_)

   194

#undef __iec_

   195

   196

/******** [TIME | ANY_DATE]_TO_[ANY_BIT | ANY_INT]   ************/ 

   197

#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __time_to_int)

   198

__to_anyint_(TIME)

   199

__to_anynbit_(TIME)

   200

__ANY_DATE(__to_anyint_)

   201

__ANY_DATE(__to_anynbit_)

   202

#undef __iec_

   203

   204

/******** [TIME | ANY_DATE]_TO_[ANY_REAL]   ************/ 

   205

#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __time_to_real)

   206

__to_anyreal_(TIME)

   207

__ANY_DATE(__to_anyreal_)

   208

#undef __iec_

   209

   210

   211

/******** [ANY_DATE]_TO_[ANY_DATE | TIME]   ************/ 

   212

/* Not supported: DT_TO_TIME */

   213

__convert_type(DT, DATE,  __date_and_time_to_date)

   214

static inline DATE DATE_AND_TIME_TO_DATE(EN_ENO_PARAMS, DT op){

   215

	return DT_TO_DATE(EN_ENO, op);

   216

}

   217

__convert_type(DT, DT,    __move_DT)

   218

__convert_type(DT, TOD,   __date_and_time_to_time_of_day)

   219

static inline DATE DATE_AND_TIME_TO_TIME_OF_DAY(EN_ENO_PARAMS, DT op){

   220

	return DT_TO_TOD(EN_ENO, op);

   221

}

   222

/* Not supported: DATE_TO_TIME */

   223

__convert_type(DATE, DATE, __move_DATE)

   224

/* Not supported: DATE_TO_DT */

   225

/* Not supported: DATE_TO_TOD */

   226

/* Not supported: TOD_TO_TIME */

   227

/* Not supported: TOD_TO_DATE */

   228

/* Not supported: TOD_TO_DT */

   229

__convert_type(TOD, TOD, __move_TOD)

   230

   231

   232

/******** TIME_TO_[ANY_DATE]   ************/ 

   233

/* Not supported: TIME_TO_DATE */

   234

/* Not supported: TIME_TO_DT */

   235

/* Not supported: TIME_TO_TOD */

   236

   237

/******** TIME_TO_TIME   ************/ 

   238

__convert_type(TIME, TIME, __move_TIME)

   239

   240

   241

/******** [ANY_BIT]_TO_STRING   ************/ 

   242

__convert_type(BOOL, STRING, __bool_to_string)

   243

#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __bit_to_string)

   244

__ANY_NBIT(__iec_)

   245

#undef __iec_

   246

   247

/******** [ANY_INT]_TO_STRING   ************/ 

   248

#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __sint_to_string)

   249

__ANY_SINT(__iec_)

   250

#undef __iec_

   251

#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __uint_to_string)

   252

__ANY_UINT(__iec_)

   253

#undef __iec_

   254

   255

/******** [ANY_REAL]_TO_STRING   ************/ 

   256

#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __real_to_string)

   257

__ANY_REAL(__iec_)

   258

#undef __iec_

   259

   260

/******** [ANY_DATE]_TO_STRING   ************/ 

   261

__convert_type(DATE, STRING, __date_to_string)

   262

__convert_type(DT,   STRING, __dt_to_string)

   263

__convert_type(TOD,  STRING, __tod_to_string)

   264

   265

/******** TIME_TO_STRING   ************/ 

   266

__convert_type(TIME, STRING, __time_to_string)

   267

   268

   269

/******** STRING_TO_[ANY_BIT]   ************/ 

   270

__convert_type(STRING, BOOL, __string_to_bool)

   271

#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_bit)

   272

__ANY_NBIT(__iec_)

   273

#undef __iec_

   274

   275

/******** STRING_TO_[ANY_INT]   ************/ 

   276

#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_sint)

   277

__ANY_SINT(__iec_)

   278

#undef __iec_

   279

#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_uint)

   280

__ANY_UINT(__iec_)

   281

#undef __iec_

   282

   283

/******** STRING_TO_[ANY_REAL]   ************/ 

   284

#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_real)

   285

__ANY_REAL(__iec_)

   286

#undef __iec_

   287

   288

/******** STRING_TO_[ANY_DATE]   ************/ 

   289

#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_time)

   290

__ANY_DATE(__iec_)

   291

#undef __iec_

   292

   293

/******** STRING_TO_TIME   ************/ 

   294

__convert_type(STRING, TIME, __string_to_time)

   295

   296

   297

/********   TRUNC   ************/ 

   298

#define __iec_(to_TYPENAME,from_TYPENAME) \

   299

static inline to_TYPENAME TRUNC__##to_TYPENAME##__##from_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\

   300

  TEST_EN(to_TYPENAME)\

   301

  return (to_TYPENAME)__move_##to_TYPENAME(op);\

   302

}

   303

__ANY_REAL(__to_anyint_)

   304

#undef __iec_

   305

   306

   307

/********   _TO_BCD   ************/

   308

#define __iec_(to_TYPENAME,from_TYPENAME) \

   309

static inline to_TYPENAME from_TYPENAME##_TO_BCD_##to_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\

   310

  TEST_EN(to_TYPENAME)\

   311

  return (to_TYPENAME)__uint_to_bcd(op);\

   312

}\

   313

static inline to_TYPENAME from_TYPENAME##_TO_BCD__##to_TYPENAME##__##from_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\

   314

  return from_TYPENAME##_TO_BCD_##to_TYPENAME(EN_ENO, op);\

   315

}

   316

__ANY_UINT(__to_anynbit_)

   317

#undef __iec_

   318

   319

   320

/********   BCD_TO_   ************/

   321

#define __iec_(to_TYPENAME,from_TYPENAME) \

   322

static inline to_TYPENAME from_TYPENAME##_BCD_TO_##to_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\

   323

  TEST_EN_COND(to_TYPENAME, __test_bcd(op))\

   324

  return (to_TYPENAME)__bcd_to_uint(op);\

   325

}\

   326

static inline to_TYPENAME BCD_TO_##to_TYPENAME##__##to_TYPENAME##__##from_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\

   327

  return from_TYPENAME##_BCD_TO_##to_TYPENAME(EN_ENO, op);\

   328

}

   329

__ANY_NBIT(__to_anyuint_)

   330

#undef __iec_

   331

   332

   333

/***********************************/  

   334

/***********************************/  

   335

/*  2.5.1.5.2 Numerical Functions  */

   336

/***********************************/  

   337

/***********************************/  

   338

   339

/* workaround for va-args limitation on shorter than int params */

   340

#define VA_ARGS_REAL LREAL

   341

#define VA_ARGS_LREAL LREAL

   342

#define VA_ARGS_SINT DINT

   343

#define VA_ARGS_INT DINT

   344

#define VA_ARGS_DINT DINT

   345

#define VA_ARGS_LINT LINT

   346

#define VA_ARGS_USINT UDINT

   347

#define VA_ARGS_UINT UDINT

   348

#define VA_ARGS_UDINT UDINT

   349

#define VA_ARGS_ULINT ULINT

   350

#define VA_ARGS_TIME TIME

   351

#define VA_ARGS_BOOL DWORD

   352

#define VA_ARGS_BYTE DWORD

   353

#define VA_ARGS_WORD DWORD

   354

#define VA_ARGS_DWORD DWORD

   355

#define VA_ARGS_LWORD LWORD

   356

#define VA_ARGS_STRING STRING

   357

#define VA_ARGS_WSTRING WSTRING

   358

#define VA_ARGS_DATE DATE

   359

#define VA_ARGS_TOD TOD

   360

#define VA_ARGS_DT DT

   361

   362

   363

#define __numeric(fname,TYPENAME, FUNC) \

   364

/* explicitly typed function */\

   365

static inline TYPENAME fname##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\

   366

  TEST_EN(TYPENAME)\

   367

  return FUNC(op);\

   368

}\

   369

/* overloaded function */\

   370

static inline TYPENAME fname##_##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op) {\

   371

  return fname##TYPENAME(EN_ENO, op);\

   372

}

   373

   374

/******************************************************************/

   375

/***   Table 23 - Standard functions of one numeric variable    ***/

   376

/******************************************************************/

   377

   378

  /**************/

   379

  /*    ABS     */

   380

  /**************/

   381

#define __abs_signed(TYPENAME) \

   382

/* explicitly typed function */\

   383

static inline TYPENAME ABS_##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\

   384

  TEST_EN(TYPENAME)\

   385

  if (op < 0)\

   386

    return -op;\

   387

  return op;\

   388

}\

   389

/* overloaded function */\

   390

static inline TYPENAME ABS__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op) {\

   391

  return ABS_##TYPENAME(EN_ENO, op);\

   392

}

   393

   394

#define __abs_unsigned(TYPENAME) \

   395

/* explicitly typed function */\

   396

static inline TYPENAME ABS_##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\

   397

  TEST_EN(TYPENAME)\

   398

  return op;\

   399

}\

   400

/* overloaded function */\

   401

static inline TYPENAME ABS__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op) {\

   402

  return ABS_##TYPENAME(EN_ENO, op);\

   403

}

   404

   405

__ANY_REAL(__abs_signed)

   406

__ANY_SINT(__abs_signed)

   407

__ANY_UINT(__abs_unsigned)

   408

   409

   410

  /**************/

   411

  /*    SQRT    */

   412

  /**************/

   413

#define __sqrt(TYPENAME) __numeric(SQRT_, TYPENAME, sqrt)

   414

__ANY_REAL(__sqrt)

   415

   416

   417

/**************/

   418

  /*     LN     */

   419

  /**************/

   420

#define __ln(TYPENAME) __numeric(LN_, TYPENAME, log)

   421

__ANY_REAL(__ln)

   422

   423

   424

  /**************/

   425

  /*     LOG    */

   426

  /**************/

   427

#define __log(TYPENAME) __numeric(LOG_, TYPENAME, log10)

   428

__ANY_REAL(__log)

   429

   430

   431

  /**************/

   432

  /*     EXP    */

   433

  /**************/

   434

#define __exp(TYPENAME) __numeric(EXP_, TYPENAME, exp)

   435

__ANY_REAL(__exp)

   436

   437

   438

  /**************/

   439

  /*     SIN    */

   440

  /**************/

   441

#define __sin(TYPENAME) __numeric(SIN_, TYPENAME, sin)

   442

__ANY_REAL(__sin)

   443

   444

   445

  /**************/

   446

  /*     COS    */

   447

  /**************/

   448

#define __cos(TYPENAME) __numeric(COS_, TYPENAME, cos)

   449

__ANY_REAL(__cos)

   450

   451

  /**************/

   452

  /*     TAN    */

   453

  /**************/

   454

#define __tan(TYPENAME) __numeric(TAN_, TYPENAME, tan)

   455

__ANY_REAL(__tan)

   456

   457

   458

  /**************/

   459

  /*    ASIN    */

   460

  /**************/

   461

#define __asin(TYPENAME) __numeric(ASIN_, TYPENAME, asin)

   462

__ANY_REAL(__asin)

   463

   464

  /**************/

   465

  /*    ACOS    */

   466

  /**************/

   467

#define __acos(TYPENAME) __numeric(ACOS_, TYPENAME, acos)

   468

__ANY_REAL(__acos)

   469

   470

  /**************/

   471

  /*    ATAN    */

   472

  /**************/

   473

#define __atan(TYPENAME) __numeric(ATAN_, TYPENAME, atan)

   474

__ANY_REAL(__atan)

   475

   476

   477

   478

/*****************************************************/

   479

/***   Table 24 - Standard arithmetic functions    ***/

   480

/*****************************************************/

   481

   482

#define __arith_expand(fname,TYPENAME, OP)\

   483

static inline TYPENAME fname(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\

   484

  va_list ap;\

   485

  UINT i;\

   486

  TEST_EN(TYPENAME)\

   487

  \

   488

  va_start (ap, op1);         /* Initialize the argument list.  */\

   489

  \

   490

  for (i = 0; i < param_count - 1; i++){\

   491

    op1 = op1 OP va_arg (ap, VA_ARGS_##TYPENAME);\

   492

  }\

   493

  \