1

#!/bin/sh 

     2

#

     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

echo "(************************************************)"

    19

echo "(************************************************)"

    20

echo "(***                                          ***)"

    21

echo "(***    The IEC 61131-3 standard functions    ***)"

    22

echo "(***                                          ***)"

    23

echo "(***    Auto-generated file. Do not edit!     ***)"

    24

echo "(***                                          ***)"

    25

echo "(************************************************)"

    26

echo "(************************************************)"

    27

    28

    29

echo "{disable code generation}"

    30

    31

# Lets parse this file with the C pre-processor!

    32

#cpp <<"END" | sed "s/ FUNCTION/\nFUNCTION/g" | grep -v '#'

    33

# We usee gcc -E instead, as it seems cpp on OSX works differently! However, it needs an input file parameter...

    34

#gcc -E <<"END" | sed "s/ FUNCTION/\nFUNCTION/g" | grep -v '#'

    35

cpp <<"END" | sed "s/ FUNCTION/\nFUNCTION/g" | grep -v '#'

    36

    37

#define __DEFINE_CLASHING_FUNCTIONS 

    38

    39

/* Macro that expand to subtypes */

    40

#define __ANY(DO)                 __ANY_DERIVED(DO) __ANY_ELEMENTARY(DO)

    41

#define __ANY_DERIVED(DO)

    42

#define __ANY_ELEMENTARY(DO)      __ANY_MAGNITUDE(DO) __ANY_BIT(DO) __ANY_STRING(DO) __ANY_DATE(DO)

    43

#define __ANY_MAGNITUDE(DO)       __ANY_NUM(DO) DO(TIME)

    44

#define __ANY_BIT(DO)             __ANY_NBIT(DO) DO(BOOL)

    45

#define __ANY_NBIT(DO)            DO(BYTE) DO(WORD) DO(DWORD) DO(LWORD)

    46

#define __ANY_STRING(DO)          DO(STRING)

    47

#define __ANY_DATE(DO)            DO(DATE) DO(TOD) DO(DT)

    48

#define __ANY_NUM(DO)             __ANY_REAL(DO) __ANY_INT(DO)

    49

#define __ANY_REAL(DO)            DO(REAL) DO(LREAL)

    50

#define __ANY_INT(DO)             __ANY_SINT(DO) __ANY_UINT(DO)

    51

#define __ANY_SINT(DO)            DO(SINT) DO(INT) DO(DINT) DO(LINT)

    52

#define __ANY_UINT(DO)            DO(USINT) DO(UINT) DO(UDINT) DO(ULINT)

    53

    54

#define __ANY_1(DO,P1)            __ANY_DERIVED_1(DO,P1) __ANY_ELEMENTARY_1(DO,P1)

    55

#define __ANY_DERIVED_1(DO,P1)

    56

#define __ANY_ELEMENTARY_1(DO,P1) __ANY_MAGNITUDE_1(DO,P1) __ANY_BIT_1(DO,P1) __ANY_STRING_1(DO,P1) __ANY_DATE_1(DO,P1)

    57

#define __ANY_MAGNITUDE_1(DO,P1)  __ANY_NUM_1(DO,P1) DO(TIME,P1)

    58

#define __ANY_BIT_1(DO,P1)        __ANY_NBIT_1(DO,P1) DO(BOOL,P1)

    59

#define __ANY_NBIT_1(DO,P1)       DO(BYTE,P1) DO(WORD,P1) DO(DWORD,P1) DO(LWORD,P1)

    60

#define __ANY_STRING_1(DO,P1)     DO(STRING,P1)

    61

#define __ANY_DATE_1(DO,P1)       DO(DATE,P1) DO(TOD,P1) DO(DT,P1)

    62

#define __ANY_NUM_1(DO,P1)        __ANY_REAL_1(DO,P1) __ANY_INT_1(DO,P1)

    63

#define __ANY_REAL_1(DO,P1)       DO(REAL,P1) DO(LREAL,P1)

    64

#define __ANY_INT_1(DO,P1)        __ANY_SINT_1(DO,P1) __ANY_UINT_1(DO,P1)

    65

#define __ANY_SINT_1(DO,P1)       DO(SINT,P1) DO(INT,P1) DO(DINT,P1) DO(LINT,P1)

    66

