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

 *

    93

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

    94

 *  of the standard, it is stated:

    95

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

    96

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

    97

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

    98

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

    99

 * [...]

   100

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

   101

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

   102

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

   103

 * shown in table 21."

   104

 *

   105

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

   106

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

   107

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

   108

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

   109

 *

   110

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

   111

 */

   112

   113

   114

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

   115

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

   116

/*  2.5.1.5.1 Type Conversion Functions  */

   117

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

   118

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

   119

   120

/* macros for non-extensible functions */

   121

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

   122

FUNCTION fname : to_TYPENAME\

   123

  VAR_INPUT p1_NAME : p1_TYPENAME; END_VAR\

   124

  RETURN; \

   125

END_FUNCTION\

   126

   127

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

   128

FUNCTION fname : to_TYPENAME\

   129

  VAR_INPUT p1_NAME : p1_TYPENAME; p2_NAME : p2_TYPENAME; END_VAR\

   130

  RETURN; \

   131

END_FUNCTION\

   132

   133

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

   134

FUNCTION fname : to_TYPENAME\

   135

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

   136

  RETURN; \

   137

END_FUNCTION\

   138

   139

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

   140

FUNCTION fname : to_TYPENAME\

   141

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

   142

  RETURN; \

   143

END_FUNCTION\

   144

   145

   146

/* macro for extensible functions */

   147

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

   148

FUNCTION fname : to_TYPENAME\

   149

  VAR_INPUT p1_NAME FIRST_INDEX .. : p1_TYPENAME; END_VAR\

   150

  RETURN; \

   151

END_FUNCTION\

   152

   153

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

   154

FUNCTION fname : to_TYPENAME\

   155

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

   156

  RETURN; \

   157

END_FUNCTION\

   158

   159

   160

   161

   162

   163

   164

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

   165

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

   166

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

   167

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

   168

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

   169

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

   170

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

   171

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

   172

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

   173

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

   174

   175

   176

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

   177

/*   *_TO_**     */

   178

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

   179

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

   180

   181

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

   182

__ANY_BIT(__to_anynum_)

   183

__ANY_BIT(__to_anybit_)

   184

   185

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

   186

__ANY_NUM(__to_anynum_)

   187

__ANY_NUM(__to_anybit_)

   188

   189

   190

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

   191

__ANY_BIT(__to_time_)

   192

__ANY_NUM(__to_time_)

   193

__ANY_BIT(__to_anydate_)

   194

__ANY_NUM(__to_anydate_)

   195

   196

   197

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

   198

__to_anynum_(TIME)

   199

__to_anybit_(TIME)

   200

__ANY_DATE(__to_anynum_)

   201

__ANY_DATE(__to_anybit_)

   202

   203

   204

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

   205

/* Not supported: DT_TO_TIME */

   206

/*__iec_(to_TYPENAME,from_TYPENAME)*/

   207

__iec_(DATE,DT)

   208

__iec_(DT,DT)

   209

__iec_(TOD,DT)

   210

/* Not supported: DATE_TO_TIME */

   211

__iec_(DATE,DATE)

   212

/* Not supported: DATE_TO_DT */

   213

/* Not supported: DATE_TO_TOD */

   214

/* Not supported: TOD_TO_TIME */

   215

/* Not supported: TOD_TO_DATE */

   216

/* Not supported: TOD_TO_DT */

   217

__iec_(TOD,TOD)

   218

   219

   220

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

   221

/* Not supported: TIME_TO_DATE */

   222

/* Not supported: TIME_TO_DT */

   223

/* Not supported: TIME_TO_TOD */

   224

   225

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

   226

__iec_(TIME,TIME)

   227

   228

   229

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

   230

__ANY_BIT(__to_string_)

   231

   232

   233

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

   234

__ANY_NUM(__to_string_)

   235

   236

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

   237

__ANY_DATE(__to_string_)

   238

   239

   240

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

   241

__iec_(STRING,TIME)

   242

   243

   244

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

   245

__to_anybit_(STRING)

   246

   247

   248

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

   249

__to_anynum_(STRING)

   250

   251

   252

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

   253

__to_anydate_(STRING)

   254

   255

   256

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

   257

__iec_(TIME,STRING)

   258

   259

#undef __iec_

   260

   261

   262

   263

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

   264

/*   TRUNC    */

   265

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

   266

/* overloaded function! */

   267

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

   268

__ANY_REAL(__to_anyint_)

   269

#undef __iec_

   270

   271

   272

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

   273

/*   *_TO_BCD_*    */

   274

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

   275

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

   276

__ANY_UINT(__to_anynbit_)

   277

#undef __iec_

   278

   279

   280

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

   281

/*   *_BCD_TO_*    */

   282

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

   283

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

   284

__ANY_NBIT(__to_anyuint_)

   285

#undef __iec_

   286

   287

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

   288

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

   289

/*  2.5.1.5.2 Numerical Functions  */

   290

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

   291

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

   292

   293

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

   294

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

   295

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

   296

   297

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

   298

  /*    ABS     */

   299

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

   300

#define __iec_(TYPENAME) \

   301

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

   302

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

   303

__ANY_REAL(__iec_)

   304

__ANY_INT(__iec_)

   305

