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

#ifdef DISABLE_EN_ENO_PARAMETERS

    86

    87

  /* Do _not_ generate the EN and ENO parameters! */

    88

  #define EN_ENO_PARAMS

    89

  #define EN_ENO

    90

    91

  #define TEST_EN(TYPENAME)

    92

  #define TEST_EN_COND(TYPENAME, COND)

    93

    94

#else

    95

    96

  /* _Do_ generate the EN and ENO parameters! */

    97

  #define EN_ENO_PARAMS BOOL EN, BOOL *ENO,

    98

  #define EN_ENO EN, ENO,

    99

   100

  #define TEST_EN(TYPENAME)\

   101

    if (!EN) {\

   102

      if (ENO != NULL)\

   103

        *ENO = __BOOL_LITERAL(FALSE);\

   104

      return __INIT_##TYPENAME;\

   105

    }\

   106

    else if (ENO != NULL)\

   107

      *ENO = __BOOL_LITERAL(TRUE);

   108

   109

  #define TEST_EN_COND(TYPENAME, COND)\

   110

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

   111

      if (ENO != NULL)\

   112

        *ENO = __BOOL_LITERAL(FALSE);\

   113

      return __INIT_##TYPENAME;\

   114

    }\

   115

    else if (ENO != NULL)\

   116

      *ENO = __BOOL_LITERAL(TRUE);

   117

   118

#endif

   119

   120

   121

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

   122

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

   123

/*  2.5.1.5.1 Type Conversion Functions  */

   124

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

   125

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

   126

   127

#define __convert_type(from_TYPENAME,to_TYPENAME, oper) \

   128

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

   129

  TEST_EN(to_TYPENAME)\

   130

  return (to_TYPENAME)oper(op);\

   131

}

   132

   133

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

   134

#define __convert_num_to_bool(TYPENAME) \

   135

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

   136

  TEST_EN(BOOL)\

   137

  return op == 0 ? 0 : 1;\

   138

}

   139

__ANY_NUM(__convert_num_to_bool)

   140

__ANY_NBIT(__convert_num_to_bool)

   141

   142

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

   143

#define __convert_time_to_bool(TYPENAME) \

   144

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

   145

  TEST_EN(BOOL)\

   146

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

   147

}

   148

__convert_time_to_bool(TIME)

   149

__ANY_DATE(__convert_time_to_bool)

   150

   151

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

   152

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

   153

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

   154

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

   155

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

   156

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

   157

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

   158

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

   159

   160

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

   161

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

   162

__ANY_BIT(__to_anynum_)

   163

__ANY_BIT(__to_anynbit_)

   164

#undef __iec_

   165

   166

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

   167

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

   168

__ANY_INT(__to_anynum_)

   169

__ANY_INT(__to_anynbit_)

   170

#undef __iec_

   171

   172

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

   173

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

   174

__ANY_REAL(__to_anynbit_)

   175

#undef __iec_

   176

   177

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

   178

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

   179

__ANY_REAL(__to_anysint_)

   180

#undef __iec_

   181

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

   182

__ANY_REAL(__to_anyuint_)

   183

#undef __iec_

   184

   185

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

   186

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

   187

__ANY_REAL(__to_anyreal_)

   188

#undef __iec_

   189

   190

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

   191

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

   192

__ANY_BIT(__iec_)

   193

__ANY_INT(__iec_)

   194

#undef __iec_

   195

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

   196

__ANY_BIT(__to_anydate_)

   197

__ANY_INT(__to_anydate_)

   198

#undef __iec_

   199

   200

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

   201

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

   202

__ANY_REAL(__iec_)

   203

#undef __iec_

   204

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

   205

__ANY_REAL(__to_anydate_)

   206

#undef __iec_

   207

   208

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

   209

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

   210

__to_anyint_(TIME)

   211

__to_anynbit_(TIME)

   212

__ANY_DATE(__to_anyint_)

   213

__ANY_DATE(__to_anynbit_)

   214

#undef __iec_

   215

   216

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

   217

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

   218

