1

/*

     2

 * (c) 2008 Edouard TISSERANT

     3

 *

     4

 * Offered to the public under the terms of the GNU Lesser General Public

     5

 * License as published by the Free Software Foundation; either version 2

     6

 * of the License, or (at your option) any later version.

     7

 *

     8

 * This program is distributed in the hope that it will be useful, but

     9

 * WITHOUT ANY WARRANTY; without even the implied warranty of

    10

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser

    11

 * General Public License for more details.

    12

 *

    13

 * This code is made available on the understanding that it will not be

    14

 * used in safety-critical situations without a full and competent review.

    15

 */

    16

    17

/****

    18

 * IEC 61131-3 standard function library

    19

 */

    20

    21

#include <limits.h>

    22

#include <float.h>

    23

#include <math.h>

    24

#include <time.h>

    25

#include <stdint.h>

    26

    27

#include <stdio.h>

    28

#include <stdlib.h>

    29

#include <string.h>

    30

#include <stdarg.h>

    31

    32

#ifdef DEBUG_IEC

    33

#define DBG(...) printf(__VA_ARGS__);

    34

#define DBG_TYPE(TYPENAME, name) __print_##TYPENAME(name);

    35

#else

    36

#define DBG(...)

    37

#define DBG_TYPE(TYPENAME, name)

    38

#endif

    39

    40

/*

    41

 * Include type defs.

    42

 */

    43

#include "iec_types_all.h"

    44

    45

#define __TIME_CMP(t1, t2) (t2.tv_sec == t1.tv_sec ? t1.tv_nsec - t2.tv_nsec : t1.tv_sec - t2.tv_sec) 

    46

extern TIME __CURRENT_TIME;

    48

    49

#define __STR_CMP(str1, str2) memcmp((char*)&str1.body,(char*)&str2.body, str1.len < str2.len ? str1.len : str2.len)

    50

    51

/* TODO

    52

typedef struct {

    53

    __strlen_t len;

    54

    u_int16_t body[STR_MAX_LEN];

    55

} WSTRING;

    56

*/

    57

    58

# if __WORDSIZE == 64

    59

#define __32b_sufix

    60

#define __64b_sufix L

    61

#else

    62

#define __32b_sufix L

    63

#define __64b_sufix LL 

    64

#endif 

    65

    66

#define __lit(type,value,sfx) (type)value##sfx

    67

// Keep this macro expention step to let sfx change into L or LL 

    68

#define __literal(type,value,sfx) __lit(type,value,sfx)

    69

    70

#define __BOOL_LITERAL(value) __literal(BOOL,value,)

    71

#define __SINT_LITERAL(value) __literal(SINT,value,)

    72

#define __INT_LITERAL(value) __literal(INT,value,)

    73

#define __DINT_LITERAL(value) __literal(DINT,value,__32b_sufix)

    74

#define __LINT_LITERAL(value) __literal(LINT,value,__64b_sufix)

    75

#define __USINT_LITERAL(value) __literal(USINT,value,)

    76

#define __UINT_LITERAL(value) __literal(UINT,value,)

    77

#define __UDINT_LITERAL(value) __literal(UDINT,value,__32b_sufix)

    78

#define __ULINT_LITERAL(value) __literal(ULINT,value,__64b_sufix)

    79

#define __REAL_LITERAL(value) __literal(REAL,value,__32b_sufix)

    80

#define __LREAL_LITERAL(value) __literal(LREAL,value,__64b_sufix)

    81

#define __TIME_LITERAL(value) __literal(TIME,value,)

    82

#define __DATE_LITERAL(value) __literal(DATE,value,)

    83

#define __TOD_LITERAL(value) __literal(TOD,value,)

    84

#define __DT_LITERAL(value) __literal(DT,value,)

    85

#define __STRING_LITERAL(value) __literal(STRING,value,)

    86

#define __BYTE_LITERAL(value) __literal(BYTE,value,)

    87

#define __WORD_LITERAL(value) __literal(WORD,value,)

    88

#define __DWORD_LITERAL(value) __literal(DWORD,value,__32b_sufix)

    89

#define __LWORD_LITERAL(value) __literal(LWORD,value,__32b_sufix)

    90

    91

    92

    93

#define __INIT_REAL 0

    94

#define __INIT_LREAL 0

    95

#define __INIT_SINT 0

    96

#define __INIT_INT 0

    97