#define __ANY_UINT_1(DO,P1)       DO(USINT,P1) DO(UINT,P1) DO(UDINT,P1) DO(ULINT,P1)

    67

    68

    69

    70

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

    71

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

    72

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

    73

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

    74

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

    75

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

    76

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

    77

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

    78

    79

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

    80

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

    81

 *       We do not declare/define the overloaded functions

    82

 *       (SIN, ADD, ...). 

    83

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

    84

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

    85

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

    86

 *       typed standard function.

    87

 */

    88

    89

/* NOTE on explicit typing of:

    90

 *           - Table 25 - Standard bit shift functions

    91

 *           - Table 29 - Character string Functions

    92

 *           - Table 27 - Standard selection functions (actually, just the MUX function)

    93

 *

    94

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

    95

 *  of the standard, it is stated:

    96

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

    97

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

    98

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

    99

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

   100

 * [...]

   101

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

   102

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

   103

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

   104

 * shown in table 21."

   105

 *

   106

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

   107

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

   108

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

   109

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

   110

 *

   111

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

   112

 */

   113

   114

   115

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

   116

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

   117

/*  2.5.1.5.1 Type Conversion Functions  */

   118

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

   119

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

   120

   121

/* macros for non-extensible functions */

   122

#define __function_1p(fname,to_TYPENAME,p1_NAME,p1_TYPENAME) \

   123

FUNCTION fname : to_TYPENAME\

   124

  VAR_INPUT p1_NAME : p1_TYPENAME; END_VAR\

   125

  RETURN; \

   126

END_FUNCTION\

   127

   128

#define __function_2p(fname,to_TYPENAME,p1_NAME,p1_TYPENAME,p2_NAME,p2_TYPENAME) \

   129

FUNCTION fname : to_TYPENAME\

   130

  VAR_INPUT p1_NAME : p1_TYPENAME; p2_NAME : p2_TYPENAME; END_VAR\

   131

  RETURN; \

   132

END_FUNCTION\

   133

   134

#define __function_3p(fname,to_TYPENAME,p1_NAME,p1_TYPENAME,p2_NAME,p2_TYPENAME,p3_NAME,p3_TYPENAME) \

   135

FUNCTION fname : to_TYPENAME\

   136

  VAR_INPUT p1_NAME : p1_TYPENAME; p2_NAME : p2_TYPENAME; p3_NAME : p3_TYPENAME; END_VAR\

   137

  RETURN; \

   138

END_FUNCTION\

   139

   140

#define __function_4p(fname,to_TYPENAME,p1_NAME,p1_TYPENAME,p2_NAME,p2_TYPENAME,p3_NAME,p3_TYPENAME,p4_NAME,p4_TYPENAME) \

   141

FUNCTION fname : to_TYPENAME\

   142

  VAR_INPUT p1_NAME : p1_TYPENAME; p2_NAME : p2_TYPENAME; p3_NAME : p3_TYPENAME; p4_NAME : p4_TYPENAME; END_VAR\

   143

  RETURN; \

   144

END_FUNCTION\

   145

   146

   147

/* macro for extensible functions */

   148

#define __function_1e(fname,to_TYPENAME,p1_NAME,p1_TYPENAME, FIRST_INDEX) \

   149

FUNCTION fname : to_TYPENAME\

   150

  VAR_INPUT p1_NAME FIRST_INDEX .. : p1_TYPENAME; END_VAR\

   151

  RETURN; \

   152

END_FUNCTION\

   153

   154

#define __function_2e(fname,to_TYPENAME,p1_NAME,p1_TYPENAME,p2_NAME,p2_TYPENAME, FIRST_INDEX) \

   155

FUNCTION fname : to_TYPENAME\

   156

  VAR_INPUT p1_NAME : p1_TYPENAME; p2_NAME FIRST_INDEX .. : p2_TYPENAME; END_VAR\

   157

  RETURN; \

   158

END_FUNCTION\

   159

   160

   161

   162

   163

   164

   165

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

   166

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

   167

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

   168

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

   169

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

   170

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

   171

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

   172

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

   173

#define __to_time_(from_TYPENAME)    __iec_(TIME,from_TYPENAME)

   174

#define __to_string_(from_TYPENAME)  __iec_(STRING,from_TYPENAME)

   175

   176

   177

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

   178

/*   *_TO_**     */

   179

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

   180

#define __iec_(to_TYPENAME,from_TYPENAME) __function_1p(from_TYPENAME##_TO_##to_TYPENAME, to_TYPENAME, IN, from_TYPENAME)

   181

   182

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

   183

__ANY_BIT(__to_anynum_)

   184