#undef __iec_

   306

   307

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

   308

  /*    SQRT    */

   309

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

   310

#define __iec_(TYPENAME) \

   311

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

   312

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

   313

__ANY_REAL(__iec_)

   314

#undef __iec_

   315

   316

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

   317

  /*     LN     */

   318

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

   319

#define __iec_(TYPENAME) \

   320

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

   321

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

   322

__ANY_REAL(__iec_)

   323

#undef __iec_

   324

   325

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

   326

  /*     LOG    */

   327

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

   328

#define __iec_(TYPENAME) \

   329

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

   330

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

   331

__ANY_REAL(__iec_)

   332

#undef __iec_

   333

   334

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

   335

  /*     EXP    */

   336

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

   337

#define __iec_(TYPENAME) \

   338

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

   339

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

   340

__ANY_REAL(__iec_)

   341

#undef __iec_

   342

   343

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

   344

  /*     SIN    */

   345

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

   346

#define __iec_(TYPENAME) \

   347

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

   348

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

   349

__ANY_REAL(__iec_)

   350

#undef __iec_

   351

   352

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

   353

  /*     COS    */

   354

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

   355

#define __iec_(TYPENAME) \

   356

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

   357

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

   358

__ANY_REAL(__iec_)

   359

#undef __iec_

   360

   361

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

   362

  /*     TAN    */

   363

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

   364

#define __iec_(TYPENAME) \

   365

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

   366

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

   367

__ANY_REAL(__iec_)

   368

#undef __iec_

   369

   370

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

   371

  /*    ASIN    */

   372

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

   373

#define __iec_(TYPENAME) \

   374

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

   375

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

   376

__ANY_REAL(__iec_)

   377

#undef __iec_

   378

   379

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

   380

  /*    ACOS    */

   381

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

   382

#define __iec_(TYPENAME) \

   383

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

   384

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

   385

__ANY_REAL(__iec_)

   386

#undef __iec_

   387

   388

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

   389

  /*    ATAN    */

   390

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

   391

#define __iec_(TYPENAME) \

   392

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

   393

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

   394

__ANY_REAL(__iec_)

   395

#undef __iec_

   396

   397

   398

   399

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

   400

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

   401

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

   402

   403

#define __arith_expand(fname,TYPENAME) \

   404

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

   405

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

   406

   407

   408

#define __arith_static(fname,TYPENAME) \

   409

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

   410

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

   411

   412

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

   413

  /*     ADD    */

   414

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

   415

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

   416

__ANY_NUM(__iec_)

   417

#undef __iec_

   418

   419

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

   420

  /*     MUL    */

   421

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

   422

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

   423

__ANY_NUM(__iec_)

   424

#undef __iec_

   425

   426

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

   427

  /*     SUB    */

   428

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

   429

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

   430

__ANY_NUM(__iec_)

   431

#undef __iec_

   432

   433

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

   434

  /*     DIV    */

   435

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

   436

#define __iec_(TYPENAME)\

   437

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

   438

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

   439

__ANY_NUM(__iec_)

   440

#undef __iec_

   441

   442

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

   443

  /*     MOD    */

   444

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

   445

#ifdef __DEFINE_CLASHING_FUNCTIONS  

   446

#define __iec_(TYPENAME)\

   447

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

   448

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

   449

__ANY_INT(__iec_)

   450

#undef __iec_

   451

#endif

   452

   453

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

   454

  /*    EXPT    */

   455

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

   456

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

   457

#define __iec_(in1_TYPENAME,in2_TYPENAME) \

   458

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

   459

__ANY_NUM(__in1_anyreal_)

   460

#undef __iec_

   461

   462

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

   463

  /*     MOVE    */

   464

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

   465

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

   466

__ANY(__iec_)

   467

#undef __iec_

   468

   469

   470

   471

   472

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

   473

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

   474

/*  2.5.1.5.3 Bit String Functions */

   475

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

   476

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

   477

   478

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

   479

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

   480

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

   481

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

   482

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

   483

 */

   484

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

   485

   486

   487

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

   488

  /*     SHL    */

   489

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

   490

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

   491

__ANY_INT(__in1_anybit_)

   492

#undef __iec_

   493

   494

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

   495

  /*     SHR    */

   496

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

   497

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

   498

__ANY_INT(__in1_anybit_)

   499

#undef __iec_

   500

   501

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

   502

  /*     ROR    */

   503

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

   504

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

   505

__ANY_INT(__in1_anybit_)

   506

#undef __iec_

   507

   508

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

   509

  /*     ROL    */

   510

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

   511

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

   512

__ANY_INT(__in1_anybit_)

   513

#undef __iec_

   514

   515

   516

   517

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

   518

/***   Table 26    ***/

   519

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

   520

   521

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

   522

  /*     AND    */

   523

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

   524

#ifdef __DEFINE_CLASHING_FUNCTIONS  

   525

#define __iec_(TYPENAME) \

   526

__function_1e(AND, TYPENAME, IN, TYPENAME, 1)                /* overloaded function */ \

   527

__function_1e(AND_##TYPENAME, TYPENAME, IN, TYPENAME, 1)     /* explicitly typed function */ 

   528

__ANY_BIT(__iec_)

   529

#undef __iec_

   530