#define __INIT_DINT 0

    98

#define __INIT_LINT 0

    99

#define __INIT_USINT 0

   100

#define __INIT_UINT 0

   101

#define __INIT_UDINT 0

   102

#define __INIT_ULINT 0

   103

#define __INIT_TIME (TIME){0,0}

   104

#define __INIT_BOOL 0

   105

#define __INIT_BYTE 0

   106

#define __INIT_WORD 0

   107

#define __INIT_DWORD 0

   108

#define __INIT_LWORD 0

   109

#define __INIT_STRING (STRING){0,""}

   110

//#define __INIT_WSTRING

   111

#define __INIT_DATE (DATE){0,0}

   112

#define __INIT_TOD (TOD){0,0}

   113

#define __INIT_DT (DT){0,0}

   114

   115

typedef union __IL_DEFVAR_T {

   116

    BOOL    BOOLvar;

   117

   118

    SINT    SINTvar;

   119

    INT     INTvar;

   120

    DINT    DINTvar;

   121

    LINT    LINTvar;

   122

   123

    USINT   USINTvar;

   124

    UINT    UINTvar;

   125

    UDINT   UDINTvar;

   126

    ULINT   ULINTvar;

   127

   128

    BYTE    BYTEvar;

   129

    WORD    WORDvar;

   130

    DWORD   DWORDvar;

   131

    LWORD   LWORDvar;

   132

   133

    REAL    REALvar;

   134

    LREAL   LREALvar;

   135

   136

    TIME    TIMEvar;

   137

    TOD TODvar;

   138

    DT  DTvar;

   139

    DATE    DATEvar;

   140

} __IL_DEFVAR_T;

   141

   142

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

   143

/* Misc internal */

   144

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

   145

   146

/* function that generates an IEC runtime error */

   147

static inline void IEC_error(void) {

   148

  /* TODO... */

   149

  fprintf(stderr, "IEC 61131-3 runtime error.\n");

   150

  /*exit(1);*/

   151

}

   152

   153

   154

static inline void __normalize_timespec (struct timespec *ts) {

   155

  if( ts->tv_nsec < -1000000000 || (( ts->tv_sec > 0 ) && ( ts->tv_nsec < 0 ))){

   156

    ts->tv_sec--;

   157

    ts->tv_nsec += 1000000000;

   158

  }

   159

  if( ts->tv_nsec > 1000000000 || (( ts->tv_sec < 0 ) && ( ts->tv_nsec > 0 ))){

   160

    ts->tv_sec++;

   161

    ts->tv_nsec -= 1000000000;

   162

  }

   163

}

   164

   165

static inline struct timespec __time_to_timespec(int sign, double mseconds, double seconds, double minutes, double hours, double days) {

   166

  struct timespec ts;

   167

   168

  /* sign is 1 for positive values, -1 for negative time... */

   169

  long double total_sec = ((days*24 + hours)*60 + minutes)*60 + seconds + mseconds/1e3;

   170

  if (sign >= 0) sign = 1; else sign = -1;

   171

  ts.tv_sec = sign * (long int)total_sec;

   172

  ts.tv_nsec = sign * (long int)((total_sec - ts.tv_sec)*1e9);

   173

   174

  return ts;

   175

}

   176

   177

   178

static inline struct timespec __tod_to_timespec(double seconds, double minutes, double hours) {

   179

  struct timespec ts;

   180

   181

  long double total_sec = (hours*60 + minutes)*60 + seconds;

   182

  ts.tv_sec = (long int)total_sec;

   183

  ts.tv_nsec = (long int)((total_sec - ts.tv_sec)*1e9);

   184

   185

  return ts;

   186

}

   187

   188

static inline struct timespec __date_to_timespec(int day, int month, int year) {

   189

  struct timespec ts;

   190

  struct tm broken_down_time;

   191

   192

  broken_down_time.tm_sec = 0;

   193

  broken_down_time.tm_min = 0;

   194

  broken_down_time.tm_hour = 0;

   195

  broken_down_time.tm_mday = day;  /* day of month, from 1 to 31 */

   196

  broken_down_time.tm_mon = month - 1;   /* month since January, in the range 0 to 11 */

   197

  broken_down_time.tm_year = year - 1900;  /* number of years since 1900 */

   198

   199

  time_t epoch_seconds = mktime(&broken_down_time); /* determine number of seconds since the epoch, i.e. Jan 1st 1970 */

   200

   201

  if ((time_t)(-1) == epoch_seconds)

   202

    IEC_error();

   203

   204

  ts.tv_sec = epoch_seconds;

   205

  ts.tv_nsec = 0;

   206

   207

  return ts;

   208

}

   209

   210