__ANY_BIT(__to_anybit_)

   185

   186

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

   187

__ANY_NUM(__to_anynum_)

   188

__ANY_NUM(__to_anybit_)

   189

   190

   191

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

   192

__ANY_BIT(__to_time_)

   193

__ANY_NUM(__to_time_)

   194

__ANY_BIT(__to_anydate_)

   195

__ANY_NUM(__to_anydate_)

   196

   197

   198

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

   199

__to_anynum_(TIME)

   200

__to_anybit_(TIME)

   201

__ANY_DATE(__to_anynum_)

   202

__ANY_DATE(__to_anybit_)

   203

   204

   205

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

   206

/* Not supported: DT_TO_TIME */

   207

/*__iec_(to_TYPENAME,from_TYPENAME)*/

   208

__iec_(DATE,DT)

   209

__iec_(DT,DT)

   210

__iec_(TOD,DT)

   211

/* Not supported: DATE_TO_TIME */

   212

__iec_(DATE,DATE)

   213

/* Not supported: DATE_TO_DT */

   214

/* Not supported: DATE_TO_TOD */

   215

/* Not supported: TOD_TO_TIME */

   216

/* Not supported: TOD_TO_DATE */

   217

/* Not supported: TOD_TO_DT */

   218

__iec_(TOD,TOD)

   219

   220

   221

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

   222

/* Not supported: TIME_TO_DATE */

   223

/* Not supported: TIME_TO_DT */

   224

/* Not supported: TIME_TO_TOD */

   225

   226

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

   227

__iec_(TIME,TIME)

   228

   229

   230

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

   231

__ANY_BIT(__to_string_)

   232

   233

   234

/******** [ANY_NUM]_TO_STRING   ************/ 

   235

__ANY_NUM(__to_string_)

   236

   237

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

   238

__ANY_DATE(__to_string_)

   239

   240

   241

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

   242

__iec_(STRING,TIME)

   243

   244

   245

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

   246

__to_anybit_(STRING)

   247

   248

   249

/******** STRING_TO_[ANY_NUM]   ************/ 

   250

__to_anynum_(STRING)

   251

   252

   253

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

   254

__to_anydate_(STRING)

   255

   256

   257

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

   258

__iec_(TIME,STRING)

   259

   260

#undef __iec_

   261

   262

   263

   264

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

   265

/*   TRUNC    */

   266

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

   267

/* overloaded function! */

   268

#define __iec_(to_TYPENAME,from_TYPENAME) __function_1p(TRUNC, to_TYPENAME, IN, from_TYPENAME)

   269

__ANY_REAL(__to_anyint_)

   270

#undef __iec_

   271

   272

   273

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

   274

/*   *_TO_BCD_*    */

   275

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

   279

__ANY_UINT(__to_anynbit_)

   280

#undef __iec_

   281

   282

   283

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

   284

/*   *_BCD_TO_*    */

   285

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

   290

__ANY_NBIT(__to_anyuint_)

   291

#undef __iec_

   292

   293

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

   294

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

   295

/*  2.5.1.5.2 Numerical Functions  */

   296

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

   297

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

   298

   299

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

   300

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

   301

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

   302

   303

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

   304

  /*    ABS     */

   305

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

   306

#define __iec_(TYPENAME) \

   307