__to_anyreal_(TIME)

   219

__ANY_DATE(__to_anyreal_)

   220

#undef __iec_

   221

   222

   223

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

   224

/* Not supported: DT_TO_TIME */

   225

__convert_type(DT, DATE,  __date_and_time_to_date)

   226

static inline DATE DATE_AND_TIME_TO_DATE(EN_ENO_PARAMS DT op){

   227

	return DT_TO_DATE(EN_ENO op);

   228

}

   229

__convert_type(DT, DT,    __move_DT)

   230

__convert_type(DT, TOD,   __date_and_time_to_time_of_day)

   231

static inline DATE DATE_AND_TIME_TO_TIME_OF_DAY(EN_ENO_PARAMS DT op){

   232

	return DT_TO_TOD(EN_ENO op);

   233

}

   234

/* Not supported: DATE_TO_TIME */

   235

__convert_type(DATE, DATE, __move_DATE)

   236

/* Not supported: DATE_TO_DT */

   237

/* Not supported: DATE_TO_TOD */

   238

/* Not supported: TOD_TO_TIME */

   239

/* Not supported: TOD_TO_DATE */

   240

/* Not supported: TOD_TO_DT */

   241

__convert_type(TOD, TOD, __move_TOD)

   242

   243

   244

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

   245

/* Not supported: TIME_TO_DATE */

   246

/* Not supported: TIME_TO_DT */

   247

/* Not supported: TIME_TO_TOD */

   248

   249

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

   250

__convert_type(TIME, TIME, __move_TIME)

   251

   252

   253

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

   254

__convert_type(BOOL, STRING, __bool_to_string)

   255

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

   256

__ANY_NBIT(__iec_)

   257

#undef __iec_

   258

   259

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

   260

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

   261

__ANY_SINT(__iec_)

   262

#undef __iec_

   263

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

   264

__ANY_UINT(__iec_)

   265

#undef __iec_

   266

   267

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

   268

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

   269

__ANY_REAL(__iec_)

   270

#undef __iec_

   271

   272

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

   273

__convert_type(DATE, STRING, __date_to_string)

   274

__convert_type(DT,   STRING, __dt_to_string)

   275

__convert_type(TOD,  STRING, __tod_to_string)

   276

   277

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

   278

__convert_type(TIME, STRING, __time_to_string)

   279

   280

   281

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

   282

__convert_type(STRING, BOOL, __string_to_bool)

   283

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

   284

__ANY_NBIT(__iec_)

   285

#undef __iec_

   286

   287

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

   288

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

   289

__ANY_SINT(__iec_)

   290

#undef __iec_

   291

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

   292

__ANY_UINT(__iec_)

   293

#undef __iec_

   294

   295

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

   296

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

   297

__ANY_REAL(__iec_)

   298

#undef __iec_

   299

   300

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

   301

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

   302

__ANY_DATE(__iec_)

   303

#undef __iec_

   304

   305

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

   306

__convert_type(STRING, TIME, __string_to_time)

   307

   308

   309

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

   310

#define __iec_(to_TYPENAME,from_TYPENAME) \

   311

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

   312

  TEST_EN(to_TYPENAME)\

   313

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

   314

}

   315

__ANY_REAL(__to_anyint_)

   316

#undef __iec_

   317

   318

   319

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

   320

#define __iec_(to_TYPENAME,from_TYPENAME) \

   321

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

   322

  TEST_EN(to_TYPENAME)\

   323

  return (to_TYPENAME)__uint_to_bcd(op);\

   324

}\

   325

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

   326

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

   327

}

   328

__ANY_UINT(__to_anynbit_)

   329

#undef __iec_

   330

   331

   332

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

   333

#define __iec_(to_TYPENAME,from_TYPENAME) \

   334

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

   335

  TEST_EN_COND(to_TYPENAME, __test_bcd(op))\

   336

  return (to_TYPENAME)__bcd_to_uint(op);\

   337

}\

   338

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

   339

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

   340

}

   341

