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

__function_1p(DATE_AND_TIME_TO_DATE, DATE, IN, DT)

   210

__iec_(DT,DT)

   211

__iec_(TOD,DT)

   212

__function_1p(DATE_AND_TIME_TO_TIME_OF_DAY, TOD, IN, DT)

   213

/* Not supported: DATE_TO_TIME */

   214

__iec_(DATE,DATE)

   215

/* Not supported: DATE_TO_DT */

   216

/* Not supported: DATE_TO_TOD */

   217

/* Not supported: TOD_TO_TIME */

   218

/* Not supported: TOD_TO_DATE */

   219

/* Not supported: TOD_TO_DT */

   220

__iec_(TOD,TOD)

   221

   222

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

   223

/* Not supported: TIME_TO_DATE */

   224

/* Not supported: TIME_TO_DT */

   225

/* Not supported: TIME_TO_TOD */

   226

   227

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

   228

__iec_(TIME,TIME)

   229

   230

   231

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

   232

__ANY_BIT(__to_string_)

   233

   234

   235

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

   236

__ANY_NUM(__to_string_)

   237

   238

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

   239

__ANY_DATE(__to_string_)

   240

   241

   242

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

   243

__iec_(STRING,TIME)

   244

   245

   246

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

   247

__to_anybit_(STRING)

   248

   249

   250

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

   251

__to_anynum_(STRING)

   252

   253

   254

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

   255

__to_anydate_(STRING)

   256

   257

   258

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

   259

__iec_(TIME,STRING)

   260

   261

#undef __iec_

   262

   263

   264

   265

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

   266

/*   TRUNC    */

   267

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

   268

/* overloaded function! */

   269

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

   270

__ANY_REAL(__to_anyint_)

   271

#undef __iec_

   272

   273

   274

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

   275

/*   *_TO_BCD_*    */

   276

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

   277

#define __iec_(to_TYPENAME,from_TYPENAME)\

   278

