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

    91

    92

  #define TEST_EN(TYPENAME)

    93

  #define TEST_EN_COND(TYPENAME, COND)

    94

    95

#else

    96

    97

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

    98

  #define EN_ENO_PARAMS BOOL EN, BOOL *ENO,

    99

  #define EN_ENO EN, ENO,

   101

   102

  #define TEST_EN(TYPENAME)\

   103

    if (!EN) {\

   104

      if (ENO != NULL)\

   105

        *ENO = __BOOL_LITERAL(FALSE);\

   106

      return __INIT_##TYPENAME;\

   107

    }\

   108

    else if (ENO != NULL)\

   109

      *ENO = __BOOL_LITERAL(TRUE);

   110

   111

  #define TEST_EN_COND(TYPENAME, COND)\

   112

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

   113

      if (ENO != NULL)\

   114

        *ENO = __BOOL_LITERAL(FALSE);\

   115

      return __INIT_##TYPENAME;\

   116

    }\

   117

    else if (ENO != NULL)\

   118

      *ENO = __BOOL_LITERAL(TRUE);

   119

   120

#endif

   121

   122

   123

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

   124

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

   125

/*  2.5.1.5.1 Type Conversion Functions  */

   126

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

   127

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

   128

   129

#define __convert_type(from_TYPENAME,to_TYPENAME, oper) \

   130

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

   131

  TEST_EN(to_TYPENAME)\

   132

  return (to_TYPENAME)oper(op);\

   133

}

   134

   135

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

   136

#define __convert_num_to_bool(TYPENAME) \

   137

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

   138

  TEST_EN(BOOL)\

   139

  return op == 0 ? 0 : 1;\

   140

}

   141

__ANY_NUM(__convert_num_to_bool)

   142

__ANY_NBIT(__convert_num_to_bool)

   143

   144

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

   145

#define __convert_time_to_bool(TYPENAME) \

   146

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

   147

  TEST_EN(BOOL)\

   148

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

   149

}

   150

__convert_time_to_bool(TIME)

   151

__ANY_DATE(__convert_time_to_bool)

   152

   153

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

   154

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

   155

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

   156

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

   157

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

   158

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

   159

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

   160

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

   161

   162

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

   163

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

   164

__ANY_BIT(__to_anynum_)

   165

__ANY_BIT(__to_anynbit_)

   166

#undef __iec_

   167

   168

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

   169

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

   170

__ANY_INT(__to_anynum_)

   171

__ANY_INT(__to_anynbit_)

   172

#undef __iec_

   173

   174

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

   175

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

   176

__ANY_REAL(__to_anynbit_)

   177

#undef __iec_

   178

   179

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

   180

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

   181

__ANY_REAL(__to_anysint_)

   182

#undef __iec_

   183

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

   184

__ANY_REAL(__to_anyuint_)

   185

#undef __iec_

   186

   187

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

   188

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

   189

__ANY_REAL(__to_anyreal_)

   190

#undef __iec_

   191

   192

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

   193

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

   194

__ANY_BIT(__iec_)

   195

__ANY_INT(__iec_)

   196

#undef __iec_

   197

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

   198

__ANY_BIT(__to_anydate_)

   199

__ANY_INT(__to_anydate_)

   200

#undef __iec_

   201

   202

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

   203

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

   204

__ANY_REAL(__iec_)

   205

#undef __iec_

   206

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

   207

__ANY_REAL(__to_anydate_)

   208

#undef __iec_

   209

   210

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

   211

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

   212

__to_anyint_(TIME)

   213

__to_anynbit_(TIME)

   214

__ANY_DATE(__to_anyint_)

   215

__ANY_DATE(__to_anynbit_)

   216

#undef __iec_

   217

   218

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

   219

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

   220

__to_anyreal_(TIME)

   221

__ANY_DATE(__to_anyreal_)

   222

#undef __iec_

   223

   224

   225

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

   226