static inline struct timespec __dt_to_timespec(double seconds,  double minutes, double hours, int day, int month, int year) {

   211

  struct timespec ts;

   212

   213

  long double total_sec = (hours*60 + minutes)*60 + seconds;

   214

  ts.tv_sec = (long int)total_sec;

   215

  ts.tv_nsec = (long int)((total_sec - ts.tv_sec)*1e9);

   216

   217

  struct tm broken_down_time;

   218

  broken_down_time.tm_sec = 0;

   219

  broken_down_time.tm_min = 0;

   220

  broken_down_time.tm_hour = 0;

   221

  broken_down_time.tm_mday = day;  /* day of month, from 1 to 31 */

   222

  broken_down_time.tm_mon = month - 1;   /* month since January, in the range 0 to 11 */

   223

  broken_down_time.tm_year = year - 1900;  /* number of years since 1900 */

   224

   225

  time_t epoch_seconds = mktime(&broken_down_time); /* determine number of seconds since the epoch, i.e. Jan 1st 1970 */

   226

  if ((time_t)(-1) == epoch_seconds)

   227

    IEC_error();

   228

   229

  ts.tv_sec += epoch_seconds;

   230

  if (ts.tv_sec < epoch_seconds)

   231

    /* since the TOD is always positive, if the above happens then we had an overflow */

   232

    IEC_error();

   233

   234

  return ts;

   235

}

   236

   237

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

   238

/*   Time ops  */

   239

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

   240

static inline TIME __date_and_time_to_time_of_day(TIME IN){

   241

  return (TIME){IN.tv_sec % 86400, IN.tv_nsec};

   242

}

   243

static inline TIME __date_and_time_to_date(TIME IN){

   244

  return (TIME){IN.tv_sec - (IN.tv_sec % (24*60*60)), 0};

   245

}

   246

static inline TIME __time_add(TIME IN1, TIME IN2){

   247

  TIME res ={IN1.tv_sec + IN2.tv_sec,

   248

             IN1.tv_nsec + IN2.tv_nsec };

   249

  __normalize_timespec(&res);

   250

  return res;

   251

}

   252

static inline TIME __time_sub(TIME IN1, TIME IN2){

   253

  TIME res ={IN1.tv_sec - IN2.tv_sec,

   254

             IN1.tv_nsec - IN2.tv_nsec };

   255

  __normalize_timespec(&res);

   256

  return res;

   257

}

   258

static inline TIME __time_mul(TIME IN1, LREAL IN2){

   259

  LREAL s_f = IN1.tv_sec * IN2;

   260

  time_t s = s_f;

   261

  div_t ns = div((LREAL)IN1.tv_nsec * IN2, 1000000000);

   262

  TIME res = {s + ns.quot,

   263

              ns.rem + (s_f - s) * 1000000000 };

   264

  __normalize_timespec(&res);

   265

  return res;

   266

}

   267

static inline TIME __time_div(TIME IN1, LREAL IN2){

   268

  LREAL s_f = IN1.tv_sec / IN2;

   269

  time_t s = s_f;

   270

  TIME res = {s,

   271

              IN1.tv_nsec / IN2 + (s_f - s) * 1000000000 };

   272

  __normalize_timespec(&res);

   273

  return res;

   274

}

   275

   276

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

   277

/* String ops  */

   278

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

   279

static inline UINT __len(STRING IN){

   280

    return IN.len;

   281

}

   282

static inline STRING __left(STRING IN, SINT L){

   283

    STRING res = __INIT_STRING;

   284

    L = L < IN.len ? L : IN.len;

   285

    memcpy(&res.body, &IN.body, L);

   286

    res.len = L;

   287

    return res;

   288

}

   289

static inline STRING __right(STRING IN, SINT L){

   290

    STRING res = __INIT_STRING;

   291

    L = L < IN.len ? L : IN.len;

   292

    memcpy(&res.body, &IN.body[IN.len - L], L);

   293

    res.len = L;

   294

    return res;

   295

}

   296