__function_1p(from_TYPENAME##_TO_BCD_##to_TYPENAME, to_TYPENAME, IN, from_TYPENAME)  /* explicitly typed function */\

   279

__function_1p(from_TYPENAME##_TO_BCD, to_TYPENAME, IN, from_TYPENAME)                /* overloaded function */ 

   280

__ANY_UINT(__to_anynbit_)

   281

#undef __iec_

   282

   283

   284

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

   285

/*   *_BCD_TO_*    */

   286

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

   287

#define __iec_(to_TYPENAME,from_TYPENAME)\

   288

__function_1p(from_TYPENAME##_BCD_TO_##to_TYPENAME, to_TYPENAME, IN, from_TYPENAME)  /* explicitly typed function */\

   289

__function_1p(BCD_TO_##to_TYPENAME, to_TYPENAME, IN, from_TYPENAME)                  /* overloaded function */ 

   290

   291

__ANY_NBIT(__to_anyuint_)

   292

#undef __iec_

   293

   294

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

   295

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

   296

/*  2.5.1.5.2 Numerical Functions  */

   297

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

   298

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

   299

   300

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

   301

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

   302

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

   303

   304

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

   305

  /*    ABS     */

   306

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

   307

#define __iec_(TYPENAME) \

   308

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

   309

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

   310

__ANY_REAL(__iec_)

   311

__ANY_INT(__iec_)

   312

#undef __iec_

   313

   314

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

   315

  /*    SQRT    */

   316

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

   317

#define __iec_(TYPENAME) \

   318

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

   319

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

   320

__ANY_REAL(__iec_)

   321

#undef __iec_

   322

   323

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

   324

  /*     LN     */

   325

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

   326

#define __iec_(TYPENAME) \

   327

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

   328

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

   329

__ANY_REAL(__iec_)

   330

#undef __iec_

   331

   332

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

   333

  /*     LOG    */

   334

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

   335

#define __iec_(TYPENAME) \

   336

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

   337

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

   338

__ANY_REAL(__iec_)

   339

#undef __iec_

   340

   341

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

   342

  /*     EXP    */

   343

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

   344

#define __iec_(TYPENAME) \

   345

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

   346

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

   347

__ANY_REAL(__iec_)

   348

#undef __iec_

   349

   350

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

   351

  /*     SIN    */

   352

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

   353

#define __iec_(TYPENAME) \

   354

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

   355

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

   356

__ANY_REAL(__iec_)

   357

#undef __iec_

   358

   359

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

   360

  /*     COS    */

   361

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

   362

#define __iec_(TYPENAME) \

   363

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

   364

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

   365

__ANY_REAL(__iec_)

   366

#undef __iec_

   367

   368

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

   369

  /*     TAN    */

   370

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

   371

#define __iec_(TYPENAME) \

   372

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

   373

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

   374

__ANY_REAL(__iec_)

   375

#undef __iec_

   376

   377

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

   378

  /*    ASIN    */

   379

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

   380

#define __iec_(TYPENAME) \

   381

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

   382

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

   383

__ANY_REAL(__iec_)

   384

#undef __iec_

   385

   386

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

   387

  /*    ACOS    */

   388

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

   389

#define __iec_(TYPENAME) \

   390

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

   391

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

   392

__ANY_REAL(__iec_)

   393

#undef __iec_

   394

   395

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

   396

  /*    ATAN    */

   397

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

   398

#define __iec_(TYPENAME) \

   399

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

   400

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

   401

__ANY_REAL(__iec_)

   402

#undef __iec_

   403

   404

   405

   406

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

   407

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

   408

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

   409

   410

#define __arith_expand(fname,TYPENAME) \

   411

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

   412

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

   413

   414

   415

#define __arith_static(fname,TYPENAME) \

   416

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

   417

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

   418

   419

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

   420

  /*     ADD    */

   421

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

   422

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

   423

__ANY_NUM(__iec_)

   424

#undef __iec_

   425

   426

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

   427

  /*     MUL    */

   428

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

   429

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

   430

__ANY_NUM(__iec_)

   431

#undef __iec_

   432

   433

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

   434

  /*     SUB    */

   435

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

   436

#define __iec_(TYPENAME)\

   437

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

   438

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

   439

__ANY_NUM(__iec_)

   440

#undef __iec_

   441

   442

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

   443

  /*     DIV    */

   444

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

   445

#define __iec_(TYPENAME)\

   446

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

   447

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

   448

__ANY_NUM(__iec_)

   449

#undef __iec_

   450

   451

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

   452

  /*     MOD    */

   453

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

   454

#ifdef __DEFINE_CLASHING_FUNCTIONS  

   455

#define __iec_(TYPENAME)\

   456

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

   457

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

   458

__ANY_INT(__iec_)

   459

#undef __iec_

   460

#endif

   461

   462

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

   463

  /*    EXPT    */

   464

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

   465

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

   466

#define __iec_(in1_TYPENAME,in2_TYPENAME) \

   467

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

   468

__ANY_NUM(__in1_anyreal_)

   469

#undef __iec_

   470

   471

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

   472

  /*     MOVE    */

   473

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

   474

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

   475

__ANY(__iec_)

   476

#undef __iec_

   477

   478

   479

   480

   481

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

   482

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

   483

/*  2.5.1.5.3 Bit String Functions */

   484

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

   485

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

   486

   487

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

   488

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

   489

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

   490

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

   491

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

   492

 */

   493

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

   494

   495

   496

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

   497

  /*     SHL    */

   498

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

   499

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

   500

__ANY_INT(__in1_anybit_)

   501

#undef __iec_

   502

   503

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

   504

  /*     SHR    */

   505

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

   506

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

   507

__ANY_INT(__in1_anybit_)

   508

#undef __iec_

   509

   510

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

   511

  /*     ROR    */

   512

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

   513

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

   514

__ANY_INT(__in1_anybit_)

   515

#undef __iec_

   516

   517

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

   518

  /*     ROL    */

   519

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

   520

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

   521

__ANY_INT(__in1_anybit_)

   522

#undef __iec_

   523

   524

   525

   526

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

   527

/***   Table 26    ***/

   528

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