__ANY_NBIT(__to_anyuint_)

   342

#undef __iec_

   343

   344

   345

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

   346

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

   347

/*  2.5.1.5.2 Numerical Functions  */

   348

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

   349

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

   350

   351

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

   352

#define VA_ARGS_REAL LREAL

   353

#define VA_ARGS_LREAL LREAL

   354

#define VA_ARGS_SINT DINT

   355

#define VA_ARGS_INT DINT

   356

#define VA_ARGS_DINT DINT

   357

#define VA_ARGS_LINT LINT

   358

#define VA_ARGS_USINT UDINT

   359

#define VA_ARGS_UINT UDINT

   360

#define VA_ARGS_UDINT UDINT

   361

#define VA_ARGS_ULINT ULINT

   362

#define VA_ARGS_TIME TIME

   363

#define VA_ARGS_BOOL DWORD

   364

#define VA_ARGS_BYTE DWORD

   365

#define VA_ARGS_WORD DWORD

   366

#define VA_ARGS_DWORD DWORD

   367

#define VA_ARGS_LWORD LWORD

   368

#define VA_ARGS_STRING STRING

   369

#define VA_ARGS_WSTRING WSTRING

   370

#define VA_ARGS_DATE DATE

   371

#define VA_ARGS_TOD TOD

   372

#define VA_ARGS_DT DT

   373

   374

   375

#define __numeric(fname,TYPENAME, FUNC) \

   376

/* explicitly typed function */\

   377

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

   378

  TEST_EN(TYPENAME)\

   379

  return FUNC(op);\

   380

}\

   381

/* overloaded function */\

   382

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

   383

  return fname##TYPENAME(EN_ENO op);\

   384

}

   385

   386

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

   387

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

   388

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

   389

   390

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

   391

  /*    ABS     */

   392

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

   393

#define __abs_signed(TYPENAME) \

   394

/* explicitly typed function */\

   395

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

   396

  TEST_EN(TYPENAME)\

   397

  if (op < 0)\

   398

    return -op;\

   399

  return op;\

   400

}\

   401

/* overloaded function */\

   402

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

   403

  return ABS_##TYPENAME(EN_ENO op);\

   404

}

   405

   406

#define __abs_unsigned(TYPENAME) \

   407

/* explicitly typed function */\

   408

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

   409

  TEST_EN(TYPENAME)\

   410

  return op;\

   411

}\

   412

/* overloaded function */\

   413

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

   414

  return ABS_##TYPENAME(EN_ENO op);\

   415

}

   416

   417

__ANY_REAL(__abs_signed)

   418

__ANY_SINT(__abs_signed)

   419

__ANY_UINT(__abs_unsigned)

   420

   421

   422

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

   423

  /*    SQRT    */

   424

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

   425

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

   426

__ANY_REAL(__sqrt)

   427

   428

   429

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

   430

  /*     LN     */

   431

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

   432

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

   433

__ANY_REAL(__ln)

   434

   435

   436

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

   437

  /*     LOG    */

   438

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

   439

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

   440

__ANY_REAL(__log)

   441

   442

   443

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

   444

  /*     EXP    */

   445

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

   446

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

   447

__ANY_REAL(__exp)

   448

   449

   450

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

   451

  /*     SIN    */

   452

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

   453

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

   454

__ANY_REAL(__sin)

   455

   456

   457

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

   458

  /*     COS    */

   459

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

   460

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

   461

__ANY_REAL(__cos)

   462

   463

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

   464

  /*     TAN    */

   465

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

   466

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

   467

__ANY_REAL(__tan)

   468

   469

   470

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

   471

  /*    ASIN    */

   472

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

   473

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

   474

__ANY_REAL(__asin)

   475

   476

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

   477

  /*    ACOS    */

   478

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

   479

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

   480

__ANY_REAL(__acos)

   481

   482

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

   483

  /*    ATAN    */

   484

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

   485

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

   486

__ANY_REAL(__atan)

   487

   488

   489

   490

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

   491

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

   492