static inline STRING __mid(STRING IN, SINT L, SINT P){

   297

    STRING res = __INIT_STRING;

   298

    if(P <= IN.len){

   299

	    P -= 1; /* now can be used as [index]*/

   300

	    L = L + P <= IN.len ? L : IN.len - P;

   301

	    memcpy(&res.body, &IN.body[P] , L);

   302

        res.len = L;

   303

    }

   304

    return res;

   305

}

   306

static inline STRING __concat(SINT param_count, ...){

   307

  va_list ap;

   308

  UINT i;

   309

  __strlen_t charcount = 0;

   310

  STRING res = __INIT_STRING;

   311

   312

  va_start (ap, param_count);         /* Initialize the argument list.  */

   313

   314

  for (i = 0; i < param_count && charcount < STR_MAX_LEN; i++)

   315

  {

   316

    STRING tmp = va_arg(ap, STRING);

   317

    __strlen_t charrem = STR_MAX_LEN - charcount;

   318

    __strlen_t to_write = tmp.len > charrem ? charrem : tmp.len;

   319

    memcpy(&res.body[charcount], &tmp.body , to_write);

   320

    charcount += to_write;

   321

  }

   322

   323

  res.len = charcount;

   324

   325

  va_end (ap);                  /* Clean up.  */

   326

  return res;

   327

}

   328

static inline STRING __insert(STRING IN1, STRING IN2, SINT P){

   329

    STRING res = __INIT_STRING;

   330

    __strlen_t to_copy;

   331

   332

    to_copy = P > IN1.len ? IN1.len : P - 1;

   333

    memcpy(&res.body, &IN1.body , to_copy);

   334

    P = res.len = to_copy;

   335

   336

    to_copy = IN2.len + res.len > STR_MAX_LEN ? STR_MAX_LEN - res.len : IN2.len;

   337

    memcpy(&res.body[res.len], &IN2.body , to_copy);

   338

    res.len += to_copy;

   339

   340

    to_copy = IN1.len - P < STR_MAX_LEN - res.len ? IN1.len - P : STR_MAX_LEN - res.len ;

   341

    memcpy(&res.body[res.len], &IN1.body[P] , to_copy);

   342

    res.len += to_copy;

   343

   344

    return res;

   345

}

   346

static inline STRING __delete(STRING IN, SINT L, SINT P){

   347

    STRING res = __INIT_STRING;

   348

    __strlen_t to_copy;

   349

   350

    to_copy = P > IN.len ? IN.len : P-1;

   351

    memcpy(&res.body, &IN.body , to_copy);

   352

    P = res.len = to_copy;

   353

   354

    if( IN.len > P + L ){

   355

        to_copy = IN.len - P - L;

   356

        memcpy(&res.body[res.len], &IN.body[P + L], to_copy);

   357

        res.len += to_copy;

   358

    }

   359

   360

    return res;

   361

}

   362

static inline STRING __replace(STRING IN1, STRING IN2, SINT L, SINT P){

   363

    STRING res = __INIT_STRING;

   364

    __strlen_t to_copy;

   365

   366

    to_copy = P > IN1.len ? IN1.len : P-1;

   367

    memcpy(&res.body, &IN1.body , to_copy);

   368

    P = res.len = to_copy;

   369

   370

    to_copy = IN2.len < L ? IN2.len : L;

   371

   372

    if( to_copy + res.len > STR_MAX_LEN ) 

   373

       to_copy = STR_MAX_LEN - res.len;   

   374

   375

    memcpy(&res.body[res.len], &IN2.body , to_copy);

   376

    res.len += to_copy;

   377

   378

    P += L;

   379

    if( res.len <  STR_MAX_LEN && P < IN1.len)

   380

    {

   381

        to_copy = IN1.len - P;

   382

        memcpy(&res.body[res.len], &IN1.body[P] , to_copy);

   383

        res.len += to_copy;

   384

    }

   385

   386

    return res;

   387

}

   388

   389

   390

   391

static inline UINT __pfind(STRING* IN1, STRING* IN2){

   392

    UINT count1 = 0; /* offset of first matching char in IN1 */

   393

    UINT count2 = 0; /* count of matching char */

   394

    while(count1 + count2 < IN1->len && count2 < IN2->len)

   395

    {

   396

        if(IN1->body[count1 + count2] != IN2->body[count2++]){

   397

            count1 += count2;

   398

            count2 = 0;

   399

        }        

   400

    }

   401

    return count2 == IN2->len -1 ? 0 : count1 + 1;

   402

}

   403