/* Not supported: DT_TO_TIME */

   227

__convert_type(DT, DATE,  __date_and_time_to_date)

   228

static inline DATE DATE_AND_TIME_TO_DATE(EN_ENO_PARAMS DT op){

   229

	return DT_TO_DATE(EN_ENO op);

   230

}

   231

__convert_type(DT, DT,    __move_DT)

   232

__convert_type(DT, TOD,   __date_and_time_to_time_of_day)

   233

static inline DATE DATE_AND_TIME_TO_TIME_OF_DAY(EN_ENO_PARAMS DT op){

   234

	return DT_TO_TOD(EN_ENO op);

   235

}

   236

/* Not supported: DATE_TO_TIME */

   237

__convert_type(DATE, DATE, __move_DATE)

   238

/* Not supported: DATE_TO_DT */

   239

/* Not supported: DATE_TO_TOD */

   240

/* Not supported: TOD_TO_TIME */

   241

/* Not supported: TOD_TO_DATE */

   242

/* Not supported: TOD_TO_DT */

   243

__convert_type(TOD, TOD, __move_TOD)

   244

   245

   246

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

   247

/* Not supported: TIME_TO_DATE */

   248

/* Not supported: TIME_TO_DT */

   249

/* Not supported: TIME_TO_TOD */

   250

   251

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

   252

__convert_type(TIME, TIME, __move_TIME)

   253

   254

   255

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

   256

__convert_type(BOOL, STRING, __bool_to_string)

   257

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

   258

__ANY_NBIT(__iec_)

   259

#undef __iec_

   260

   261

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

   262

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

   263

__ANY_SINT(__iec_)

   264

#undef __iec_

   265

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

   266

__ANY_UINT(__iec_)

   267

#undef __iec_

   268

   269

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

   270

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

   271

__ANY_REAL(__iec_)

   272

#undef __iec_

   273

   274

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

   275

__convert_type(DATE, STRING, __date_to_string)

   276

__convert_type(DT,   STRING, __dt_to_string)

   277

__convert_type(TOD,  STRING, __tod_to_string)

   278

   279

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

   280

__convert_type(TIME, STRING, __time_to_string)

   281

   282

   283

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

   284

__convert_type(STRING, BOOL, __string_to_bool)

   285

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

   286

__ANY_NBIT(__iec_)

   287

#undef __iec_

   288

   289

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

   290

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

   291

__ANY_SINT(__iec_)

   292

#undef __iec_

   293

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

   294

__ANY_UINT(__iec_)

   295

#undef __iec_

   296

   297

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

   298

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

   299

__ANY_REAL(__iec_)

   300

#undef __iec_

   301

   302

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

   303

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

   304

__ANY_DATE(__iec_)

   305

#undef __iec_

   306

   307

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

   308

__convert_type(STRING, TIME, __string_to_time)

   309

   310

   311

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

   312

#define __iec_(to_TYPENAME,from_TYPENAME) \

   313

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

   314

  TEST_EN(to_TYPENAME)\

   315

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

   316

}

   317

__ANY_REAL(__to_anyint_)

   318

#undef __iec_

   319

   320

   321

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

   322

#define __iec_(to_TYPENAME,from_TYPENAME) \

   323

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

   324

  TEST_EN(to_TYPENAME)\

   325

  return (to_TYPENAME)__uint_to_bcd(op);\

   326

}\

   327

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

   328

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

   329

}

   330

__ANY_UINT(__to_anynbit_)

   331

#undef __iec_

   332

   333

   334

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

   335

#define __iec_(to_TYPENAME,from_TYPENAME) \

   336

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

   337

  TEST_EN_COND(to_TYPENAME, __test_bcd(op))\

   338

  return (to_TYPENAME)__bcd_to_uint(op);\

   339

}\

   340

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

   341

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

   342

}

   343

__ANY_NBIT(__to_anyuint_)

   344

