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

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

   276

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

   277

__ANY_UINT(__to_anynbit_)

   278

#undef __iec_

   279

   280

   281

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

   282

/*   *_BCD_TO_*    */

   283

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

   284

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

   285

__ANY_NBIT(__to_anyuint_)

   286

#undef __iec_

   287

   288

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

   289

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

   290

/*  2.5.1.5.2 Numerical Functions  */

   291

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

   292

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

   293

   294

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

   295

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

   296

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

   297

   298

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

   299

  /*    ABS     */

   300

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

   301

#define __iec_(TYPENAME) \

   302

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

   303

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

   304

__ANY_REAL(__iec_)

   305

__ANY_INT(__iec_)

   306

#undef __iec_

   307

   308

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

   309

  /*    SQRT    */

   310

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

   311

#define __iec_(TYPENAME) \

   312

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

   313

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

   314

__ANY_REAL(__iec_)

   315

#undef __iec_

   316

   317

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

   318

  /*     LN     */

   319

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

   320

#define __iec_(TYPENAME) \

   321

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

   322

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

   323

__ANY_REAL(__iec_)

   324

#undef __iec_

   325

   326

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

   327

  /*     LOG    */

   328

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

   329

#define __iec_(TYPENAME) \

   330

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

   331

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

   332

__ANY_REAL(__iec_)

   333

#undef __iec_

   334

   335

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

   336

  /*     EXP    */

   337

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

   338

#define __iec_(TYPENAME) \

   339

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

   340

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

   341

__ANY_REAL(__iec_)

   342

#undef __iec_

   343

   344

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

   345

  /*     SIN    */

   346

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

   347

#define __iec_(TYPENAME) \

   348

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

   349

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

   350

__ANY_REAL(__iec_)

   351

#undef __iec_

   352

   353

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

   354

  /*     COS    */

   355

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

   356

#define __iec_(TYPENAME) \

   357

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

   358

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

   359

__ANY_REAL(__iec_)

   360

#undef __iec_

   361

   362

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

   363

  /*     TAN    */

   364

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

   365

#define __iec_(TYPENAME) \

   366

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

   367

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

   368

__ANY_REAL(__iec_)

   369

#undef __iec_

   370

   371

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

   372

  /*    ASIN    */

   373

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

   374

#define __iec_(TYPENAME) \

   375

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

   376

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

   377

__ANY_REAL(__iec_)

   378

#undef __iec_

   379

   380

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

   381

  /*    ACOS    */

   382

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

   383

#define __iec_(TYPENAME) \

   384

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

   385

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

   386

__ANY_REAL(__iec_)

   387

#undef __iec_

   388

   389

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

   390

  /*    ATAN    */

   391

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

   392

#define __iec_(TYPENAME) \

   393

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

   394

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

   395

__ANY_REAL(__iec_)

   396

#undef __iec_

   397

   398

   399

   400

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

   401

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

   402

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

   403

   404

#define __arith_expand(fname,TYPENAME) \

   405

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

   406

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

   407

   408

   409

#define __arith_static(fname,TYPENAME) \

   410

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

   411

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

   412

   413

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

   414

  /*     ADD    */

   415

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

   416

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

   417

__ANY_NUM(__iec_)

   418

#undef __iec_

   419

   420

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

   421

  /*     MUL    */

   422

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

   423

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

   424

__ANY_NUM(__iec_)

   425

#undef __iec_

   426

   427

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

   428

  /*     SUB    */

   429

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

   430

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

   431

__ANY_NUM(__iec_)

   432

#undef __iec_

   433

   434

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

   435

  /*     DIV    */

   436

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

   437

#define __iec_(TYPENAME)\

   438

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

   439

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

   440

__ANY_NUM(__iec_)

   441

#undef __iec_

   442

   443

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

   444

  /*     MOD    */

   445

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

   446

#ifdef __DEFINE_CLASHING_FUNCTIONS  

   447

#define __iec_(TYPENAME)\

   448

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

   449

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

   450

__ANY_INT(__iec_)

   451

#undef __iec_

   452

#endif

   453

   454

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

   455

  /*    EXPT    */

   456

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

   457

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

   458

#define __iec_(in1_TYPENAME,in2_TYPENAME) \

   459

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

   460

__ANY_NUM(__in1_anyreal_)

   461

#undef __iec_

   462

   463

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

   464

  /*     MOVE    */

   465

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

   466

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

   467

__ANY(__iec_)

   468

#undef __iec_

   469

   470

   471

   472

   473

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

   474

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

   475

/*  2.5.1.5.3 Bit String Functions */

   476

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

   477

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

   478

   479

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

   480

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

   481

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

   482

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

   483

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

   484

 */

   485

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

   486

   487

   488

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

   489

  /*     SHL    */

   490

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

   491

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

   492

__ANY_INT(__in1_anybit_)

   493

#undef __iec_

   494

   495

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

   496

  /*     SHR    */

   497

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

   498

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

   499

__ANY_INT(__in1_anybit_)

   500

#undef __iec_

   501

   502

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

   503

  /*     ROR    */

   504

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

   505

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

   506

__ANY_INT(__in1_anybit_)

   507

#undef __iec_

   508

   509

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

   510

  /*     ROL    */

   511

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

   512

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

   513

__ANY_INT(__in1_anybit_)

   514

#undef __iec_

   515

   516

   517

   518

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

   519

/***   Table 26    ***/

   520

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

   521

   522

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

   523

  /*     AND    */

   524

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

   525

#ifdef __DEFINE_CLASHING_FUNCTIONS  

   526

#define __iec_(TYPENAME) \

   527

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

   528

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

   529

__ANY_BIT(__iec_)