static inline UINT __find(STRING IN1, STRING IN2){

   404

    return __pfind(&IN1, &IN2);

   405

}

   406

   407

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

   408

/* Convertions */

   409

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

   410

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

   411

    /*  TO_STRING  */

   412

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

   413

static inline STRING __bool_to_string(BOOL IN)

   414

{

   415

    if(IN)

   416

        return (STRING){4, "TRUE"};

   417

    return (STRING){5,"FALSE"};

   418

}

   419

static inline STRING __bit_to_string(LWORD IN){

   420

    STRING res = __INIT_STRING;

   421

    res.len = snprintf((char*)res.body, STR_MAX_LEN, "16#%llx", IN);

   422

    if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;

   423

    return res;

   424

}

   425

static inline STRING __real_to_string(LREAL IN){

   426

    STRING res = __INIT_STRING;

   427

    res.len = snprintf((char*)res.body, STR_MAX_LEN, "%.10g", IN);

   428

    if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;

   429

    return res;

   430

}

   431

static inline STRING __sint_to_string(LINT IN){

   432

    STRING res = __INIT_STRING;

   433

    res.len = snprintf((char*)res.body, STR_MAX_LEN, "%lld", IN);

   434

    if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;

   435

    return res;

   436

}

   437

static inline STRING __uint_to_string(ULINT IN){

   438

    STRING res = __INIT_STRING;

   439

    res.len = snprintf((char*)res.body, STR_MAX_LEN, "%llu", IN);

   440

    if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;

   441

    return res;

   442

}

   443

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

   444

    /* FROM_STRING */

   445

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

   446

static inline BOOL __string_to_bool(STRING IN){

   447

    return IN.len == 5 ? !memcmp(&IN.body,"TRUE", IN.len) : 0;

   448

}

   449

   450

static inline LINT __pstring_to_sint(STRING* IN){

   451

    LINT res = 0;

   452

    char tmp[STR_MAX_LEN];

   453

    char tmp2[STR_MAX_LEN];

   454

    __strlen_t l;

   455

    unsigned int shift = 0;

   456

   457

    if(IN->body[0]=='2' && IN->body[1]=='#'){

   458

        /* 2#0101_1010_1011_1111 */

   459

        for(l = IN->len - 1; l >= 2 && shift < 64; l--)

   460

        {

   461

            char c = IN->body[l];

   462

            if( c >= '0' && c <= '1'){

   463

                res |= ( c - '0') << shift;

   464

                shift += 1;

   465

            }

   466

        }

   467

    }else if(IN->body[0]=='8' && IN->body[1]=='#'){

   468

        /* 8#1234_5665_4321 */

   469

        for(l = IN->len - 1; l >= 2 && shift < 64; l--)

   470

        {

   471

            char c = IN->body[l];

   472

            if( c >= '0' && c <= '7'){

   473

                res |= ( c - '0') << shift;

   474

                shift += 3;

   475

            }

   476

        }

   477

    }else if(IN->body[0]=='1' && IN->body[1]=='6' && IN->body[2]=='#'){

   478

        /* 16#1234_5678_9abc_DEFG */

   479

        for(l = IN->len - 1; l >= 3 && shift < 64; l--)

   480

        {

   481

            char c = IN->body[l];

   482

            if( c >= '0' && c <= '9'){

   483

                res |= (LWORD)( c - '0') << shift;

   484

                shift += 4;

   485

            }else if( c >= 'a' && c <= 'f'){

   486

                res |= (LWORD)( c - 'a' + 10 ) << shift;

   487

                shift += 4;

   488

            }else if( c >= 'A' && c <= 'F'){

   489

                res |= (LWORD)( c - 'A' + 10 ) << shift;

   490

                shift += 4;

   491

            }

   492

        }

   493

    }else{

   494

        /* -123456789 */

   495

        LINT fac = IN->body[0] == '-' ? -1 : 1;

   496

        for(l = IN->len - 1; l >= 0 && shift < 20; l--)

   497

        {

   498

            char c = IN->body[l];

   499

            if( c >= '0' && c <= '9'){

   500

                res += ( c - '0') * fac;

   501

                fac *= 10;

   502

                shift += 1;

   503

            }else if( c >= '.' ){ /* reset value */

   504

                res = 0;

   505

                fac = 1;

   506

                shift = 0;

   507

            }            

   508

        }

   509

    }

   510

    return res;

   511

}