__function_1p(ABS_##TYPENAME, TYPENAME, IN, TYPENAME)  /* explicitly typed function */\

   308

__function_1p(ABS, TYPENAME, IN, TYPENAME)             /* overloaded function */ 

   309

__ANY_REAL(__iec_)

   310

__ANY_INT(__iec_)

   311

#undef __iec_

   312

   313

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

   314

  /*    SQRT    */

   315

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

   316

#define __iec_(TYPENAME) \

   317

__function_1p(SQRT_##TYPENAME, TYPENAME, IN, TYPENAME)  /* explicitly typed function */\

   318

__function_1p(SQRT, TYPENAME, IN, TYPENAME)             /* overloaded function */ 

   319

__ANY_REAL(__iec_)

   320

#undef __iec_

   321

   322

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

   323

  /*     LN     */

   324

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

   325

#define __iec_(TYPENAME) \

   326

__function_1p(LN_##TYPENAME, TYPENAME, IN, TYPENAME)  /* explicitly typed function */\

   327

__function_1p(LN, TYPENAME, IN, TYPENAME)             /* overloaded function */ 

   328

__ANY_REAL(__iec_)

   329

#undef __iec_

   330

   331

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

   332

  /*     LOG    */

   333

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

   334

#define __iec_(TYPENAME) \

   335

__function_1p(LOG_##TYPENAME, TYPENAME, IN, TYPENAME)  /* explicitly typed function */\

   336

__function_1p(LOG, TYPENAME, IN, TYPENAME)             /* overloaded function */ 

   337

__ANY_REAL(__iec_)

   338

#undef __iec_

   339

   340

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

   341

  /*     EXP    */

   342

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

   343

#define __iec_(TYPENAME) \

   344

__function_1p(EXP_##TYPENAME, TYPENAME, IN, TYPENAME)  /* explicitly typed function */\

   345

__function_1p(EXP, TYPENAME, IN, TYPENAME)             /* overloaded function */ 

   346

__ANY_REAL(__iec_)

   347

#undef __iec_

   348

   349

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

   350

  /*     SIN    */

   351

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

   352

#define __iec_(TYPENAME) \

   353

__function_1p(SIN_##TYPENAME, TYPENAME, IN, TYPENAME)  /* explicitly typed function */\

   354

__function_1p(SIN, TYPENAME, IN, TYPENAME)             /* overloaded function */ 

   355

__ANY_REAL(__iec_)

   356

#undef __iec_

   357

   358

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

   359

  /*     COS    */

   360

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

   361

#define __iec_(TYPENAME) \

   362

__function_1p(COS_##TYPENAME, TYPENAME, IN, TYPENAME)  /* explicitly typed function */\

   363

__function_1p(COS, TYPENAME, IN, TYPENAME)             /* overloaded function */ 

   364

__ANY_REAL(__iec_)

   365

#undef __iec_

   366

   367

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

   368

  /*     TAN    */

   369

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

   370

#define __iec_(TYPENAME) \

   371

__function_1p(TAN_##TYPENAME, TYPENAME, IN, TYPENAME)  /* explicitly typed function */\

   372

__function_1p(TAN, TYPENAME, IN, TYPENAME)             /* overloaded function */ 

   373

__ANY_REAL(__iec_)

   374

#undef __iec_

   375

   376

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

   377

  /*    ASIN    */

   378

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

   379

#define __iec_(TYPENAME) \

   380

__function_1p(ASIN_##TYPENAME, TYPENAME, IN, TYPENAME)  /* explicitly typed function */\

   381

__function_1p(ASIN, TYPENAME, IN, TYPENAME)             /* overloaded function */ 

   382

__ANY_REAL(__iec_)

   383

#undef __iec_

   384

   385

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

   386

  /*    ACOS    */

   387

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

   388

#define __iec_(TYPENAME) \

   389

__function_1p(ACOS_##TYPENAME, TYPENAME, IN, TYPENAME)  /* explicitly typed function */\

   390

__function_1p(ACOS, TYPENAME, IN, TYPENAME)             /* overloaded function */ 

   391

__ANY_REAL(__iec_)

   392

#undef __iec_

   393

   394

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

   395

  /*    ATAN    */

   396

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

   397

#define __iec_(TYPENAME) \

   398

__function_1p(ATAN_##TYPENAME, TYPENAME, IN, TYPENAME)  /* explicitly typed function */\

   399

__function_1p(ATAN, TYPENAME, IN, TYPENAME)             /* overloaded function */ 

   400

__ANY_REAL(__iec_)

   401

#undef __iec_

   402

   403

   404

   405

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

   406

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

   407

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

   408

   409

#define __arith_expand(fname,TYPENAME) \

   410

__function_1e(fname##_##TYPENAME, TYPENAME, IN, TYPENAME, 1)     /* explicitly typed function */\

   411

__function_1e(fname, TYPENAME, IN, TYPENAME, 1)                  /* overloaded function */ 

   412

   413

   414

#define __arith_static(fname,TYPENAME) \

   415

__function_1p(fname##_##TYPENAME, TYPENAME, IN, TYPENAME)  /* explicitly typed function */\

   416

__function_1p(fname, TYPENAME, IN, TYPENAME)               /* overloaded function */ 

   417

   418

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

   419

  /*     ADD    */

   420

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

   421

#define __iec_(TYPENAME) __arith_expand(ADD, TYPENAME)

   422

__ANY_NUM(__iec_)

   423

#undef __iec_

   424

   425

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

   426

  /*     MUL    */

   427

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

   428

#define __iec_(TYPENAME) __arith_expand(MUL, TYPENAME)

   429

__ANY_NUM(__iec_)

   430

#undef __iec_

   431

   432

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

   433

  /*     SUB    */

   434

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

   435

#define __iec_(TYPENAME)\

   436

__function_2p(SUB_##TYPENAME, TYPENAME, IN1, TYPENAME, IN2, TYPENAME)  /* explicitly typed function */\

   437

__function_2p(SUB, TYPENAME, IN1, TYPENAME, IN2, TYPENAME)             /* overloaded function */ 

   438

__ANY_NUM(__iec_)

   439

#undef __iec_

   440

   441

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

   442

  /*     DIV    */

   443

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

   444

#define __iec_(TYPENAME)\

   445

__function_2p(DIV_##TYPENAME, TYPENAME, IN1, TYPENAME, IN2, TYPENAME)  /* explicitly typed function */\

   446

__function_2p(DIV, TYPENAME, IN1, TYPENAME, IN2, TYPENAME)             /* overloaded function */ 

   447

__ANY_NUM(__iec_)

   448

#undef __iec_

   449

   450

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

   451

  /*     MOD    */

   452

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

   453

#ifdef __DEFINE_CLASHING_FUNCTIONS  

   454

#define __iec_(TYPENAME)\

   455

__function_2p(MOD_##TYPENAME, TYPENAME, IN1, TYPENAME, IN2, TYPENAME)  /* explicitly typed function */\

   456

__function_2p(MOD, TYPENAME, IN1, TYPENAME, IN2, TYPENAME)             /* overloaded function */ 

   457

__ANY_INT(__iec_)

   458

#undef __iec_

   459

#endif

   460

   461

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

   462

  /*    EXPT    */

   463

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

   464

#define __in1_anyreal_(in2_TYPENAME)   __ANY_REAL_1(__iec_,in2_TYPENAME)

   465

#define __iec_(in1_TYPENAME,in2_TYPENAME) \

   466

__function_2p(EXPT, in1_TYPENAME, IN1, in1_TYPENAME, IN2, in2_TYPENAME)             /* overloaded function */ 

   467

__ANY_NUM(__in1_anyreal_)

   468

#undef __iec_

   469

   470

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

   471

  /*     MOVE    */

   472

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

   473

#define __iec_(TYPENAME) __arith_static(MOVE, TYPENAME)

   474

__ANY(__iec_)

   475

#undef __iec_

   476

   477

   478

   479

   480

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

   481

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

   482

/*  2.5.1.5.3 Bit String Functions */

   483

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

   484

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

   485

   486

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

   487

/***   Table 25 - Standard bit shift functions    ***/

   488

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

   489

/* We do not delcare explcitly typed versions of the functions in table 29.

   490

 * See note at top of this file regarding explicitly typed functions for more details.

   491

 */

   492

#define __in1_anybit_(in2_TYPENAME)   __ANY_BIT_1(__iec_,in2_TYPENAME)

   493

   494

   495

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

   496

  /*     SHL    */

   497

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

   498

#define __iec_(in1_TYPENAME,in2_TYPENAME) __function_2p(SHL, in1_TYPENAME, IN, in1_TYPENAME, N, in2_TYPENAME)             /* overloaded function */ 

   499

__ANY_INT(__in1_anybit_)

   500

#undef __iec_

   501

   502

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

   503

  /*     SHR    */

   504

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

   505

#define __iec_(in1_TYPENAME,in2_TYPENAME) __function_2p(SHR, in1_TYPENAME, IN, in1_TYPENAME, N, in2_TYPENAME)             /* overloaded function */ 

   506

__ANY_INT(__in1_anybit_)

   507

#undef __iec_

   508

   509

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

   510

  /*     ROR    */

   511

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

   512

#define __iec_(in1_TYPENAME,in2_TYPENAME) __function_2p(ROR, in1_TYPENAME, IN, in1_TYPENAME, N, in2_TYPENAME)             /* overloaded function */ 

   513

__ANY_INT(__in1_anybit_)

   514

#undef __iec_

   515

   516

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

   517

  /*     ROL    */

   518

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

   519

#define __iec_(in1_TYPENAME,in2_TYPENAME) __function_2p(ROL, in1_TYPENAME, IN, in1_TYPENAME, N, in2_TYPENAME)             /* overloaded function */ 

   520

__ANY_INT(__in1_anybit_)

   521

#undef __iec_

   522

   523

   524

   525

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

   526

/***   Table 26    ***/

   527

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

   528