#undef __iec_

   345

   346

   347

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

   348

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

   349

/*  2.5.1.5.2 Numerical Functions  */

   350

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

   351

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

   352

   353

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

   354

#define VA_ARGS_REAL LREAL

   355

#define VA_ARGS_LREAL LREAL

   356

#define VA_ARGS_SINT DINT

   357

#define VA_ARGS_INT DINT

   358

#define VA_ARGS_DINT DINT

   359

#define VA_ARGS_LINT LINT

   360

#define VA_ARGS_USINT UDINT

   361

#define VA_ARGS_UINT UDINT

   362

#define VA_ARGS_UDINT UDINT

   363

#define VA_ARGS_ULINT ULINT

   364

#define VA_ARGS_TIME TIME

   365

#define VA_ARGS_BOOL DWORD

   366

#define VA_ARGS_BYTE DWORD

   367

#define VA_ARGS_WORD DWORD

   368

#define VA_ARGS_DWORD DWORD

   369

#define VA_ARGS_LWORD LWORD

   370

#define VA_ARGS_STRING STRING

   371

#define VA_ARGS_WSTRING WSTRING

   372

#define VA_ARGS_DATE DATE

   373

#define VA_ARGS_TOD TOD

   374

#define VA_ARGS_DT DT

   375

   376

   377

#define __numeric(fname,TYPENAME, FUNC) \

   378

/* explicitly typed function */\

   379

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

   380

  TEST_EN(TYPENAME)\

   381

  return FUNC(op);\

   382

}\

   383

/* overloaded function */\

   384

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

   385

  return fname##TYPENAME(EN_ENO op);\

   386

}

   387

   388

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

   389

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

   390

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

   391

   392

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

   393

  /*    ABS     */

   394

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

   395

#define __abs_signed(TYPENAME) \

   396

/* explicitly typed function */\

   397

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

   398

  TEST_EN(TYPENAME)\

   399

  if (op < 0)\

   400

    return -op;\

   401

  return op;\

   402

}\

   403

/* overloaded function */\

   404

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

   405

  return ABS_##TYPENAME(EN_ENO op);\

   406

}

   407

   408

#define __abs_unsigned(TYPENAME) \

   409

/* explicitly typed function */\

   410

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

   411

  TEST_EN(TYPENAME)\

   412

  return op;\

   413

}\

   414

/* overloaded function */\

   415

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

   416

  return ABS_##TYPENAME(EN_ENO op);\

   417

}

   418

   419

__ANY_REAL(__abs_signed)

   420

__ANY_SINT(__abs_signed)

   421

__ANY_UINT(__abs_unsigned)

   422

   423

   424

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

   425

  /*    SQRT    */

   426

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

   427

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

   428

__ANY_REAL(__sqrt)

   429

   430

   431

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

   432

  /*     LN     */

   433

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

   434

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

   435

__ANY_REAL(__ln)

   436

   437

   438

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

   439

  /*     LOG    */

   440

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

   441

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

   442

__ANY_REAL(__log)

   443

   444

   445

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

   446

  /*     EXP    */

   447

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

   448

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

   449

__ANY_REAL(__exp)

   450

   451

   452

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

   453

  /*     SIN    */

   454

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

   455

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

   456

__ANY_REAL(__sin)

   457

   458

   459

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

   460

  /*     COS    */

   461

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

   462

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

   463

__ANY_REAL(__cos)

   464

   465

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

   466

  /*     TAN    */

   467

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

   468

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

   469

__ANY_REAL(__tan)

   470

   471

   472

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

   473

  /*    ASIN    */

   474

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

   475

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

   476

__ANY_REAL(__asin)

   477

   478

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

   479

  /*    ACOS    */

   480

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

   481

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

   482

__ANY_REAL(__acos)

   483

   484

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

   485

  /*    ATAN    */

   486

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

   487

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

   488

__ANY_REAL(__atan)

   489

   490

   491

   492

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