--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lib/C/accessor.h Sun Jul 06 11:07:38 2014 +0100
@@ -0,0 +1,127 @@
+#ifndef __ACCESSOR_H
+#define __ACCESSOR_H
+
+#define __INITIAL_VALUE(...) __VA_ARGS__
+
+// variable declaration macros
+#define __DECLARE_VAR(type, name)\
+ __IEC_##type##_t name;
+#define __DECLARE_GLOBAL(type, domain, name)\
+ __IEC_##type##_t domain##__##name;\
+ static __IEC_##type##_t *GLOBAL__##name = &(domain##__##name);\
+ void __INIT_GLOBAL_##name(type value) {\
+ (*GLOBAL__##name).value = value;\
+ }\
+ IEC_BYTE __IS_GLOBAL_##name##_FORCED(void) {\
+ return (*GLOBAL__##name).flags & __IEC_FORCE_FLAG;\
+ }\
+ type* __GET_GLOBAL_##name(void) {\
+ return &((*GLOBAL__##name).value);\
+ }
+#define __DECLARE_GLOBAL_FB(type, domain, name)\
+ type domain##__##name;\
+ static type *GLOBAL__##name = &(domain##__##name);\
+ type* __GET_GLOBAL_##name(void) {\
+ return &(*GLOBAL__##name);\
+ }\
+ extern void type##_init__(type* data__, BOOL retain);
+#define __DECLARE_GLOBAL_LOCATION(type, location)\
+ extern type *location;
+#define __DECLARE_GLOBAL_LOCATED(type, resource, name)\
+ __IEC_##type##_p resource##__##name;\
+ static __IEC_##type##_p *GLOBAL__##name = &(resource##__##name);\
+ void __INIT_GLOBAL_##name(type value) {\
+ *((*GLOBAL__##name).value) = value;\
+ }\
+ IEC_BYTE __IS_GLOBAL_##name##_FORCED(void) {\
+ return (*GLOBAL__##name).flags & __IEC_FORCE_FLAG;\
+ }\
+ type* __GET_GLOBAL_##name(void) {\
+ return (*GLOBAL__##name).value;\
+ }
+#define __DECLARE_GLOBAL_PROTOTYPE(type, name)\
+ extern type* __GET_GLOBAL_##name(void);
+#define __DECLARE_EXTERNAL(type, name)\
+ __IEC_##type##_p name;
+#define __DECLARE_EXTERNAL_FB(type, name)\
+ type* name;
+#define __DECLARE_LOCATED(type, name)\
+ __IEC_##type##_p name;
+
+
+// variable initialization macros
+#define __INIT_RETAIN(name, retained)\
+ name.flags |= retained?__IEC_RETAIN_FLAG:0;
+#define __INIT_VAR(name, initial, retained)\
+ name.value = initial;\
+ __INIT_RETAIN(name, retained)
+#define __INIT_GLOBAL(type, name, initial, retained)\
+ {\
+ static const type temp = initial;\
+ __INIT_GLOBAL_##name(temp);\
+ __INIT_RETAIN((*GLOBAL__##name), retained)\
+ }
+#define __INIT_GLOBAL_FB(type, name, retained)\
+ type##_init__(&(*GLOBAL__##name), retained);
+#define __INIT_GLOBAL_LOCATED(domain, name, location, retained)\
+ domain##__##name.value = location;\
+ __INIT_RETAIN(domain##__##name, retained)
+#define __INIT_EXTERNAL(type, global, name, retained)\
+ {\
+ name.value = __GET_GLOBAL_##global();\
+ __INIT_RETAIN(name, retained)\
+ }
+#define __INIT_EXTERNAL_FB(type, global, name, retained)\
+ name = __GET_GLOBAL_##global();
+#define __INIT_LOCATED(type, location, name, retained)\
+ {\
+ extern type *location;\
+ name.value = location;\
+ __INIT_RETAIN(name, retained)\
+ }
+#define __INIT_LOCATED_VALUE(name, initial)\
+ *(name.value) = initial;
+
+
+// variable getting macros
+#define __GET_VAR(name, ...)\
+ name.value __VA_ARGS__
+#define __GET_EXTERNAL(name, ...)\
+ ((name.flags & __IEC_FORCE_FLAG) ? name.fvalue __VA_ARGS__ : (*(name.value)) __VA_ARGS__)
+#define __GET_EXTERNAL_FB(name, ...)\
+ __GET_VAR(((*name) __VA_ARGS__))
+#define __GET_LOCATED(name, ...)\
+ ((name.flags & __IEC_FORCE_FLAG) ? name.fvalue __VA_ARGS__ : (*(name.value)) __VA_ARGS__)
+
+#define __GET_VAR_BY_REF(name, ...)\
+ ((name.flags & __IEC_FORCE_FLAG) ? &(name.fvalue __VA_ARGS__) : &(name.value __VA_ARGS__))
+#define __GET_EXTERNAL_BY_REF(name, ...)\
+ ((name.flags & __IEC_FORCE_FLAG) ? &(name.fvalue __VA_ARGS__) : &((*(name.value)) __VA_ARGS__))
+#define __GET_EXTERNAL_FB_BY_REF(name, ...)\
+ __GET_EXTERNAL_BY_REF(((*name) __VA_ARGS__))
+#define __GET_LOCATED_BY_REF(name, ...)\
+ ((name.flags & __IEC_FORCE_FLAG) ? &(name.fvalue __VA_ARGS__) : &((*(name.value)) __VA_ARGS__))
+
+#define __GET_VAR_REF(name, ...)\
+ (&(name.value __VA_ARGS__))
+#define __GET_EXTERNAL_REF(name, ...)\
+ (&((*(name.value)) __VA_ARGS__))
+#define __GET_EXTERNAL_FB_REF(name, ...)\
+ (&(__GET_VAR(((*name) __VA_ARGS__))))
+#define __GET_LOCATED_REF(name, ...)\
+ (&((*(name.value)) __VA_ARGS__))
+
+
+// variable setting macros
+#define __SET_VAR(prefix, name, suffix, new_value)\
+ if (!(prefix name.flags & __IEC_FORCE_FLAG)) prefix name.value suffix = new_value
+#define __SET_EXTERNAL(prefix, name, suffix, new_value)\
+ {extern IEC_BYTE __IS_GLOBAL_##name##_FORCED();\
+ if (!(prefix name.flags & __IEC_FORCE_FLAG || __IS_GLOBAL_##name##_FORCED()))\
+ (*(prefix name.value)) suffix = new_value;}
+#define __SET_EXTERNAL_FB(prefix, name, suffix, new_value)\
+ __SET_VAR((*(prefix name)), suffix, new_value)
+#define __SET_LOCATED(prefix, name, suffix, new_value)\
+ if (!(prefix name.flags & __IEC_FORCE_FLAG)) *(prefix name.value) suffix = new_value
+
+#endif //__ACCESSOR_H
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lib/C/iec_std_lib.h Sun Jul 06 11:07:38 2014 +0100
@@ -0,0 +1,2271 @@
+/*
+ * copyright 2008 Edouard TISSERANT
+ * copyright 2011 Mario de Sousa (msousa@fe.up.pt)
+ *
+ * Offered to the public under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
+ * General Public License for more details.
+ *
+ * This code is made available on the understanding that it will not be
+ * used in safety-critical situations without a full and competent review.
+ */
+
+/****
+ * IEC 61131-3 standard function library
+ */
+
+/* NOTE: This file is full of (what may seem at first) very strange macros.
+ * If you want to know what all these strange macros are doing,
+ * just parse this file through a C preprocessor (e.g. cpp),
+ * and analyse the output!
+ * $gcc -E iec_std_lib.h
+ */
+
+#ifndef _IEC_STD_LIB_H
+#define _IEC_STD_LIB_H
+
+
+#include <limits.h>
+#include <float.h>
+#include <math.h>
+#include <stdint.h>
+#include <ctype.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#ifdef DEBUG_IEC
+#define DBG(...) printf(__VA_ARGS__);
+#define DBG_TYPE(TYPENAME, name) __print_##TYPENAME(name);
+#else
+#define DBG(...)
+#define DBG_TYPE(TYPENAME, name)
+#endif
+
+/*
+ * Include type defs.
+ */
+#include "iec_types_all.h"
+
+extern TIME __CURRENT_TIME;
+extern BOOL __DEBUG;
+
+/* TODO
+typedef struct {
+ __strlen_t len;
+ u_int16_t body[STR_MAX_LEN];
+} WSTRING;
+*/
+/*
+# if __WORDSIZE == 64
+#define __32b_sufix
+#define __64b_sufix L
+#else
+#define __32b_sufix L
+#define __64b_sufix LL
+#endif
+*/
+
+# if __WORDSIZE == 64
+#define __32b_sufix
+#define __64b_sufix L
+#else
+#define __32b_sufix L
+/* changed this from LL to L temporarily. It was causing a bug when compiling resulting code with gcc.
+ * I have other things to worry about at the moment..
+ */
+#define __64b_sufix L
+#endif
+
+
+#define __lit(type,value,...) (type)value##__VA_ARGS__
+// Keep this macro expention step to let sfx(__VA_ARGS__) change into L or LL
+#define __literal(type,value,...) __lit(type,value,__VA_ARGS__)
+
+#define __BOOL_LITERAL(value) __literal(BOOL,value)
+#define __SINT_LITERAL(value) __literal(SINT,value)
+#define __INT_LITERAL(value) __literal(INT,value)
+#define __DINT_LITERAL(value) __literal(DINT,value,__32b_sufix)
+#define __LINT_LITERAL(value) __literal(LINT,value,__64b_sufix)
+#define __USINT_LITERAL(value) __literal(USINT,value)
+#define __UINT_LITERAL(value) __literal(UINT,value)
+#define __UDINT_LITERAL(value) __literal(UDINT,value,__32b_sufix)
+#define __ULINT_LITERAL(value) __literal(ULINT,value,__64b_sufix)
+#define __REAL_LITERAL(value) __literal(REAL,value,__32b_sufix)
+#define __LREAL_LITERAL(value) __literal(LREAL,value,__64b_sufix)
+#define __TIME_LITERAL(value) __literal(TIME,value)
+#define __DATE_LITERAL(value) __literal(DATE,value)
+#define __TOD_LITERAL(value) __literal(TOD,value)
+#define __DT_LITERAL(value) __literal(DT,value)
+#define __STRING_LITERAL(count,value) (STRING){count,value}
+#define __BYTE_LITERAL(value) __literal(BYTE,value)
+#define __WORD_LITERAL(value) __literal(WORD,value)
+#define __DWORD_LITERAL(value) __literal(DWORD,value,__32b_sufix)
+#define __LWORD_LITERAL(value) __literal(LWORD,value,__64b_sufix)
+
+
+typedef union __IL_DEFVAR_T {
+ BOOL BOOLvar;
+
+ SINT SINTvar;
+ INT INTvar;
+ DINT DINTvar;
+ LINT LINTvar;
+
+ USINT USINTvar;
+ UINT UINTvar;
+ UDINT UDINTvar;
+ ULINT ULINTvar;
+
+ BYTE BYTEvar;
+ WORD WORDvar;
+ DWORD DWORDvar;
+ LWORD LWORDvar;
+
+ REAL REALvar;
+ LREAL LREALvar;
+
+ TIME TIMEvar;
+ TOD TODvar;
+ DT DTvar;
+ DATE DATEvar;
+} __IL_DEFVAR_T;
+
+
+/**********************************************************************/
+/**********************************************************************/
+/***** *****/
+/***** Some helper functions... *****/
+/***** ...used later: *****/
+/***** - when declaring the IEC 61131-3 standard functions *****/
+/***** - in the C source code itself in SFC and ST expressions *****/
+/***** *****/
+/**********************************************************************/
+/**********************************************************************/
+
+
+/****************************/
+/* Notify IEC runtime error */
+/****************************/
+
+/* function that generates an IEC runtime error */
+static inline void __iec_error(void) {
+ /* TODO... */
+ fprintf(stderr, "IEC 61131-3 runtime error.\n");
+ /*exit(1);*/
+}
+
+/*******************************/
+/* Time normalization function */
+/*******************************/
+
+static inline void __normalize_timespec (IEC_TIMESPEC *ts) {
+ if( ts->tv_nsec < -1000000000 || (( ts->tv_sec > 0 ) && ( ts->tv_nsec < 0 ))){
+ ts->tv_sec--;
+ ts->tv_nsec += 1000000000;
+ }
+ if( ts->tv_nsec > 1000000000 || (( ts->tv_sec < 0 ) && ( ts->tv_nsec > 0 ))){
+ ts->tv_sec++;
+ ts->tv_nsec -= 1000000000;
+ }
+}
+
+/**********************************************/
+/* Time conversion to/from timespec functions */
+/**********************************************/
+/* NOTE: The following function was turned into a macro, so it could be used to initialize the initial value of TIME variables.
+ * Since each macro parameter is evaluated several times, the macro may result in multiple function invocations if an expression
+ * containing a function invocation is passed as a parameter. However, currently matiec only uses this conversion macro with
+ * constant literals, so it is safe to change it into a macro.
+ */
+/* NOTE: I (Mario - msousa@fe.up.pt) believe that the following function contains a bug when handling negative times.
+ * The equivalent macro has this bug fixed.
+ * e.g.;
+ * T#3.8s
+ * using the function, will result in a timespec of 3.8s !!!:
+ * tv_sec = 4 <----- 1 * 3.8 is rounded up when converting a double to an int!
+ * tv_nsec = -200 000 000 <----- 1 * (3.8 - 4)*1e9
+ *
+ * -T#3.8s
+ * using the function, will result in a timespec of -11.8s !!!:
+ * tv_sec = -4 <----- -1 * 3.8 is rounded down when converting a double to an int!
+ * tv_nsec = -7 800 000 000 <----- -1 * (3.8 - -4)*1e9
+ */
+/* NOTE: Due to the fact that the C compiler may round a tv_sec number away from zero,
+ * the following macro may result in a timespec that is not normalized, i.e. with a tv_sec > 0, and a tv_nsec < 0 !!!!
+ * This is due to the rounding that C compiler applies when converting a (long double) to a (long int).
+ * To produce normalized timespec's we need to use floor(), but we cannot call any library functions since we want this macro to be
+ * useable as a variable initializer.
+ * VAR x : TIME = T#3.5h; END_VAR ---> IEC_TIME x = __time_to_timespec(1, 0, 0, 0, 3.5, 0);
+ */
+/*
+static inline IEC_TIMESPEC __time_to_timespec(int sign, double mseconds, double seconds, double minutes, double hours, double days) {
+ IEC_TIMESPEC ts;
+
+ // sign is 1 for positive values, -1 for negative time...
+ long double total_sec = ((days*24 + hours)*60 + minutes)*60 + seconds + mseconds/1e3;
+ if (sign >= 0) sign = 1; else sign = -1;
+ ts.tv_sec = sign * (long int)total_sec;
+ ts.tv_nsec = sign * (long int)((total_sec - ts.tv_sec)*1e9);
+
+ return ts;
+}
+*/
+/* NOTE: Unfortunately older versions of ANSI C (e.g. C99) do not allow explicit identification of elements in initializers
+ * e.g. {tv_sec = 1, tv_nsec = 300}
+ * They are therefore commented out. This however means that any change to the definition of IEC_TIMESPEC may require this
+ * macro to be updated too!
+ */
+#define __time_to_timespec(sign,mseconds,seconds,minutes,hours,days) \
+ ((IEC_TIMESPEC){\
+ /*tv_sec =*/ ((long int) (((sign>=0)?1:-1)*((((long double)days*24 + (long double)hours)*60 + (long double)minutes)*60 + (long double)seconds + (long double)mseconds/1e3))), \
+ /*tv_nsec =*/ ((long int)(( \
+ ((long double)(((sign>=0)?1:-1)*((((long double)days*24 + (long double)hours)*60 + (long double)minutes)*60 + (long double)seconds + (long double)mseconds/1e3))) - \
+ ((long int) (((sign>=0)?1:-1)*((((long double)days*24 + (long double)hours)*60 + (long double)minutes)*60 + (long double)seconds + (long double)mseconds/1e3))) \
+ )*1e9))\
+ })
+
+
+
+
+/* NOTE: The following function was turned into a macro, so it could be used to initialize the initial value of TOD (TIME_OF_DAY) variables */
+/* NOTE: many (but not all) of the same comments made regarding __time_to_timespec() are also valid here, so go and read those comments too!
+/*
+static inline IEC_TIMESPEC __tod_to_timespec(double seconds, double minutes, double hours) {
+ IEC_TIMESPEC ts;
+
+ long double total_sec = (hours*60 + minutes)*60 + seconds;
+ ts.tv_sec = (long int)total_sec;
+ ts.tv_nsec = (long int)((total_sec - ts.tv_sec)*1e9);
+
+ return ts;
+}
+*/
+#define __tod_to_timespec(seconds,minutes,hours) \
+ ((IEC_TIMESPEC){\
+ /*tv_sec =*/ ((long int) ((((long double)hours)*60 + (long double)minutes)*60 + (long double)seconds)), \
+ /*tv_nsec =*/ ((long int)(( \
+ ((long double)((((long double)hours)*60 + (long double)minutes)*60 + (long double)seconds)) - \
+ ((long int) ((((long double)hours)*60 + (long double)minutes)*60 + (long double)seconds)) \
+ )*1e9))\
+ })
+
+
+#define EPOCH_YEAR 1970
+#define SECONDS_PER_MINUTE 60
+#define SECONDS_PER_HOUR (60 * SECONDS_PER_MINUTE)
+#define SECONDS_PER_DAY (24 * SECONDS_PER_HOUR)
+#define __isleap(year) \
+ ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
+static const unsigned short int __mon_yday[2][13] =
+{
+ /* Normal years. */
+ { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
+ /* Leap years. */
+ { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}
+};
+
+typedef struct {
+ int tm_sec; /* Seconds. [0-60] (1 leap second) */
+ int tm_min; /* Minutes. [0-59] */
+ int tm_hour; /* Hours. [0-23] */
+ int tm_day; /* Day. [1-31] */
+ int tm_mon; /* Month. [0-11] */
+ int tm_year; /* Year */
+} tm;
+
+static inline tm convert_seconds_to_date_and_time(long int seconds) {
+ tm dt;
+ long int days, rem;
+ days = seconds / SECONDS_PER_DAY;
+ rem = seconds % SECONDS_PER_DAY;
+ if (rem < 0) {
+ rem += SECONDS_PER_DAY;
+ days--;
+ }
+
+ // time of day
+ dt.tm_hour = rem / SECONDS_PER_HOUR;
+ rem %= SECONDS_PER_HOUR;
+ dt.tm_min = rem / 60;
+ dt.tm_sec = rem % 60;
+
+ // date
+ dt.tm_year = EPOCH_YEAR;
+ while (days >= (rem = __isleap(dt.tm_year) ? 366 : 365)) {
+ dt.tm_year++;
+ days -= rem;
+ }
+ while (days < 0) {
+ dt.tm_year--;
+ days += __isleap(dt.tm_year) ? 366 : 365;
+ }
+ dt.tm_mon = 1;
+ while (days > __mon_yday[__isleap(dt.tm_year)][dt.tm_mon]) {
+ dt.tm_mon += 1;
+ }
+ dt.tm_day = days - __mon_yday[__isleap(dt.tm_year)][dt.tm_mon - 1] + 1;
+
+ return dt;
+}
+
+static inline IEC_TIMESPEC __date_to_timespec(int day, int month, int year) {
+ IEC_TIMESPEC ts;
+ int a4, b4, a100, b100, a400, b400;
+ int yday;
+ int intervening_leap_days;
+
+ if (month < 1 || month > 12)
+ __iec_error();
+
+ yday = __mon_yday[__isleap(year)][month - 1] + day;
+
+ if (yday > __mon_yday[__isleap(year)][month])
+ __iec_error();
+
+ a4 = (year >> 2) - ! (year & 3);
+ b4 = (EPOCH_YEAR >> 2) - ! (EPOCH_YEAR & 3);
+ a100 = a4 / 25 - (a4 % 25 < 0);
+ b100 = b4 / 25 - (b4 % 25 < 0);
+ a400 = a100 >> 2;
+ b400 = b100 >> 2;
+ intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
+
+ ts.tv_sec = ((year - EPOCH_YEAR) * 365 + intervening_leap_days + yday - 1) * 24 * 60 * 60;
+ ts.tv_nsec = 0;
+
+ return ts;
+}
+
+static inline IEC_TIMESPEC __dt_to_timespec(double seconds, double minutes, double hours, int day, int month, int year) {
+ IEC_TIMESPEC ts_date = __date_to_timespec(day, month, year);
+ IEC_TIMESPEC ts = __tod_to_timespec(seconds, minutes, hours);
+
+ ts.tv_sec += ts_date.tv_sec;
+
+ return ts;
+}
+
+/*******************/
+/* Time operations */
+/*******************/
+
+#define __time_cmp(t1, t2) (t2.tv_sec == t1.tv_sec ? t1.tv_nsec - t2.tv_nsec : t1.tv_sec - t2.tv_sec)
+
+static inline TIME __time_add(TIME IN1, TIME IN2){
+ TIME res ={IN1.tv_sec + IN2.tv_sec,
+ IN1.tv_nsec + IN2.tv_nsec };
+ __normalize_timespec(&res);
+ return res;
+}
+static inline TIME __time_sub(TIME IN1, TIME IN2){
+ TIME res ={IN1.tv_sec - IN2.tv_sec,
+ IN1.tv_nsec - IN2.tv_nsec };
+ __normalize_timespec(&res);
+ return res;
+}
+static inline TIME __time_mul(TIME IN1, LREAL IN2){
+ LREAL s_f = IN1.tv_sec * IN2;
+ time_t s = (time_t)s_f;
+ div_t ns = div((int)((LREAL)IN1.tv_nsec * IN2), 1000000000);
+ TIME res = {(long)s + ns.quot,
+ (long)ns.rem + (s_f - s) * 1000000000 };
+ __normalize_timespec(&res);
+ return res;
+}
+static inline TIME __time_div(TIME IN1, LREAL IN2){
+ LREAL s_f = IN1.tv_sec / IN2;
+ time_t s = (time_t)s_f;
+ TIME res = {(long)s,
+ (long)(IN1.tv_nsec / IN2 + (s_f - s) * 1000000000) };
+ __normalize_timespec(&res);
+ return res;
+}
+
+
+/***************/
+/* Convertions */
+/***************/
+ /*****************/
+ /* REAL_TO_INT */
+ /*****************/
+static inline LINT __real_round(LREAL IN) {
+ return fmod(IN, 1) == 0 ? ((LINT)IN / 2) * 2 : (LINT)IN;
+}
+static inline LINT __preal_to_sint(LREAL IN) {
+ return IN >= 0 ? __real_round(IN + 0.5) : __real_round(IN - 0.5);
+}
+static inline LINT __preal_to_uint(LREAL IN) {
+ return IN >= 0 ? __real_round(IN + 0.5) : 0;
+}
+static inline LINT __real_to_sint(LREAL IN) {return (LINT)__preal_to_sint(IN);}
+static inline LWORD __real_to_bit(LREAL IN) {return (LWORD)__preal_to_uint(IN);}
+static inline ULINT __real_to_uint(LREAL IN) {return (ULINT)__preal_to_uint(IN);}
+
+ /***************/
+ /* TO_STRING */
+ /***************/
+static inline STRING __bool_to_string(BOOL IN) {
+ if(IN) return (STRING){4, "TRUE"};
+ return (STRING){5,"FALSE"};
+}
+static inline STRING __bit_to_string(LWORD IN) {
+ STRING res;
+ res = __INIT_STRING;
+ res.len = snprintf((char*)res.body, STR_MAX_LEN, "16#%llx",(long long unsigned int)IN);
+ if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
+ return res;
+}
+static inline STRING __real_to_string(LREAL IN) {
+ STRING res;
+ res = __INIT_STRING;
+ res.len = snprintf((char*)res.body, STR_MAX_LEN, "%.10g", IN);
+ if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
+ return res;
+}
+static inline STRING __sint_to_string(LINT IN) {
+ STRING res;
+ res = __INIT_STRING;
+ res.len = snprintf((char*)res.body, STR_MAX_LEN, "%lld", (long long int)IN);
+ if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
+ return res;
+}
+static inline STRING __uint_to_string(ULINT IN) {
+ STRING res;
+ res = __INIT_STRING;
+ res.len = snprintf((char*)res.body, STR_MAX_LEN, "%llu", (long long unsigned int)IN);
+ if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
+ return res;
+}
+ /***************/
+ /* FROM_STRING */
+ /***************/
+static inline BOOL __string_to_bool(STRING IN) {
+ int i;
+ if (IN.len == 1) return !memcmp(&IN.body,"1", IN.len);
+ for (i = 0; i < IN.len; i++) IN.body[i] = toupper(IN.body[i]);
+ return IN.len == 4 ? !memcmp(&IN.body,"TRUE", IN.len) : 0;
+}
+
+static inline LINT __pstring_to_sint(STRING* IN) {
+ LINT res = 0;
+ __strlen_t l;
+ unsigned int shift = 0;
+
+ if(IN->body[0]=='2' && IN->body[1]=='#'){
+ /* 2#0101_1010_1011_1111 */
+ for(l = IN->len - 1; l >= 2 && shift < 64; l--)
+ {
+ char c = IN->body[l];
+ if( c >= '0' && c <= '1'){
+ res |= ( c - '0') << shift;
+ shift += 1;
+ }
+ }
+ }else if(IN->body[0]=='8' && IN->body[1]=='#'){
+ /* 8#1234_5665_4321 */
+ for(l = IN->len - 1; l >= 2 && shift < 64; l--)
+ {
+ char c = IN->body[l];
+ if( c >= '0' && c <= '7'){
+ res |= ( c - '0') << shift;
+ shift += 3;
+ }
+ }
+ }else if(IN->body[0]=='1' && IN->body[1]=='6' && IN->body[2]=='#'){
+ /* 16#1234_5678_9abc_DEFG */
+ for(l = IN->len - 1; l >= 3 && shift < 64; l--)
+ {
+ char c = IN->body[l];
+ if( c >= '0' && c <= '9'){
+ res |= (LWORD)( c - '0') << shift;
+ shift += 4;
+ }else if( c >= 'a' && c <= 'f'){
+ res |= (LWORD)( c - 'a' + 10 ) << shift;
+ shift += 4;
+ }else if( c >= 'A' && c <= 'F'){
+ res |= (LWORD)( c - 'A' + 10 ) << shift;
+ shift += 4;
+ }
+ }
+ }else{
+ /* -123456789 */
+ LINT fac = IN->body[0] == '-' ? -1 : 1;
+ for(l = IN->len - 1; l >= 0 && shift < 20; l--)
+ {
+ char c = IN->body[l];
+ if( c >= '0' && c <= '9'){
+ res += ( c - '0') * fac;
+ fac *= 10;
+ shift += 1;
+ }else if( c >= '.' ){ /* reset value */
+ res = 0;
+ fac = IN->body[0] == '-' ? -1 : 1;
+ shift = 0;
+ }
+ }
+ }
+ return res;
+}
+
+static inline LINT __string_to_sint(STRING IN) {return (LINT)__pstring_to_sint(&IN);}
+static inline LWORD __string_to_bit (STRING IN) {return (LWORD)__pstring_to_sint(&IN);}
+static inline ULINT __string_to_uint(STRING IN) {return (ULINT)__pstring_to_sint(&IN);}
+static inline LREAL __string_to_real(STRING IN) {
+ __strlen_t l;
+ l = IN.len;
+ /* search the dot */
+ while(--l > 0 && IN.body[l] != '.');
+ if(l != 0){
+ return atof((const char *)&IN.body);
+ }else{
+ return (LREAL)__pstring_to_sint(&IN);
+ }
+}
+
+ /***************/
+ /* TO_TIME */
+ /***************/
+static inline TIME __int_to_time(LINT IN) {return (TIME){IN, 0};}
+static inline TIME __real_to_time(LREAL IN) {return (TIME){IN, (IN - (LINT)IN) * 1000000000};}
+static inline TIME __string_to_time(STRING IN){
+ __strlen_t l;
+ /* TODO :
+ *
+ * Duration literals without underlines: T#14ms T#-14ms T#14.7s T#14.7m
+ * short prefix T#14.7h t#14.7d t#25h15m
+ * t#5d14h12m18s3.5ms
+ * long prefix TIME#14ms TIME#-14ms time#14.7s
+ * Duration literals with underlines:
+ * short prefix t#25h_15m t#5d_14h_12m_18s_3.5ms
+ * long prefix TIME#25h_15m
+ * time#5d_14h_12m_18s_3.5ms
+ *
+ * Long prefix notation Short prefix notation
+ * DATE#1984-06-25 D#1984-06-25
+ * date#1984-06-25 d#1984-06-25
+ * TIME_OF_DAY#15:36:55.36 TOD#15:36:55.36
+ * time_of_day#15:36:55.36 tod#15:36:55.36
+ * DATE_AND_TIME#1984-06-25-15:36:55.36 DT#1984-06-25-15:36:55.36
+ * date_and_time#1984-06-25-15:36:55.36 dt#1984-06-25-15:36:55.36
+ *
+ */
+ /* Quick hack : only transform seconds */
+ /* search the dot */
+ l = IN.len;
+ while(--l > 0 && IN.body[l] != '.');
+ if(l != 0){
+ LREAL IN_val = atof((const char *)&IN.body);
+ return (TIME){(long)IN_val, (long)(IN_val - (LINT)IN_val)*1000000000};
+ }else{
+ return (TIME){(long)__pstring_to_sint(&IN), 0};
+ }
+}
+
+ /***************/
+ /* FROM_TIME */
+ /***************/
+static inline LREAL __time_to_real(TIME IN){
+ return (LREAL)IN.tv_sec + ((LREAL)IN.tv_nsec/1000000000);
+}
+static inline LINT __time_to_int(TIME IN) {return IN.tv_sec;}
+static inline STRING __time_to_string(TIME IN){
+ STRING res;
+ div_t days;
+ /*t#5d14h12m18s3.5ms*/
+ res = __INIT_STRING;
+ days = div(IN.tv_sec, SECONDS_PER_DAY);
+ if(!days.rem && IN.tv_nsec == 0){
+ res.len = snprintf((char*)&res.body, STR_MAX_LEN, "T#%dd", days.quot);
+ }else{
+ div_t hours = div(days.rem, SECONDS_PER_HOUR);
+ if(!hours.rem && IN.tv_nsec == 0){
+ res.len = snprintf((char*)&res.body, STR_MAX_LEN, "T#%dd%dh", days.quot, hours.quot);
+ }else{
+ div_t minuts = div(hours.rem, SECONDS_PER_MINUTE);
+ if(!minuts.rem && IN.tv_nsec == 0){
+ res.len = snprintf((char*)&res.body, STR_MAX_LEN, "T#%dd%dh%dm", days.quot, hours.quot, minuts.quot);
+ }else{
+ if(IN.tv_nsec == 0){
+ res.len = snprintf((char*)&res.body, STR_MAX_LEN, "T#%dd%dh%dm%ds", days.quot, hours.quot, minuts.quot, minuts.rem);
+ }else{
+ res.len = snprintf((char*)&res.body, STR_MAX_LEN, "T#%dd%dh%dm%ds%gms", days.quot, hours.quot, minuts.quot, minuts.rem, (LREAL)IN.tv_nsec / 1000000);
+ }
+ }
+ }
+ }
+ if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
+ return res;
+}
+static inline STRING __date_to_string(DATE IN){
+ STRING res;
+ tm broken_down_time;
+ /* D#1984-06-25 */
+ broken_down_time = convert_seconds_to_date_and_time(IN.tv_sec);
+ res = __INIT_STRING;
+ res.len = snprintf((char*)&res.body, STR_MAX_LEN, "D#%d-%2.2d-%2.2d",
+ broken_down_time.tm_year,
+ broken_down_time.tm_mon,
+ broken_down_time.tm_day);
+ if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
+ return res;
+}
+static inline STRING __tod_to_string(TOD IN){
+ STRING res;
+ tm broken_down_time;
+ time_t seconds;
+ /* TOD#15:36:55.36 */
+ seconds = IN.tv_sec;
+ if (seconds >= SECONDS_PER_DAY){
+ __iec_error();
+ return (STRING){9,"TOD#ERROR"};
+ }
+ broken_down_time = convert_seconds_to_date_and_time(seconds);
+ res = __INIT_STRING;
+ if(IN.tv_nsec == 0){
+ res.len = snprintf((char*)&res.body, STR_MAX_LEN, "TOD#%2.2d:%2.2d:%2.2d",
+ broken_down_time.tm_hour,
+ broken_down_time.tm_min,
+ broken_down_time.tm_sec);
+ }else{
+ res.len = snprintf((char*)&res.body, STR_MAX_LEN, "TOD#%2.2d:%2.2d:%09.6f",
+ broken_down_time.tm_hour,
+ broken_down_time.tm_min,
+ (LREAL)broken_down_time.tm_sec + (LREAL)IN.tv_nsec / 1e9);
+ }
+ if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
+ return res;
+}
+static inline STRING __dt_to_string(DT IN){
+ STRING res;
+ tm broken_down_time;
+ /* DT#1984-06-25-15:36:55.36 */
+ broken_down_time = convert_seconds_to_date_and_time(IN.tv_sec);
+ if(IN.tv_nsec == 0){
+ res.len = snprintf((char*)&res.body, STR_MAX_LEN, "DT#%d-%2.2d-%2.2d-%2.2d:%2.2d:%2.2d",
+ broken_down_time.tm_year,
+ broken_down_time.tm_mon,
+ broken_down_time.tm_day,
+ broken_down_time.tm_hour,
+ broken_down_time.tm_min,
+ broken_down_time.tm_sec);
+ }else{
+ res.len = snprintf((char*)&res.body, STR_MAX_LEN, "DT#%d-%2.2d-%2.2d-%2.2d:%2.2d:%09.6f",
+ broken_down_time.tm_year,
+ broken_down_time.tm_mon,
+ broken_down_time.tm_day,
+ broken_down_time.tm_hour,
+ broken_down_time.tm_min,
+ (LREAL)broken_down_time.tm_sec + ((LREAL)IN.tv_nsec / 1e9));
+ }
+ if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
+ return res;
+}
+
+ /**********************************************/
+ /* [ANY_DATE | TIME] _TO_ [ANY_DATE | TIME] */
+ /**********************************************/
+
+static inline TOD __date_and_time_to_time_of_day(DT IN) {
+ return (TOD){
+ IN.tv_sec % SECONDS_PER_DAY + (IN.tv_sec < 0 ? SECONDS_PER_DAY : 0),
+ IN.tv_nsec};
+}
+static inline DATE __date_and_time_to_date(DT IN){
+ return (DATE){
+ IN.tv_sec - IN.tv_sec % SECONDS_PER_DAY - (IN.tv_sec < 0 ? SECONDS_PER_DAY : 0),
+ 0};
+}
+
+ /*****************/
+ /* FROM/TO BCD */
+ /*****************/
+
+static inline BOOL __test_bcd(LWORD IN) {
+ while (IN) {
+ if ((IN & 0xf) > 9) return 1;
+ IN >>= 4;
+ }
+ return 0;
+}
+
+static inline ULINT __bcd_to_uint(LWORD IN){
+ ULINT res = IN & 0xf;
+ ULINT factor = 10ULL;
+
+ while (IN >>= 4) {
+ res += (IN & 0xf) * factor;
+ factor *= 10;
+ }
+ return res;
+}
+
+static inline LWORD __uint_to_bcd(ULINT IN){
+ LWORD res = IN % 10;
+ USINT shift = 4;
+
+ while (IN /= 10) {
+ res |= (IN % 10) << shift;
+ shift += 4;
+ }
+ return res;
+}
+
+
+ /************/
+ /* MOVE_* */
+ /************/
+
+/* some helpful __move_[ANY] functions, used in the *_TO_** and MOVE standard functions */
+/* e.g. __move_BOOL, __move_BYTE, __move_REAL, __move_TIME, ... */
+#define __move_(TYPENAME)\
+static inline TYPENAME __move_##TYPENAME(TYPENAME op1) {return op1;}
+__ANY(__move_)
+
+
+
+/*****************************************************************/
+/*****************************************************************/
+/***** *****/
+/***** IEC 61131-3 *****/
+/***** S T A N D A R D F U N C T I O N S *****/
+/***** *****/
+/*****************************************************************/
+/*****************************************************************/
+
+/* NOTE: If you want to know what all these strange macros are doing,
+ * just parse this file through a C preprocessor, and analyse the output!
+ * $gcc -E iec_std_lib.h
+ */
+
+/* NOTE: We only define and declare the explicitly typed standard functions
+ * (e.g., SIN_REAL, SIN_LREAL, ..., ADD_SINT, ADD_INT, ADD_LINT, ...)
+ * We do not declare/define the overloaded functions
+ * (SIN, ADD, ...).
+ * When handling a call to an overloaded function, the iec2c compiler
+ * will determine in stage3 the data type of the parameter being passed,
+ * and in stage4 generate the C code to call the correct
+ * typed standard function.
+ */
+
+/* NOTE on explicit typing of:
+ * - Table 25 - Standard bit shift functions
+ * - Table 29 - Character string Functions
+ *
+ * In section 2.5.1.4 (Typing, overloading, and type conversion) of the IEC 61131-3 (version 2)
+ * of the standard, it is stated:
+ * "A standard function, [...] is said to be overloaded when it
+ * can operate on input data elements of various types within a generic type designator as defined in
+ * 2.3.2. For instance, an overloaded addition function on generic type ANY_NUM can operate on data
+ * of types LREAL, REAL, DINT, INT, and SINT."
+ * [...]
+ * "When a function which normally represents an overloaded operator is to be typed, i.e., the types
+ * of its inputs and outputs restricted to a particular elementary or derived data type as defined in
+ * 2.3, this shall be done by appending an "underline" character followed by the required type, as
+ * shown in table 21."
+ *
+ * However, this explanation (as well as the example in table 21) only refers to functions where the same
+ * generic data type is used for the single input and the output parameter.
+ * How can we create explicitly types functions when this is not the case?
+ * It does not seem to be covered by the standard.
+ *
+ * For this reason, we do not define the LEN_SINT, LEN_INT, LEN_STRING, LEN_[ANY_INT], LEN_[ANY_STRING] functions...
+ */
+
+
+/********************/
+/* EN/ENO PARAMS */
+/********************/
+
+#define EN_ENO_PARAMS BOOL EN, BOOL *ENO
+#define EN_ENO EN, ENO
+
+#define TEST_EN(TYPENAME)\
+ if (!EN) {\
+ if (ENO != NULL)\
+ *ENO = __BOOL_LITERAL(FALSE);\
+ return __INIT_##TYPENAME;\
+ }\
+ else if (ENO != NULL)\
+ *ENO = __BOOL_LITERAL(TRUE);
+
+#define TEST_EN_COND(TYPENAME, COND)\
+ if (!EN || (COND)) {\
+ if (ENO != NULL)\
+ *ENO = __BOOL_LITERAL(FALSE);\
+ return __INIT_##TYPENAME;\
+ }\
+ else if (ENO != NULL)\
+ *ENO = __BOOL_LITERAL(TRUE);
+
+
+
+/*****************************************/
+/*****************************************/
+/* 2.5.1.5.1 Type Conversion Functions */
+/*****************************************/
+/*****************************************/
+
+#define __convert_type(from_TYPENAME,to_TYPENAME, oper) \
+static inline to_TYPENAME from_TYPENAME##_TO_##to_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\
+ TEST_EN(to_TYPENAME)\
+ return (to_TYPENAME)oper(op);\
+}
+
+/******** [ANY_NUM | ANY_NBIT]_TO_BOOL ************/
+#define __convert_num_to_bool(TYPENAME) \
+static inline BOOL TYPENAME##_TO_BOOL(EN_ENO_PARAMS, TYPENAME op){\
+ TEST_EN(BOOL)\
+ return op == 0 ? 0 : 1;\
+}
+__ANY_NUM(__convert_num_to_bool)
+__ANY_NBIT(__convert_num_to_bool)
+
+/******** [TIME | ANY_DATE]_TO_BOOL ************/
+#define __convert_time_to_bool(TYPENAME) \
+static inline BOOL TYPENAME##_TO_BOOL(EN_ENO_PARAMS, TYPENAME op){\
+ TEST_EN(BOOL)\
+ return op.tv_sec == 0 && op.tv_nsec == 0 ? 0 : 1;\
+}
+__convert_time_to_bool(TIME)
+__ANY_DATE(__convert_time_to_bool)
+
+#define __to_anynum_(from_TYPENAME) __ANY_NUM_1(__iec_,from_TYPENAME)
+#define __to_anyint_(from_TYPENAME) __ANY_INT_1(__iec_,from_TYPENAME)
+#define __to_anybit_(from_TYPENAME) __ANY_BIT_1(__iec_,from_TYPENAME)
+#define __to_anynbit_(from_TYPENAME) __ANY_NBIT_1(__iec_,from_TYPENAME)
+#define __to_anysint_(from_TYPENAME) __ANY_SINT_1(__iec_,from_TYPENAME)
+#define __to_anyuint_(from_TYPENAME) __ANY_UINT_1(__iec_,from_TYPENAME)
+#define __to_anyreal_(from_TYPENAME) __ANY_REAL_1(__iec_,from_TYPENAME)
+#define __to_anydate_(from_TYPENAME) __ANY_DATE_1(__iec_,from_TYPENAME)
+
+/******** [ANY_BIT]_TO_[ANY_NUM | ANT_NBIT] ************/
+#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __move_##to_TYPENAME)
+__ANY_BIT(__to_anynum_)
+__ANY_BIT(__to_anynbit_)
+#undef __iec_
+
+/******** [ANY_INT]_TO_[ANY_NUM | ANT_NBIT] ************/
+#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __move_##to_TYPENAME)
+__ANY_INT(__to_anynum_)
+__ANY_INT(__to_anynbit_)
+#undef __iec_
+
+/******** [ANY_REAL]_TO_[ANY_NBIT] ************/
+#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_bit)
+__ANY_REAL(__to_anynbit_)
+#undef __iec_
+
+/******** [ANY_REAL]_TO_[ANY_NINT] ************/
+#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_sint)
+__ANY_REAL(__to_anysint_)
+#undef __iec_
+#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_uint)
+__ANY_REAL(__to_anyuint_)
+#undef __iec_
+
+/******** [ANY_REAL]_TO_[ANY_REAL] ************/
+#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __move_##to_TYPENAME)
+__ANY_REAL(__to_anyreal_)
+#undef __iec_
+
+/******** [ANY_BIT | ANY_INT]_TO_[TIME | ANY_DATE] ************/
+#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, TIME, __int_to_time)
+__ANY_BIT(__iec_)
+__ANY_INT(__iec_)
+#undef __iec_
+#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __int_to_time)
+__ANY_BIT(__to_anydate_)
+__ANY_INT(__to_anydate_)
+#undef __iec_
+
+/******** [ANY_REAL]_TO_[TIME | ANY_DATE] ************/
+#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, TIME, __real_to_time)
+__ANY_REAL(__iec_)
+#undef __iec_
+#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_time)
+__ANY_REAL(__to_anydate_)
+#undef __iec_
+
+/******** [TIME | ANY_DATE]_TO_[ANY_BIT | ANY_INT] ************/
+#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __time_to_int)
+__to_anyint_(TIME)
+__to_anynbit_(TIME)
+__ANY_DATE(__to_anyint_)
+__ANY_DATE(__to_anynbit_)
+#undef __iec_
+
+/******** [TIME | ANY_DATE]_TO_[ANY_REAL] ************/
+#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __time_to_real)
+__to_anyreal_(TIME)
+__ANY_DATE(__to_anyreal_)
+#undef __iec_
+
+
+/******** [ANY_DATE]_TO_[ANY_DATE | TIME] ************/
+/* Not supported: DT_TO_TIME */
+__convert_type(DT, DATE, __date_and_time_to_date)
+static inline DATE DATE_AND_TIME_TO_DATE(EN_ENO_PARAMS, DT op){
+ return DT_TO_DATE(EN_ENO, op);
+}
+__convert_type(DT, DT, __move_DT)
+__convert_type(DT, TOD, __date_and_time_to_time_of_day)
+static inline DATE DATE_AND_TIME_TO_TIME_OF_DAY(EN_ENO_PARAMS, DT op){
+ return DT_TO_TOD(EN_ENO, op);
+}
+/* Not supported: DATE_TO_TIME */
+__convert_type(DATE, DATE, __move_DATE)
+/* Not supported: DATE_TO_DT */
+/* Not supported: DATE_TO_TOD */
+/* Not supported: TOD_TO_TIME */
+/* Not supported: TOD_TO_DATE */
+/* Not supported: TOD_TO_DT */
+__convert_type(TOD, TOD, __move_TOD)
+
+
+/******** TIME_TO_[ANY_DATE] ************/
+/* Not supported: TIME_TO_DATE */
+/* Not supported: TIME_TO_DT */
+/* Not supported: TIME_TO_TOD */
+
+/******** TIME_TO_TIME ************/
+__convert_type(TIME, TIME, __move_TIME)
+
+
+/******** [ANY_BIT]_TO_STRING ************/
+__convert_type(BOOL, STRING, __bool_to_string)
+#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __bit_to_string)
+__ANY_NBIT(__iec_)
+#undef __iec_
+
+/******** [ANY_INT]_TO_STRING ************/
+#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __sint_to_string)
+__ANY_SINT(__iec_)
+#undef __iec_
+#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __uint_to_string)
+__ANY_UINT(__iec_)
+#undef __iec_
+
+/******** [ANY_REAL]_TO_STRING ************/
+#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __real_to_string)
+__ANY_REAL(__iec_)
+#undef __iec_
+
+/******** [ANY_DATE]_TO_STRING ************/
+__convert_type(DATE, STRING, __date_to_string)
+__convert_type(DT, STRING, __dt_to_string)
+__convert_type(TOD, STRING, __tod_to_string)
+
+/******** TIME_TO_STRING ************/
+__convert_type(TIME, STRING, __time_to_string)
+
+
+/******** STRING_TO_[ANY_BIT] ************/
+__convert_type(STRING, BOOL, __string_to_bool)
+#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_bit)
+__ANY_NBIT(__iec_)
+#undef __iec_
+
+/******** STRING_TO_[ANY_INT] ************/
+#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_sint)
+__ANY_SINT(__iec_)
+#undef __iec_
+#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_uint)
+__ANY_UINT(__iec_)
+#undef __iec_
+
+/******** STRING_TO_[ANY_REAL] ************/
+#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_real)
+__ANY_REAL(__iec_)
+#undef __iec_
+
+/******** STRING_TO_[ANY_DATE] ************/
+#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_time)
+__ANY_DATE(__iec_)
+#undef __iec_
+
+/******** STRING_TO_TIME ************/
+__convert_type(STRING, TIME, __string_to_time)
+
+
+/******** TRUNC ************/
+#define __iec_(to_TYPENAME,from_TYPENAME) \
+static inline to_TYPENAME TRUNC__##to_TYPENAME##__##from_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\
+ TEST_EN(to_TYPENAME)\
+ return (to_TYPENAME)__move_##to_TYPENAME(op);\
+}
+__ANY_REAL(__to_anyint_)
+#undef __iec_
+
+
+/******** _TO_BCD ************/
+#define __iec_(to_TYPENAME,from_TYPENAME) \
+static inline to_TYPENAME from_TYPENAME##_TO_BCD_##to_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\
+ TEST_EN(to_TYPENAME)\
+ return (to_TYPENAME)__uint_to_bcd(op);\
+}\
+static inline to_TYPENAME from_TYPENAME##_TO_BCD__##to_TYPENAME##__##from_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\
+ return from_TYPENAME##_TO_BCD_##to_TYPENAME(EN_ENO, op);\
+}
+__ANY_UINT(__to_anynbit_)
+#undef __iec_
+
+
+/******** BCD_TO_ ************/
+#define __iec_(to_TYPENAME,from_TYPENAME) \
+static inline to_TYPENAME from_TYPENAME##_BCD_TO_##to_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\
+ TEST_EN_COND(to_TYPENAME, __test_bcd(op))\
+ return (to_TYPENAME)__bcd_to_uint(op);\
+}\
+static inline to_TYPENAME BCD_TO_##to_TYPENAME##__##to_TYPENAME##__##from_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\
+ return from_TYPENAME##_BCD_TO_##to_TYPENAME(EN_ENO, op);\
+}
+__ANY_NBIT(__to_anyuint_)
+#undef __iec_
+
+
+/***********************************/
+/***********************************/
+/* 2.5.1.5.2 Numerical Functions */
+/***********************************/
+/***********************************/
+
+/* workaround for va-args limitation on shorter than int params */
+#define VA_ARGS_REAL LREAL
+#define VA_ARGS_LREAL LREAL
+#define VA_ARGS_SINT DINT
+#define VA_ARGS_INT DINT
+#define VA_ARGS_DINT DINT
+#define VA_ARGS_LINT LINT
+#define VA_ARGS_USINT UDINT
+#define VA_ARGS_UINT UDINT
+#define VA_ARGS_UDINT UDINT
+#define VA_ARGS_ULINT ULINT
+#define VA_ARGS_TIME TIME
+#define VA_ARGS_BOOL DWORD
+#define VA_ARGS_BYTE DWORD
+#define VA_ARGS_WORD DWORD
+#define VA_ARGS_DWORD DWORD
+#define VA_ARGS_LWORD LWORD
+#define VA_ARGS_STRING STRING
+#define VA_ARGS_WSTRING WSTRING
+#define VA_ARGS_DATE DATE
+#define VA_ARGS_TOD TOD
+#define VA_ARGS_DT DT
+
+
+#define __numeric(fname,TYPENAME, FUNC) \
+/* explicitly typed function */\
+static inline TYPENAME fname##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\
+ TEST_EN(TYPENAME)\
+ return FUNC(op);\
+}\
+/* overloaded function */\
+static inline TYPENAME fname##_##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op) {\
+ return fname##TYPENAME(EN_ENO, op);\
+}
+
+/******************************************************************/
+/*** Table 23 - Standard functions of one numeric variable ***/
+/******************************************************************/
+
+ /**************/
+ /* ABS */
+ /**************/
+#define __abs_signed(TYPENAME) \
+/* explicitly typed function */\
+static inline TYPENAME ABS_##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\
+ TEST_EN(TYPENAME)\
+ if (op < 0)\
+ return -op;\
+ return op;\
+}\
+/* overloaded function */\
+static inline TYPENAME ABS__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op) {\
+ return ABS_##TYPENAME(EN_ENO, op);\
+}
+
+#define __abs_unsigned(TYPENAME) \
+/* explicitly typed function */\
+static inline TYPENAME ABS_##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\
+ TEST_EN(TYPENAME)\
+ return op;\
+}\
+/* overloaded function */\
+static inline TYPENAME ABS__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op) {\
+ return ABS_##TYPENAME(EN_ENO, op);\
+}
+
+__ANY_REAL(__abs_signed)
+__ANY_SINT(__abs_signed)
+__ANY_UINT(__abs_unsigned)
+
+
+ /**************/
+ /* SQRT */
+ /**************/
+#define __sqrt(TYPENAME) __numeric(SQRT_, TYPENAME, sqrt)
+__ANY_REAL(__sqrt)
+
+
+/**************/
+ /* LN */
+ /**************/
+#define __ln(TYPENAME) __numeric(LN_, TYPENAME, log)
+__ANY_REAL(__ln)
+
+
+ /**************/
+ /* LOG */
+ /**************/
+#define __log(TYPENAME) __numeric(LOG_, TYPENAME, log10)
+__ANY_REAL(__log)
+
+
+ /**************/
+ /* EXP */
+ /**************/
+#define __exp(TYPENAME) __numeric(EXP_, TYPENAME, exp)
+__ANY_REAL(__exp)
+
+
+ /**************/
+ /* SIN */
+ /**************/
+#define __sin(TYPENAME) __numeric(SIN_, TYPENAME, sin)
+__ANY_REAL(__sin)
+
+
+ /**************/
+ /* COS */
+ /**************/
+#define __cos(TYPENAME) __numeric(COS_, TYPENAME, cos)
+__ANY_REAL(__cos)
+
+ /**************/
+ /* TAN */
+ /**************/
+#define __tan(TYPENAME) __numeric(TAN_, TYPENAME, tan)
+__ANY_REAL(__tan)
+
+
+ /**************/
+ /* ASIN */
+ /**************/
+#define __asin(TYPENAME) __numeric(ASIN_, TYPENAME, asin)
+__ANY_REAL(__asin)
+
+ /**************/
+ /* ACOS */
+ /**************/
+#define __acos(TYPENAME) __numeric(ACOS_, TYPENAME, acos)
+__ANY_REAL(__acos)
+
+ /**************/
+ /* ATAN */
+ /**************/
+#define __atan(TYPENAME) __numeric(ATAN_, TYPENAME, atan)
+__ANY_REAL(__atan)
+
+
+
+/*****************************************************/
+/*** Table 24 - Standard arithmetic functions ***/
+/*****************************************************/
+
+#define __arith_expand(fname,TYPENAME, OP)\
+static inline TYPENAME fname(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\
+ va_list ap;\
+ UINT i;\
+ TEST_EN(TYPENAME)\
+ \
+ va_start (ap, op1); /* Initialize the argument list. */\
+ \
+ for (i = 0; i < param_count - 1; i++){\
+ op1 = op1 OP va_arg (ap, VA_ARGS_##TYPENAME);\
+ }\
+ \
+ va_end (ap); /* Clean up. */\
+ return op1;\
+}
+
+#define __arith_static(fname,TYPENAME, OP)\
+/* explicitly typed function */\
+static inline TYPENAME fname##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
+ TEST_EN(TYPENAME)\
+ return op1 OP op2;\
+}\
+/* overloaded function */\
+static inline TYPENAME fname##_##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
+ return fname##TYPENAME(EN_ENO, op1, op2);\
+}
+
+ /**************/
+ /* ADD */
+ /**************/
+#define __add(TYPENAME) \
+__arith_expand(ADD_##TYPENAME, TYPENAME, +) /* explicitly typed function */\
+__arith_expand(ADD__##TYPENAME##__##TYPENAME, TYPENAME, +) /* overloaded function */
+__ANY_NUM(__add)
+
+
+ /**************/
+ /* MUL */
+ /**************/
+#define __mul(TYPENAME) \
+__arith_expand(MUL_##TYPENAME, TYPENAME, *) /* explicitly typed function */\
+__arith_expand(MUL__##TYPENAME##__##TYPENAME, TYPENAME, *) /* overloaded function */
+__ANY_NUM(__mul)
+
+
+ /**************/
+ /* SUB */
+ /**************/
+#define __sub(TYPENAME) __arith_static(SUB_, TYPENAME, -)
+__ANY_NUM(__sub)
+
+
+ /**************/
+ /* DIV */
+ /**************/
+#define __div(TYPENAME)\
+/* The explicitly typed standard functions */\
+static inline TYPENAME DIV_##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
+ TEST_EN_COND(TYPENAME, op2 == 0)\
+ return op1 / op2;\
+}\
+/* The overloaded standard functions */\
+static inline TYPENAME DIV__##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
+ return DIV_##TYPENAME(EN_ENO, op1, op2);\
+}
+__ANY_NUM(__div)
+
+
+ /**************/
+ /* MOD */
+ /**************/
+#define __mod(TYPENAME)\
+/* The explicitly typed standard functions */\
+static inline TYPENAME MOD_##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
+ TEST_EN(TYPENAME)\
+ if (op2 == 0) return 0;\
+ return op1 % op2;\
+}\
+/* The overloaded standard functions */\
+static inline TYPENAME MOD__##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
+ return MOD_##TYPENAME(EN_ENO, op1, op2);\
+}
+__ANY_INT(__mod)
+
+ /**************/
+ /* EXPT */
+ /**************/
+/* overloaded function */
+#define __iec_(in1_TYPENAME,in2_TYPENAME) \
+static inline in1_TYPENAME EXPT__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME\
+ (EN_ENO_PARAMS, in1_TYPENAME IN1, in2_TYPENAME IN2){\
+ TEST_EN(in1_TYPENAME)\
+ return pow(IN1, IN2);\
+}
+#define __in1_anyreal_(in2_TYPENAME) __ANY_REAL_1(__iec_,in2_TYPENAME)
+__ANY_NUM(__in1_anyreal_)
+#undef __iec_
+
+
+
+ /***************/
+ /* MOVE */
+ /***************/
+/* The explicitly typed standard functions */
+#define __iec_(TYPENAME)\
+static inline TYPENAME MOVE_##TYPENAME(EN_ENO_PARAMS, TYPENAME op1){\
+ TEST_EN(TYPENAME)\
+ return op1;\
+}
+__ANY(__iec_)
+#undef __iec_
+
+/* Overloaded function */
+#define __iec_(TYPENAME)\
+static inline TYPENAME MOVE__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1){\
+ TEST_EN(TYPENAME)\
+ return op1;\
+}
+__ANY(__iec_)
+#undef __iec_
+
+
+
+
+
+
+/***********************************/
+/***********************************/
+/* 2.5.1.5.3 Bit String Functions */
+/***********************************/
+/***********************************/
+
+/****************************************************/
+/*** Table 25 - Standard bit shift functions ***/
+/****************************************************/
+
+/* We do not delcare explcitly typed versions of the functions in table 25.
+ * See note above regarding explicitly typed functions for more details.
+ */
+#define __in1_anynbit_(in2_TYPENAME) __ANY_NBIT_1(__iec_,in2_TYPENAME)
+
+#define __shift_(fname, in1_TYPENAME, in2_TYPENAME, OP)\
+static inline in1_TYPENAME fname(EN_ENO_PARAMS, in1_TYPENAME IN, in2_TYPENAME N) {\
+ TEST_EN(in1_TYPENAME)\
+ return IN OP N;\
+}
+
+ /**************/
+ /* SHL */
+ /**************/
+#define __iec_(TYPENAME) \
+/* Overloaded function */\
+static inline BOOL SHL__BOOL__##TYPENAME(EN_ENO_PARAMS, BOOL IN, TYPENAME N) { \
+ TEST_EN(BOOL);\
+ return (N==0)? IN : __INIT_BOOL; /* shifting by N>1 will always introduce a 0 */\
+}
+__ANY_INT(__iec_)
+#undef __iec_
+
+
+#define __iec_(in1_TYPENAME,in2_TYPENAME) \
+__shift_(SHL__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME, in1_TYPENAME, in2_TYPENAME, << )/* Overloaded function */
+__ANY_INT(__in1_anynbit_)
+#undef __iec_
+
+
+ /**************/
+ /* SHR */
+ /**************/
+#define __iec_(TYPENAME) \
+/* Overloaded function */\
+static inline BOOL SHR__BOOL__##TYPENAME(EN_ENO_PARAMS, BOOL IN, TYPENAME N) { \
+ TEST_EN(BOOL);\
+ return (N==0)? IN : __INIT_BOOL; /* shifting by N>1 will always introduce a 0 */\
+}
+__ANY_INT(__iec_)
+#undef __iec_
+
+
+#define __iec_(in1_TYPENAME,in2_TYPENAME) \
+__shift_(SHR__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME, in1_TYPENAME, in2_TYPENAME, >> )/* Overloaded function */
+__ANY_INT(__in1_anynbit_)
+#undef __iec_
+
+
+ /**************/
+ /* ROR */
+ /**************/
+#define __iec_(TYPENAME) \
+/* Overloaded function */\
+static inline BOOL ROR__BOOL__##TYPENAME(EN_ENO_PARAMS, BOOL IN, TYPENAME N) { \
+ TEST_EN(BOOL);\
+ return IN; /* rotating a single bit by any value N will not change that bit! */\
+}
+__ANY_INT(__iec_)
+#undef __iec_
+
+
+#define __iec_(in1_TYPENAME,in2_TYPENAME) \
+static inline in1_TYPENAME ROR__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME(EN_ENO_PARAMS, in1_TYPENAME IN, in2_TYPENAME N){\
+ TEST_EN(in1_TYPENAME)\
+ N %= 8*sizeof(in1_TYPENAME);\
+ return (IN >> N) | (IN << (8*sizeof(in1_TYPENAME)-N));\
+}
+__ANY_INT(__in1_anynbit_)
+#undef __iec_
+
+
+ /**************/
+ /* ROL */
+ /**************/
+#define __iec_(TYPENAME) \
+/* Overloaded function */\
+static inline BOOL ROL__BOOL__##TYPENAME(EN_ENO_PARAMS, BOOL IN, TYPENAME N) { \
+ TEST_EN(BOOL);\
+ return IN; /* rotating a single bit by any value N will not change that bit! */\
+}
+__ANY_INT(__iec_)
+#undef __iec_
+
+
+#define __iec_(in1_TYPENAME,in2_TYPENAME) \
+static inline in1_TYPENAME ROL__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME(EN_ENO_PARAMS, in1_TYPENAME IN, in2_TYPENAME N){\
+ TEST_EN(in1_TYPENAME)\
+ N %= 8*sizeof(in1_TYPENAME);\
+ return (IN << N) | (IN >> (8*sizeof(in1_TYPENAME)-N));\
+}
+__ANY_INT(__in1_anynbit_)
+#undef __iec_
+
+
+
+/*********************/
+/*** Table 26 ***/
+/*********************/
+
+ /**************/
+ /* AND */
+ /**************/
+__arith_expand(AND_BOOL, BOOL, && ) /* The explicitly typed standard functions */
+__arith_expand(AND__BOOL__BOOL, BOOL, && ) /* Overloaded function */
+
+#define __iec_(TYPENAME) \
+__arith_expand(AND_##TYPENAME, TYPENAME, &) /* The explicitly typed standard functions */\
+__arith_expand(AND__##TYPENAME##__##TYPENAME, TYPENAME, &) /* Overloaded function */
+__ANY_NBIT(__iec_)
+#undef __iec_
+
+ /*************/
+ /* OR */
+ /*************/
+__arith_expand(OR_BOOL, BOOL, || ) /* The explicitly typed standard functions */
+__arith_expand(OR__BOOL__BOOL, BOOL, || ) /* Overloaded function */
+
+#define __iec_(TYPENAME) \
+__arith_expand(OR_##TYPENAME, TYPENAME, |) /* The explicitly typed standard functions */\
+__arith_expand(OR__##TYPENAME##__##TYPENAME, TYPENAME, |) /* Overloaded function */
+__ANY_NBIT(__iec_)
+#undef __iec_
+
+ /**************/
+ /* XOR */
+ /**************/
+#define __xorbool_expand(fname) \
+static inline BOOL fname(EN_ENO_PARAMS, UINT param_count, BOOL op1, ...){ \
+ va_list ap; \
+ UINT i; \
+ TEST_EN(BOOL) \
+\
+ va_start (ap, op1); /* Initialize the argument list. */ \
+\
+ for (i = 0; i < param_count - 1; i++){ \
+ BOOL tmp = va_arg (ap, VA_ARGS_BOOL); \
+ op1 = (op1 && !tmp) || (!op1 && tmp); \
+ } \
+\
+ va_end (ap); /* Clean up. */ \
+ return op1; \
+}
+
+__xorbool_expand(XOR_BOOL) /* The explicitly typed standard functions */
+__xorbool_expand(XOR__BOOL__BOOL) /* Overloaded function */
+
+#define __iec_(TYPENAME) \
+__arith_expand(XOR_##TYPENAME, TYPENAME, ^) /* The explicitly typed standard functions */\
+__arith_expand(XOR__##TYPENAME##__##TYPENAME, TYPENAME, ^) /* Overloaded function */\
+__ANY_NBIT(__iec_)
+#undef __iec_
+
+
+ /**************/
+ /* NOT */
+ /**************/
+/* The explicitly typed standard functions */
+static inline BOOL NOT_BOOL(EN_ENO_PARAMS, BOOL op1){
+ TEST_EN(BOOL)
+ return !op1;
+}
+
+/* Overloaded function */
+static inline BOOL NOT__BOOL__BOOL(EN_ENO_PARAMS, BOOL op1){
+ TEST_EN(BOOL)
+ return !op1;
+}
+
+/* The explicitly typed standard functions */
+#define __iec_(TYPENAME)\
+static inline TYPENAME NOT_##TYPENAME(EN_ENO_PARAMS, TYPENAME op1){\
+ TEST_EN(TYPENAME)\
+ return ~op1;\
+}
+__ANY_NBIT(__iec_)
+#undef __iec_
+
+/* Overloaded function */
+#define __iec_(TYPENAME)\
+static inline TYPENAME NOT__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1){\
+ TEST_EN(TYPENAME)\
+ return ~op1;\
+}
+__ANY_NBIT(__iec_)
+#undef __iec_
+
+
+
+
+
+
+/***************************************************/
+/***************************************************/
+/* 2.5.1.5.4 Selection and comparison Functions */
+/***************************************************/
+/***************************************************/
+
+/*********************/
+/*** Table 27 ***/
+/*********************/
+
+
+ /**************/
+ /* SEL */
+ /**************/
+
+/* The explicitly typed standard functions */
+#define __iec_(TYPENAME)\
+static inline TYPENAME SEL_##TYPENAME(EN_ENO_PARAMS, BOOL G, TYPENAME op0, TYPENAME op1){\
+ TEST_EN(TYPENAME)\
+ return G ? op1 : op0;\
+}
+__ANY(__iec_)
+#undef __iec_
+
+/* Overloaded function */
+#define __iec_(TYPENAME)\
+static inline TYPENAME SEL__##TYPENAME##__BOOL__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, BOOL G, TYPENAME op0, TYPENAME op1){\
+ TEST_EN(TYPENAME)\
+ return G ? op1 : op0;\
+}
+__ANY(__iec_)
+#undef __iec_
+
+
+ /**************/
+ /* MAX */
+ /**************/
+
+#define __extrem_(fname,TYPENAME, COND) \
+static inline TYPENAME fname(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\
+ va_list ap;\
+ UINT i;\
+ TEST_EN(TYPENAME)\
+ \
+ va_start (ap, op1); /* Initialize the argument list. */\
+ \
+ for (i = 0; i < param_count - 1; i++){\
+ TYPENAME tmp = va_arg (ap, VA_ARGS_##TYPENAME);\
+ op1 = COND ? tmp : op1;\
+ }\
+ \
+ va_end (ap); /* Clean up. */\
+ return op1;\
+}
+
+/* Max for numerical data types */
+#define __iec_(TYPENAME) \
+__extrem_(MAX_##TYPENAME,TYPENAME, op1 < tmp) /* The explicitly typed standard functions */\
+__extrem_(MAX__##TYPENAME##__##TYPENAME,TYPENAME, op1 < tmp) /* Overloaded function */
+__ANY_BIT(__iec_)
+__ANY_NUM(__iec_)
+#undef __iec_
+
+/* Max for time data types */
+#define __iec_(TYPENAME) \
+__extrem_(MAX_##TYPENAME, TYPENAME, __time_cmp(op1, tmp) < 0) /* The explicitly typed standard functions */\
+__extrem_(MAX__##TYPENAME##__##TYPENAME, TYPENAME, __time_cmp(op1, tmp) < 0) /* Overloaded function */
+__ANY_DATE(__iec_)
+__iec_(TIME)
+#undef __iec_
+
+#define __STR_CMP(str1, str2) memcmp((char*)&str1.body,(char*)&str2.body, str1.len < str2.len ? str1.len : str2.len)
+
+/* Max for string data types */
+__extrem_(MAX_STRING, STRING, __STR_CMP(op1,tmp) < 0) /* The explicitly typed standard functions */
+__extrem_(MAX__STRING__STRING, STRING, __STR_CMP(op1,tmp) < 0) /* Overloaded function */
+
+ /**************/
+ /* MIN */
+ /**************/
+/* Min for numerical data types */
+#define __iec_(TYPENAME) \
+__extrem_(MIN_##TYPENAME, TYPENAME, op1 > tmp) /* The explicitly typed standard functions */\
+__extrem_(MIN__##TYPENAME##__##TYPENAME, TYPENAME, op1 > tmp) /* Overloaded function */
+__ANY_NBIT(__iec_)
+__ANY_NUM(__iec_)
+#undef __iec_
+
+/* Min for time data types */
+#define __iec_(TYPENAME) \
+__extrem_(MIN_##TYPENAME, TYPENAME, __time_cmp(op1, tmp) > 0) /* The explicitly typed standard functions */\
+__extrem_(MIN__##TYPENAME##__##TYPENAME, TYPENAME, __time_cmp(op1, tmp) > 0) /* Overloaded function */
+__ANY_DATE(__iec_)
+__iec_(TIME)
+#undef __iec_
+
+/* Min for string data types */
+__extrem_(MIN_STRING, STRING, __STR_CMP(op1,tmp) > 0) /* The explicitly typed standard functions */
+__extrem_(MIN__STRING__STRING, STRING, __STR_CMP(op1,tmp) > 0) /* Overloaded function */
+
+ /**************/
+ /* LIMIT */
+ /**************/
+
+/* Limit for numerical data types */
+#define __iec_(TYPENAME)\
+/* The explicitly typed standard functions */\
+static inline TYPENAME LIMIT_##TYPENAME(EN_ENO_PARAMS, TYPENAME MN, TYPENAME IN, TYPENAME MX){\
+ TEST_EN(TYPENAME)\
+ return IN > MN ? IN < MX ? IN : MX : MN;\
+}\
+/* Overloaded function */\
+static inline TYPENAME LIMIT__##TYPENAME##__##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME MN, TYPENAME IN, TYPENAME MX){\
+ TEST_EN(TYPENAME)\
+ return IN > MN ? IN < MX ? IN : MX : MN;\
+}
+__ANY_NBIT(__iec_)
+__ANY_NUM(__iec_)
+#undef __iec_
+
+
+/* Limit for time data types */
+#define __iec_(TYPENAME)\
+/* The explicitly typed standard functions */\
+static inline TYPENAME LIMIT_##TYPENAME(EN_ENO_PARAMS, TYPENAME MN, TYPENAME IN, TYPENAME MX){\
+ TEST_EN(TYPENAME)\
+ return __time_cmp(IN, MN) > 0 ? /* IN>MN ?*/\
+ __time_cmp(IN, MX) < 0 ? /* IN<MX ?*/\
+ IN : MX : MN;\
+}\
+/* Overloaded function */\
+static inline TYPENAME LIMIT__##TYPENAME##__##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME MN, TYPENAME IN, TYPENAME MX){\
+ TEST_EN(TYPENAME)\
+ return __time_cmp(IN, MN) > 0 ? /* IN>MN ?*/\
+ __time_cmp(IN, MX) < 0 ? /* IN<MX ?*/\
+ IN : MX : MN;\
+}
+
+__ANY_DATE(__iec_)
+__iec_(TIME)
+#undef __iec_
+
+/* Limit for string data types */
+/* The explicitly typed standard functions */
+static inline STRING LIMIT_STRING(EN_ENO_PARAMS, STRING MN, STRING IN, STRING MX){
+ TEST_EN(STRING)
+ return __STR_CMP(IN, MN) > 0 ? __STR_CMP(IN, MX) < 0 ? IN : MX : MN;
+}
+
+/* Overloaded function */
+static inline STRING LIMIT__STRING__STRING__STRING__STRING(EN_ENO_PARAMS, STRING MN, STRING IN, STRING MX){
+ TEST_EN(STRING)
+ return __STR_CMP(IN, MN) > 0 ? __STR_CMP(IN, MX) < 0 ? IN : MX : MN;
+}
+
+
+ /**************/
+ /* MUX */
+ /**************/
+/* The standard states that the inputs for SEL and MUX must be named starting off from 0,
+ * unlike remaining functions, that start off at 1.
+ */
+/* The explicitly typed standard functions */
+#define __in1_anyint_(in2_TYPENAME) __ANY_INT_1(__iec_,in2_TYPENAME)
+#define __iec_(in1_TYPENAME,in2_TYPENAME) \
+static inline in2_TYPENAME MUX__##in2_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME(EN_ENO_PARAMS, in1_TYPENAME K, UINT param_count, ...){\
+ va_list ap;\
+ UINT i;\
+ in2_TYPENAME tmp;\
+ TEST_EN_COND(in2_TYPENAME, K >= param_count)\
+ tmp = __INIT_##in2_TYPENAME;\
+ \
+ va_start (ap, param_count); /* Initialize the argument list. */\
+ \
+ for (i = 0; i < param_count; i++){\
+ if(K == i){\
+ tmp = va_arg (ap, VA_ARGS_##in2_TYPENAME);\
+ va_end (ap); /* Clean up. */\
+ return tmp;\
+ }else{\
+ va_arg (ap, VA_ARGS_##in2_TYPENAME);\
+ }\
+ }\
+ \
+ va_end (ap); /* Clean up. */\
+ return tmp;\
+}
+
+__ANY(__in1_anyint_)
+#undef __iec_
+
+
+/******************************************/
+/*** Table 28 ***/
+/*** Standard comparison functions ***/
+/******************************************/
+
+#define __compare_(fname,TYPENAME, COND) \
+static inline BOOL fname(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\
+ va_list ap;\
+ UINT i;\
+ TEST_EN(BOOL)\
+ \
+ va_start (ap, op1); /* Initialize the argument list. */\
+ DBG(#fname #TYPENAME "\n")\
+ DBG_TYPE(TYPENAME, op1)\
+ \
+ for (i = 0; i < param_count - 1; i++){\
+ TYPENAME tmp = va_arg (ap, VA_ARGS_##TYPENAME);\
+ DBG_TYPE(TYPENAME, tmp)\
+ if(COND){\
+ op1 = tmp;\
+ }else{\
+ va_end (ap); /* Clean up. */\
+ return 0;\
+ }\
+ }\
+ \
+ va_end (ap); /* Clean up. */\
+ return 1;\
+}
+
+#define __compare_num(fname, TYPENAME, TEST) __compare_(fname, TYPENAME, op1 TEST tmp )
+#define __compare_time(fname, TYPENAME, TEST) __compare_(fname, TYPENAME, __time_cmp(op1, tmp) TEST 0)
+#define __compare_string(fname, TEST) __compare_(fname, STRING, __STR_CMP(op1, tmp) TEST 0 )
+
+
+ /**************/
+ /* GT */
+ /**************/
+/* Comparison for numerical data types */
+#define __iec_(TYPENAME) \
+__compare_num(GT_##TYPENAME, TYPENAME, > ) /* The explicitly typed standard functions */\
+__compare_num(GT__BOOL__##TYPENAME, TYPENAME, > ) /* Overloaded function */
+__ANY_NBIT(__iec_)
+__ANY_NUM(__iec_)
+#undef __iec_
+
+/* Comparison for time data types */
+#define __iec_(TYPENAME) \
+__compare_time(GT_##TYPENAME, TYPENAME, > ) /* The explicitly typed standard functions */\
+__compare_time(GT__BOOL__##TYPENAME, TYPENAME, > ) /* Overloaded function */
+__ANY_DATE(__iec_)
+__iec_(TIME)
+#undef __iec_
+
+/* Comparison for string data types */
+__compare_string(GT_STRING, > ) /* The explicitly typed standard functions */
+__compare_string(GT__BOOL__STRING, > ) /* Overloaded function */
+
+ /**************/
+ /* GE */
+ /**************/
+/* Comparison for numerical data types */
+#define __iec_(TYPENAME) \
+__compare_num(GE_##TYPENAME, TYPENAME, >= ) /* The explicitly typed standard functions */\
+__compare_num(GE__BOOL__##TYPENAME, TYPENAME, >= ) /* Overloaded function */
+__ANY_NBIT(__iec_)
+__ANY_NUM(__iec_)
+#undef __iec_
+
+/* Comparison for time data types */
+#define __iec_(TYPENAME) \
+__compare_time(GE_##TYPENAME, TYPENAME, >= ) /* The explicitly typed standard functions */\
+__compare_time(GE__BOOL__##TYPENAME, TYPENAME, >= ) /* Overloaded function */
+__ANY_DATE(__iec_)
+__iec_(TIME)
+#undef __iec_
+
+/* Comparison for string data types */
+__compare_string(GE_STRING, >= ) /* The explicitly typed standard functions */
+__compare_string(GE__BOOL__STRING, >= ) /* Overloaded function */
+
+
+
+ /**************/
+ /* EQ */
+ /**************/
+/* Comparison for numerical data types */
+#define __iec_(TYPENAME) \
+__compare_num(EQ_##TYPENAME, TYPENAME, == ) /* The explicitly typed standard functions */\
+__compare_num(EQ__BOOL__##TYPENAME, TYPENAME, == ) /* Overloaded function */
+__ANY_NBIT(__iec_)
+__ANY_NUM(__iec_)
+#undef __iec_
+
+/* Comparison for time data types */
+#define __iec_(TYPENAME) \
+__compare_time(EQ_##TYPENAME, TYPENAME, == ) /* The explicitly typed standard functions */\
+__compare_time(EQ__BOOL__##TYPENAME, TYPENAME, == ) /* Overloaded function */
+__ANY_DATE(__iec_)
+__iec_(TIME)
+#undef __iec_
+
+/* Comparison for string data types */
+__compare_string(EQ_STRING, == ) /* The explicitly typed standard functions */
+__compare_string(EQ__BOOL__STRING, == ) /* Overloaded function */
+
+
+ /**************/
+ /* LT */
+ /**************/
+/* Comparison for numerical data types */
+#define __iec_(TYPENAME) \
+__compare_num(LT_##TYPENAME, TYPENAME, < ) /* The explicitly typed standard functions */\
+__compare_num(LT__BOOL__##TYPENAME, TYPENAME, < ) /* Overloaded function */
+__ANY_NBIT(__iec_)
+__ANY_NUM(__iec_)
+#undef __iec_
+
+/* Comparison for time data types */
+#define __iec_(TYPENAME) \
+__compare_time(LT_##TYPENAME, TYPENAME, < ) /* The explicitly typed standard functions */\
+__compare_time(LT__BOOL__##TYPENAME, TYPENAME, < ) /* Overloaded function */
+__ANY_DATE(__iec_)
+__iec_(TIME)
+#undef __iec_
+
+/* Comparison for string data types */
+__compare_string(LT_STRING, < ) /* The explicitly typed standard functions */
+__compare_string(LT__BOOL__STRING, < ) /* Overloaded function */
+
+
+ /**************/
+ /* LE */
+ /**************/
+/* Comparison for numerical data types */
+#define __iec_(TYPENAME) \
+__compare_num(LE_##TYPENAME, TYPENAME, <= ) /* The explicitly typed standard functions */\
+__compare_num(LE__BOOL__##TYPENAME, TYPENAME, <= ) /* Overloaded function */
+__ANY_NBIT(__iec_)
+__ANY_NUM(__iec_)
+#undef __iec_
+
+/* Comparison for time data types */
+#define __iec_(TYPENAME) \
+__compare_time(LE_##TYPENAME, TYPENAME, <= ) /* The explicitly typed standard functions */\
+__compare_time(LE__BOOL__##TYPENAME, TYPENAME, <= ) /* Overloaded function */
+__ANY_DATE(__iec_)
+__iec_(TIME)
+#undef __iec_
+
+/* Comparison for string data types */
+__compare_string(LE_STRING, <= ) /* The explicitly typed standard functions */
+__compare_string(LE__BOOL__STRING, <= ) /* Overloaded function */
+
+
+ /**************/
+ /* NE */
+ /**************/
+#define __ne_num(fname, TYPENAME) \
+static inline BOOL fname(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
+ TEST_EN(BOOL)\
+ return op1 != op2 ? 1 : 0;\
+}
+
+#define __ne_time(fname, TYPENAME) \
+static inline BOOL fname(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
+ TEST_EN(BOOL)\
+ return __time_cmp(op1, op2) != 0 ? 1 : 0;\
+}
+
+#define __ne_string(fname, TYPENAME) \
+static inline BOOL fname(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
+ TEST_EN(BOOL)\
+ return __STR_CMP(op1, op2) != 0 ? 1 : 0;\
+}
+
+/* Comparison for numerical data types */
+#define __iec_(TYPENAME) \
+__ne_num(NE_##TYPENAME, TYPENAME) /* The explicitly typed standard functions */\
+__ne_num(NE__BOOL__##TYPENAME##__##TYPENAME, TYPENAME) /* Overloaded function */
+__ANY_NBIT(__iec_)
+__ANY_NUM(__iec_)
+#undef __iec_
+
+/* Comparison for time data types */
+#define __iec_(TYPENAME) \
+__ne_time(NE_##TYPENAME, TYPENAME) /* The explicitly typed standard functions */\
+__ne_time(NE__BOOL__##TYPENAME##__##TYPENAME, TYPENAME) /* Overloaded function */
+__ANY_DATE(__iec_)
+__iec_(TIME)
+#undef __iec_
+
+/* Comparison for string data types */
+__ne_string(NE_STRING, STRING) /* The explicitly typed standard functions */
+__ne_string(NE__BOOL__STRING__STRING, STRING) /* Overloaded function */
+
+
+
+
+
+
+/*********************************************/
+/*********************************************/
+/* 2.5.1.5.5 Character string Functions */
+/*********************************************/
+/*********************************************/
+
+/*************************************/
+/*** Table 29 ***/
+/*** Character string Functions ***/
+/*************************************/
+
+/* We do not delcare explcitly typed versions of the functions in table 29.
+ * See note above regarding explicitly typed functions for more details.
+ */
+
+
+
+
+ /***************/
+ /* LEN */
+ /***************/
+static inline __strlen_t __len(STRING IN) {return IN.len;}
+
+/* A function, with 1 input paramter, implementing a generic OPERATION */
+#define __genoper_1p_(fname,ret_TYPENAME, par_TYPENAME, OPERATION) \
+static inline ret_TYPENAME fname(EN_ENO_PARAMS, par_TYPENAME par1){\
+ TEST_EN(ret_TYPENAME)\
+ return (ret_TYPENAME)OPERATION(par1);\
+}
+
+#define __iec_(TYPENAME) __genoper_1p_(LEN__##TYPENAME##__STRING, TYPENAME, STRING, __len)
+__ANY_INT(__iec_)
+#undef __iec_
+
+
+ /****************/
+ /* LEFT */
+ /****************/
+
+#define __left(TYPENAME) \
+static inline STRING LEFT__STRING__STRING__##TYPENAME(EN_ENO_PARAMS, STRING IN, TYPENAME L){\
+ STRING res;\
+ TEST_EN_COND(STRING, L < 0)\
+ res = __INIT_STRING;\
+ L = L < (TYPENAME)IN.len ? L : (TYPENAME)IN.len;\
+ memcpy(&res.body, &IN.body, (size_t)L);\
+ res.len = (__strlen_t)L;\
+ return res;\
+}
+__ANY_INT(__left)
+
+
+ /*****************/
+ /* RIGHT */
+ /*****************/
+
+#define __right(TYPENAME) \
+static inline STRING RIGHT__STRING__STRING__##TYPENAME(EN_ENO_PARAMS, STRING IN, TYPENAME L){\
+ STRING res;\
+ TEST_EN_COND(STRING, L < 0)\
+ res = __INIT_STRING;\
+ L = L < (TYPENAME)IN.len ? L : (TYPENAME)IN.len;\
+ memcpy(&res.body, &IN.body[(TYPENAME)IN.len - L], (size_t)L);\
+ res.len = (__strlen_t)L;\
+ return res;\
+}
+__ANY_INT(__right)
+
+
+ /***************/
+ /* MID */
+ /***************/
+
+#define __mid(TYPENAME) \
+static inline STRING MID__STRING__STRING__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, STRING IN, TYPENAME L, TYPENAME P){\
+ STRING res;\
+ TEST_EN_COND(STRING, L < 0 || P < 0)\
+ res = __INIT_STRING;\
+ if(P <= (TYPENAME)IN.len){\
+ P -= 1; /* now can be used as [index]*/\
+ L = L + P <= (TYPENAME)IN.len ? L : (TYPENAME)IN.len - P;\
+ memcpy(&res.body, &IN.body[P] , (size_t)L);\
+ res.len = (__strlen_t)L;\
+ }\
+ return res;\
+}
+__ANY_INT(__mid)
+
+
+ /******************/
+ /* CONCAT */
+ /******************/
+
+static inline STRING CONCAT(EN_ENO_PARAMS, UINT param_count, ...){
+ UINT i;
+ STRING res;
+ va_list ap;
+ __strlen_t charcount;
+ TEST_EN(STRING)
+ charcount = 0;
+ res = __INIT_STRING;
+
+ va_start (ap, param_count); /* Initialize the argument list. */
+
+ for (i = 0; i < param_count && charcount < STR_MAX_LEN; i++)
+ {
+ STRING tmp = va_arg(ap, STRING);
+ __strlen_t charrem = STR_MAX_LEN - charcount;
+ __strlen_t to_write = tmp.len > charrem ? charrem : tmp.len;
+ memcpy(&res.body[charcount], &tmp.body , to_write);
+ charcount += to_write;
+ }
+
+ res.len = charcount;
+
+ va_end (ap); /* Clean up. */
+ return res;
+}
+
+ /******************/
+ /* INSERT */
+ /******************/
+
+static inline STRING __insert(STRING IN1, STRING IN2, __strlen_t P){
+ STRING res;
+ __strlen_t to_copy;
+ res = __INIT_STRING;
+
+ to_copy = P > IN1.len ? IN1.len : P;
+ memcpy(&res.body, &IN1.body , to_copy);
+ P = res.len = to_copy;
+
+ to_copy = IN2.len + res.len > STR_MAX_LEN ? STR_MAX_LEN - res.len : IN2.len;
+ memcpy(&res.body[res.len], &IN2.body , to_copy);
+ res.len += to_copy;
+
+ to_copy = IN1.len - P < STR_MAX_LEN - res.len ? IN1.len - P : STR_MAX_LEN - res.len ;
+ memcpy(&res.body[res.len], &IN1.body[P] , to_copy);
+ res.len += to_copy;
+
+ return res;
+}
+
+#define __iec_(TYPENAME) \
+static inline STRING INSERT__STRING__STRING__STRING__##TYPENAME(EN_ENO_PARAMS, STRING str1, STRING str2, TYPENAME P){\
+ TEST_EN_COND(STRING, P < 0)\
+ return (STRING)__insert(str1,str2,(__strlen_t)P);\
+}
+__ANY_INT(__iec_)
+#undef __iec_
+
+
+ /******************/
+ /* DELETE */
+ /******************/
+
+static inline STRING __delete(STRING IN, __strlen_t L, __strlen_t P){
+ STRING res;
+ __strlen_t to_copy;
+ res = __INIT_STRING;
+
+ to_copy = P > IN.len ? IN.len : P-1;
+ memcpy(&res.body, &IN.body , to_copy);
+ P = res.len = to_copy;
+
+ if( IN.len > P + L ){
+ to_copy = IN.len - P - L;
+ memcpy(&res.body[res.len], &IN.body[P + L], to_copy);
+ res.len += to_copy;
+ }
+
+ return res;
+}
+
+#define __iec_(TYPENAME) \
+static inline STRING DELETE__STRING__STRING__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, STRING str, TYPENAME L, TYPENAME P){\
+ TEST_EN_COND(STRING, L < 0 || P < 0)\
+ return (STRING)__delete(str,(__strlen_t)L,(__strlen_t)P);\
+}
+__ANY_INT(__iec_)
+#undef __iec_
+
+
+ /*******************/
+ /* REPLACE */
+ /*******************/
+
+static inline STRING __replace(STRING IN1, STRING IN2, __strlen_t L, __strlen_t P){
+ STRING res;
+ __strlen_t to_copy;
+ res = __INIT_STRING;
+
+ to_copy = P > IN1.len ? IN1.len : P-1;
+ memcpy(&res.body, &IN1.body , to_copy);
+ P = res.len = to_copy;
+
+ to_copy = IN2.len < L ? IN2.len : L;
+
+ if( to_copy + res.len > STR_MAX_LEN )
+ to_copy = STR_MAX_LEN - res.len;
+
+ memcpy(&res.body[res.len], &IN2.body , to_copy);
+ res.len += to_copy;
+
+ P += L;
+ if( res.len < STR_MAX_LEN && P < IN1.len)
+ {
+ to_copy = IN1.len - P;
+ memcpy(&res.body[res.len], &IN1.body[P] , to_copy);
+ res.len += to_copy;
+ }
+
+ return res;
+}
+
+#define __iec_(TYPENAME) \
+static inline STRING REPLACE__STRING__STRING__STRING__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, STRING str1, STRING str2, TYPENAME L, TYPENAME P){\
+ TEST_EN_COND(STRING, L < 0 || P < 0)\
+ return (STRING)__replace(str1,str2,(__strlen_t)L,(__strlen_t)P);\
+}
+__ANY_INT(__iec_)
+#undef __iec_
+
+ /****************/
+ /* FIND */
+ /****************/
+
+static inline __strlen_t __pfind(STRING* IN1, STRING* IN2){
+ UINT count1 = 0; /* offset of first matching char in IN1 */
+ UINT count2 = 0; /* count of matching char */
+ while(count1 + count2 < IN1->len && count2 < IN2->len)
+ {
+ if(IN1->body[count1 + count2] != IN2->body[count2]){
+ count1 += count2 + 1;
+ count2 = 0;
+ }
+ else {
+ count2++;
+ }
+ }
+ return count2 == IN2->len -1 ? 0 : count1 + 1;
+}
+
+#define __iec_(TYPENAME) \
+static inline TYPENAME FIND__##TYPENAME##__STRING__STRING(EN_ENO_PARAMS, STRING str1, STRING str2){\
+ TEST_EN(TYPENAME)\
+ return (TYPENAME)__pfind(&str1,&str2);\
+}
+__ANY_INT(__iec_)
+#undef __iec_
+
+
+/*********************************************/
+/*********************************************/
+/* 2.5.1.5.6 Functions of time data types */
+/*********************************************/
+/*********************************************/
+
+/**************************************/
+/*** Table 30 ***/
+/*** Functions of time data types ***/
+/**************************************/
+
+
+static inline TIME ADD_TIME(EN_ENO_PARAMS, TIME IN1, TIME IN2){
+ TEST_EN(TIME)
+ return __time_add(IN1, IN2);
+}
+
+static inline TOD ADD_TOD_TIME(EN_ENO_PARAMS, TOD IN1, TIME IN2){
+ TEST_EN(TOD)
+ return __time_add(IN1, IN2);
+}
+
+static inline DT ADD_DT_TIME(EN_ENO_PARAMS, DT IN1, TIME IN2){
+ TEST_EN(DT)
+ return __time_add(IN1, IN2);
+}
+
+static inline TIME SUB_TIME(EN_ENO_PARAMS, TIME IN1, TIME IN2){
+ TEST_EN(TIME)
+ return __time_sub(IN1, IN2);
+}
+
+static inline TIME SUB_DATE_DATE(EN_ENO_PARAMS, DATE IN1, DATE IN2){
+ TEST_EN(TIME)
+ return __time_sub(IN1, IN2);
+}
+
+static inline TOD SUB_TOD_TIME(EN_ENO_PARAMS, TOD IN1, TIME IN2){
+ TEST_EN(TOD)
+ return __time_sub(IN1, IN2);
+}
+
+static inline TIME SUB_TOD_TOD(EN_ENO_PARAMS, TOD IN1, TOD IN2){
+ TEST_EN(TIME)
+ return __time_sub(IN1, IN2);
+}
+
+static inline DT SUB_DT_TIME(EN_ENO_PARAMS, DT IN1, TIME IN2){
+ TEST_EN(DT)
+ return __time_sub(IN1, IN2);
+}
+
+static inline TIME SUB_DT_DT(EN_ENO_PARAMS, DT IN1, DT IN2){
+ TEST_EN(TIME)
+ return __time_sub(IN1, IN2);
+}
+
+
+/*** MULTIME ***/
+#define __iec_(TYPENAME)\
+static inline TIME MULTIME__TIME__TIME__##TYPENAME(EN_ENO_PARAMS, TIME IN1, TYPENAME IN2){\
+ TEST_EN(TIME)\
+ return __time_mul(IN1, (LREAL)IN2);\
+}
+__ANY_NUM(__iec_)
+#undef __iec_
+
+/*** MUL ***/
+#define __iec_(TYPENAME)\
+static inline TIME MUL__TIME__TIME__##TYPENAME(EN_ENO_PARAMS, TIME IN1, TYPENAME IN2){\
+ TEST_EN(TIME)\
+ return __time_mul(IN1, (LREAL)IN2);\
+}
+__ANY_NUM(__iec_)
+#undef __iec_
+
+/*** DIVTIME ***/
+#define __iec_(TYPENAME)\
+static inline TIME DIVTIME__TIME__TIME__##TYPENAME(EN_ENO_PARAMS, TIME IN1, TYPENAME IN2){\
+ TEST_EN(TIME)\
+ return __time_div(IN1, (LREAL)IN2);\
+}
+__ANY_NUM(__iec_)
+#undef __iec_
+
+/*** DIV ***/
+#define __iec_(TYPENAME)\
+static inline TIME DIV__TIME__TIME__##TYPENAME(EN_ENO_PARAMS, TIME IN1, TYPENAME IN2){\
+ TEST_EN(TIME)\
+ return __time_div(IN1, (LREAL)IN2);\
+}
+__ANY_NUM(__iec_)
+#undef __iec_
+
+/*** CONCAT_DATE_TOD ***/
+static inline DT CONCAT_DATE_TOD(EN_ENO_PARAMS, DATE IN1, TOD IN2){
+ TEST_EN(DT)
+ return __time_add(IN1, IN2);
+}
+
+
+
+/****************************************************/
+/****************************************************/
+/* 2.5.1.5.6 Functions of enumerated data types */
+/****************************************************/
+/****************************************************/
+
+/********************************************/
+/*** Table 31 ***/
+/*** Functions of enumerated data types ***/
+/********************************************/
+
+/* Do we support this? */
+
+#endif /* _IEC_STD_LIB_H */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lib/C/iec_types.h Sun Jul 06 11:07:38 2014 +0100
@@ -0,0 +1,83 @@
+#ifndef IEC_TYPES_H
+#define IEC_TYPES_H
+
+#include <limits.h>
+#include <float.h>
+#include <stdint.h>
+
+/*********************/
+/* IEC Types defs */
+/*********************/
+
+typedef uint8_t IEC_BOOL;
+
+typedef int8_t IEC_SINT;
+typedef int16_t IEC_INT;
+typedef int32_t IEC_DINT;
+typedef int64_t IEC_LINT;
+
+typedef uint8_t IEC_USINT;
+typedef uint16_t IEC_UINT;
+typedef uint32_t IEC_UDINT;
+typedef uint64_t IEC_ULINT;
+
+typedef uint8_t IEC_BYTE;
+typedef uint16_t IEC_WORD;
+typedef uint32_t IEC_DWORD;
+typedef uint64_t IEC_LWORD;
+
+typedef float IEC_REAL;
+typedef double IEC_LREAL;
+
+/* WARNING: When editing the definition of IEC_TIMESPEC, take note that
+ * if the order of the two elements 'tv_sec' and 'tv_nsec' is changed, then the macros
+ * __time_to_timespec() and __tod_to_timespec() will need to be changed accordingly.
+ * (these macros may be found in iec_std_lib.h)
+ */
+typedef struct {
+ long int tv_sec; /* Seconds. */
+ long int tv_nsec; /* Nanoseconds. */
+} /* __attribute__((packed)) */ IEC_TIMESPEC; /* packed is gcc specific! */
+
+typedef IEC_TIMESPEC IEC_TIME;
+typedef IEC_TIMESPEC IEC_DATE;
+typedef IEC_TIMESPEC IEC_DT;
+typedef IEC_TIMESPEC IEC_TOD;
+
+#ifndef STR_MAX_LEN
+#define STR_MAX_LEN 126
+#endif
+
+#ifndef STR_LEN_TYPE
+#define STR_LEN_TYPE int8_t
+#endif
+
+#define __INIT_REAL 0
+#define __INIT_LREAL 0
+#define __INIT_SINT 0
+#define __INIT_INT 0
+#define __INIT_DINT 0
+#define __INIT_LINT 0
+#define __INIT_USINT 0
+#define __INIT_UINT 0
+#define __INIT_UDINT 0
+#define __INIT_ULINT 0
+#define __INIT_TIME (TIME){0,0}
+#define __INIT_BOOL 0
+#define __INIT_BYTE 0
+#define __INIT_WORD 0
+#define __INIT_DWORD 0
+#define __INIT_LWORD 0
+#define __INIT_STRING (STRING){0,""}
+//#define __INIT_WSTRING
+#define __INIT_DATE (DATE){0,0}
+#define __INIT_TOD (TOD){0,0}
+#define __INIT_DT (DT){0,0}
+
+typedef STR_LEN_TYPE __strlen_t;
+typedef struct {
+ __strlen_t len;
+ uint8_t body[STR_MAX_LEN];
+} /* __attribute__((packed)) */ IEC_STRING; /* packed is gcc specific! */
+
+#endif /*IEC_TYPES_H*/
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lib/C/iec_types_all.h Sun Jul 06 11:07:38 2014 +0100
@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2007-2011: Edouard TISSERANT and Laurent BESSARD
+ *
+ * See COPYING and COPYING.LESSER files for copyright details.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef IEC_TYPES_ALL_H
+#define IEC_TYPES_ALL_H
+
+
+/* Macro that expand to subtypes */
+#define __ANY(DO) __ANY_DERIVED(DO) __ANY_ELEMENTARY(DO)
+#define __ANY_DERIVED(DO)
+#define __ANY_ELEMENTARY(DO) __ANY_MAGNITUDE(DO) __ANY_BIT(DO) __ANY_STRING(DO) __ANY_DATE(DO)
+#define __ANY_MAGNITUDE(DO) __ANY_NUM(DO) DO(TIME)
+#define __ANY_BIT(DO) __ANY_NBIT(DO) DO(BOOL)
+#define __ANY_NBIT(DO) DO(BYTE) DO(WORD) DO(DWORD) DO(LWORD)
+#define __ANY_STRING(DO) DO(STRING)
+#define __ANY_DATE(DO) DO(DATE) DO(TOD) DO(DT)
+#define __ANY_NUM(DO) __ANY_REAL(DO) __ANY_INT(DO)
+#define __ANY_REAL(DO) DO(REAL) DO(LREAL)
+#define __ANY_INT(DO) __ANY_SINT(DO) __ANY_UINT(DO)
+#define __ANY_SINT(DO) DO(SINT) DO(INT) DO(DINT) DO(LINT)
+#define __ANY_UINT(DO) DO(USINT) DO(UINT) DO(UDINT) DO(ULINT)
+
+
+/* Macro that expand to subtypes */
+#define __ANY_1(DO,P1) __ANY_DERIVED_1(DO,P1) __ANY_ELEMENTARY_1(DO,P1)
+#define __ANY_DERIVED_1(DO,P1)
+#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)
+#define __ANY_MAGNITUDE_1(DO,P1) __ANY_NUM_1(DO,P1) DO(TIME,P1)
+#define __ANY_BIT_1(DO,P1) __ANY_NBIT_1(DO,P1) DO(BOOL,P1)
+#define __ANY_NBIT_1(DO,P1) DO(BYTE,P1) DO(WORD,P1) DO(DWORD,P1) DO(LWORD,P1)
+#define __ANY_STRING_1(DO,P1) DO(STRING,P1)
+#define __ANY_DATE_1(DO,P1) DO(DATE,P1) DO(TOD,P1) DO(DT,P1)
+#define __ANY_NUM_1(DO,P1) __ANY_REAL_1(DO,P1) __ANY_INT_1(DO,P1)
+#define __ANY_REAL_1(DO,P1) DO(REAL,P1) DO(LREAL,P1)
+#define __ANY_INT_1(DO,P1) __ANY_SINT_1(DO,P1) __ANY_UINT_1(DO,P1)
+#define __ANY_SINT_1(DO,P1) DO(SINT,P1) DO(INT,P1) DO(DINT,P1) DO(LINT,P1)
+#define __ANY_UINT_1(DO,P1) DO(USINT,P1) DO(UINT,P1) DO(UDINT,P1) DO(ULINT,P1)
+
+
+
+/*********************/
+/* IEC Types defs */
+/*********************/
+
+/* Include non windows.h clashing typedefs */
+#include "iec_types.h"
+
+#ifndef TRUE
+ #define TRUE 1
+ #define FALSE 0
+#endif
+
+#define __IEC_DEBUG_FLAG 0x01
+#define __IEC_FORCE_FLAG 0x02
+#define __IEC_RETAIN_FLAG 0x04
+#define __IEC_OUTPUT_FLAG 0x08
+
+#define __DECLARE_IEC_TYPE(type)\
+typedef IEC_##type type;\
+\
+typedef struct {\
+ IEC_##type value;\
+ IEC_BYTE flags;\
+} __IEC_##type##_t;\
+\
+typedef struct {\
+ IEC_##type *value;\
+ IEC_BYTE flags;\
+ IEC_##type fvalue;\
+} __IEC_##type##_p;
+
+#define __DECLARE_DERIVED_TYPE(type, base)\
+typedef base type;\
+typedef __IEC_##base##_t __IEC_##type##_t;\
+typedef __IEC_##base##_p __IEC_##type##_p;
+
+#define __DECLARE_COMPLEX_STRUCT(type)\
+typedef struct {\
+ type value;\
+ IEC_BYTE flags;\
+} __IEC_##type##_t;\
+\
+typedef struct {\
+ type *value;\
+ IEC_BYTE flags;\
+ type fvalue;\
+} __IEC_##type##_p;
+
+#define __DECLARE_ENUMERATED_TYPE(type, ...)\
+typedef enum {\
+ __VA_ARGS__\
+} type;\
+__DECLARE_COMPLEX_STRUCT(type)
+
+#define __DECLARE_ARRAY_TYPE(type, base, size)\
+typedef struct {\
+ base table size;\
+} type;\
+__DECLARE_COMPLEX_STRUCT(type)
+
+#define __DECLARE_STRUCT_TYPE(type, elements)\
+typedef struct {\
+ elements\
+} type;\
+__DECLARE_COMPLEX_STRUCT(type)
+
+/* Those typdefs clash with windows.h */
+/* i.e. this file cannot be included aside windows.h */
+__ANY(__DECLARE_IEC_TYPE)
+
+typedef struct {
+ __IEC_BOOL_t X; // state; --> current step state. 0 : inative, 1: active. We name it 'X' as it may be accessed from IEC 61131.3 code using stepname.X syntax!!
+ BOOL prev_state; // previous step state. 0 : inative, 1: active
+ __IEC_TIME_t T; // elapsed_time; --> time since step is active. We name it 'T' as it may be accessed from IEC 61131.3 code using stepname.T syntax!!
+} STEP;
+
+
+typedef struct {
+ BOOL stored; // action storing state. 0 : not stored, 1: stored
+ __IEC_BOOL_t state; // current action state. 0 : inative, 1: active
+ BOOL set; // set have been requested (reset each time the body is evaluated)
+ BOOL reset; // reset have been requested (reset each time the body is evaluated)
+ TIME set_remaining_time; // time before set will be requested
+ TIME reset_remaining_time; // time before reset will be requested
+} ACTION;
+
+/* Extra debug types for SFC */
+#define __ANY_SFC(DO) DO(STEP) DO(TRANSITION) DO(ACTION)
+
+/* Enumerate native types */
+#define __decl_enum_type(TYPENAME) TYPENAME##_ENUM,
+#define __decl_enum_pointer(TYPENAME) TYPENAME##_P_ENUM,
+#define __decl_enum_output(TYPENAME) TYPENAME##_O_ENUM,
+typedef enum{
+ __ANY(__decl_enum_type)
+ __ANY(__decl_enum_pointer)
+ __ANY(__decl_enum_output)
+ /* SFC specific types are never external or global */
+ UNKNOWN_ENUM
+} __IEC_types_enum;
+
+/* Get size of type from its number */
+#define __decl_size_case(TYPENAME) \
+ case TYPENAME##_ENUM:\
+ case TYPENAME##_O_ENUM:\
+ case TYPENAME##_P_ENUM:\
+ return sizeof(TYPENAME);
+static inline USINT __get_type_enum_size(__IEC_types_enum t){
+ switch(t){
+ __ANY(__decl_size_case)
+ /* size do not correspond to real struct.
+ * only a bool is used to represent state*/
+ default:
+ return 0;
+ }
+ return 0;
+}
+
+#endif /*IEC_TYPES_ALL_H*/
--- a/lib/accessor.h Sun Jul 06 10:16:48 2014 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,127 +0,0 @@
-#ifndef __ACCESSOR_H
-#define __ACCESSOR_H
-
-#define __INITIAL_VALUE(...) __VA_ARGS__
-
-// variable declaration macros
-#define __DECLARE_VAR(type, name)\
- __IEC_##type##_t name;
-#define __DECLARE_GLOBAL(type, domain, name)\
- __IEC_##type##_t domain##__##name;\
- static __IEC_##type##_t *GLOBAL__##name = &(domain##__##name);\
- void __INIT_GLOBAL_##name(type value) {\
- (*GLOBAL__##name).value = value;\
- }\
- IEC_BYTE __IS_GLOBAL_##name##_FORCED(void) {\
- return (*GLOBAL__##name).flags & __IEC_FORCE_FLAG;\
- }\
- type* __GET_GLOBAL_##name(void) {\
- return &((*GLOBAL__##name).value);\
- }
-#define __DECLARE_GLOBAL_FB(type, domain, name)\
- type domain##__##name;\
- static type *GLOBAL__##name = &(domain##__##name);\
- type* __GET_GLOBAL_##name(void) {\
- return &(*GLOBAL__##name);\
- }\
- extern void type##_init__(type* data__, BOOL retain);
-#define __DECLARE_GLOBAL_LOCATION(type, location)\
- extern type *location;
-#define __DECLARE_GLOBAL_LOCATED(type, resource, name)\
- __IEC_##type##_p resource##__##name;\
- static __IEC_##type##_p *GLOBAL__##name = &(resource##__##name);\
- void __INIT_GLOBAL_##name(type value) {\
- *((*GLOBAL__##name).value) = value;\
- }\
- IEC_BYTE __IS_GLOBAL_##name##_FORCED(void) {\
- return (*GLOBAL__##name).flags & __IEC_FORCE_FLAG;\
- }\
- type* __GET_GLOBAL_##name(void) {\
- return (*GLOBAL__##name).value;\
- }
-#define __DECLARE_GLOBAL_PROTOTYPE(type, name)\
- extern type* __GET_GLOBAL_##name(void);
-#define __DECLARE_EXTERNAL(type, name)\
- __IEC_##type##_p name;
-#define __DECLARE_EXTERNAL_FB(type, name)\
- type* name;
-#define __DECLARE_LOCATED(type, name)\
- __IEC_##type##_p name;
-
-
-// variable initialization macros
-#define __INIT_RETAIN(name, retained)\
- name.flags |= retained?__IEC_RETAIN_FLAG:0;
-#define __INIT_VAR(name, initial, retained)\
- name.value = initial;\
- __INIT_RETAIN(name, retained)
-#define __INIT_GLOBAL(type, name, initial, retained)\
- {\
- static const type temp = initial;\
- __INIT_GLOBAL_##name(temp);\
- __INIT_RETAIN((*GLOBAL__##name), retained)\
- }
-#define __INIT_GLOBAL_FB(type, name, retained)\
- type##_init__(&(*GLOBAL__##name), retained);
-#define __INIT_GLOBAL_LOCATED(domain, name, location, retained)\
- domain##__##name.value = location;\
- __INIT_RETAIN(domain##__##name, retained)
-#define __INIT_EXTERNAL(type, global, name, retained)\
- {\
- name.value = __GET_GLOBAL_##global();\
- __INIT_RETAIN(name, retained)\
- }
-#define __INIT_EXTERNAL_FB(type, global, name, retained)\
- name = __GET_GLOBAL_##global();
-#define __INIT_LOCATED(type, location, name, retained)\
- {\
- extern type *location;\
- name.value = location;\
- __INIT_RETAIN(name, retained)\
- }
-#define __INIT_LOCATED_VALUE(name, initial)\
- *(name.value) = initial;
-
-
-// variable getting macros
-#define __GET_VAR(name, ...)\
- name.value __VA_ARGS__
-#define __GET_EXTERNAL(name, ...)\
- ((name.flags & __IEC_FORCE_FLAG) ? name.fvalue __VA_ARGS__ : (*(name.value)) __VA_ARGS__)
-#define __GET_EXTERNAL_FB(name, ...)\
- __GET_VAR(((*name) __VA_ARGS__))
-#define __GET_LOCATED(name, ...)\
- ((name.flags & __IEC_FORCE_FLAG) ? name.fvalue __VA_ARGS__ : (*(name.value)) __VA_ARGS__)
-
-#define __GET_VAR_BY_REF(name, ...)\
- ((name.flags & __IEC_FORCE_FLAG) ? &(name.fvalue __VA_ARGS__) : &(name.value __VA_ARGS__))
-#define __GET_EXTERNAL_BY_REF(name, ...)\
- ((name.flags & __IEC_FORCE_FLAG) ? &(name.fvalue __VA_ARGS__) : &((*(name.value)) __VA_ARGS__))
-#define __GET_EXTERNAL_FB_BY_REF(name, ...)\
- __GET_EXTERNAL_BY_REF(((*name) __VA_ARGS__))
-#define __GET_LOCATED_BY_REF(name, ...)\
- ((name.flags & __IEC_FORCE_FLAG) ? &(name.fvalue __VA_ARGS__) : &((*(name.value)) __VA_ARGS__))
-
-#define __GET_VAR_REF(name, ...)\
- (&(name.value __VA_ARGS__))
-#define __GET_EXTERNAL_REF(name, ...)\
- (&((*(name.value)) __VA_ARGS__))
-#define __GET_EXTERNAL_FB_REF(name, ...)\
- (&(__GET_VAR(((*name) __VA_ARGS__))))
-#define __GET_LOCATED_REF(name, ...)\
- (&((*(name.value)) __VA_ARGS__))
-
-
-// variable setting macros
-#define __SET_VAR(prefix, name, suffix, new_value)\
- if (!(prefix name.flags & __IEC_FORCE_FLAG)) prefix name.value suffix = new_value
-#define __SET_EXTERNAL(prefix, name, suffix, new_value)\
- {extern IEC_BYTE __IS_GLOBAL_##name##_FORCED();\
- if (!(prefix name.flags & __IEC_FORCE_FLAG || __IS_GLOBAL_##name##_FORCED()))\
- (*(prefix name.value)) suffix = new_value;}
-#define __SET_EXTERNAL_FB(prefix, name, suffix, new_value)\
- __SET_VAR((*(prefix name)), suffix, new_value)
-#define __SET_LOCATED(prefix, name, suffix, new_value)\
- if (!(prefix name.flags & __IEC_FORCE_FLAG)) *(prefix name.value) suffix = new_value
-
-#endif //__ACCESSOR_H
--- a/lib/iec_std_lib.h Sun Jul 06 10:16:48 2014 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2271 +0,0 @@
-/*
- * copyright 2008 Edouard TISSERANT
- * copyright 2011 Mario de Sousa (msousa@fe.up.pt)
- *
- * Offered to the public under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
- * General Public License for more details.
- *
- * This code is made available on the understanding that it will not be
- * used in safety-critical situations without a full and competent review.
- */
-
-/****
- * IEC 61131-3 standard function library
- */
-
-/* NOTE: This file is full of (what may seem at first) very strange macros.
- * If you want to know what all these strange macros are doing,
- * just parse this file through a C preprocessor (e.g. cpp),
- * and analyse the output!
- * $gcc -E iec_std_lib.h
- */
-
-#ifndef _IEC_STD_LIB_H
-#define _IEC_STD_LIB_H
-
-
-#include <limits.h>
-#include <float.h>
-#include <math.h>
-#include <stdint.h>
-#include <ctype.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-
-#ifdef DEBUG_IEC
-#define DBG(...) printf(__VA_ARGS__);
-#define DBG_TYPE(TYPENAME, name) __print_##TYPENAME(name);
-#else
-#define DBG(...)
-#define DBG_TYPE(TYPENAME, name)
-#endif
-
-/*
- * Include type defs.
- */
-#include "iec_types_all.h"
-
-extern TIME __CURRENT_TIME;
-extern BOOL __DEBUG;
-
-/* TODO
-typedef struct {
- __strlen_t len;
- u_int16_t body[STR_MAX_LEN];
-} WSTRING;
-*/
-/*
-# if __WORDSIZE == 64
-#define __32b_sufix
-#define __64b_sufix L
-#else
-#define __32b_sufix L
-#define __64b_sufix LL
-#endif
-*/
-
-# if __WORDSIZE == 64
-#define __32b_sufix
-#define __64b_sufix L
-#else
-#define __32b_sufix L
-/* changed this from LL to L temporarily. It was causing a bug when compiling resulting code with gcc.
- * I have other things to worry about at the moment..
- */
-#define __64b_sufix L
-#endif
-
-
-#define __lit(type,value,...) (type)value##__VA_ARGS__
-// Keep this macro expention step to let sfx(__VA_ARGS__) change into L or LL
-#define __literal(type,value,...) __lit(type,value,__VA_ARGS__)
-
-#define __BOOL_LITERAL(value) __literal(BOOL,value)
-#define __SINT_LITERAL(value) __literal(SINT,value)
-#define __INT_LITERAL(value) __literal(INT,value)
-#define __DINT_LITERAL(value) __literal(DINT,value,__32b_sufix)
-#define __LINT_LITERAL(value) __literal(LINT,value,__64b_sufix)
-#define __USINT_LITERAL(value) __literal(USINT,value)
-#define __UINT_LITERAL(value) __literal(UINT,value)
-#define __UDINT_LITERAL(value) __literal(UDINT,value,__32b_sufix)
-#define __ULINT_LITERAL(value) __literal(ULINT,value,__64b_sufix)
-#define __REAL_LITERAL(value) __literal(REAL,value,__32b_sufix)
-#define __LREAL_LITERAL(value) __literal(LREAL,value,__64b_sufix)
-#define __TIME_LITERAL(value) __literal(TIME,value)
-#define __DATE_LITERAL(value) __literal(DATE,value)
-#define __TOD_LITERAL(value) __literal(TOD,value)
-#define __DT_LITERAL(value) __literal(DT,value)
-#define __STRING_LITERAL(count,value) (STRING){count,value}
-#define __BYTE_LITERAL(value) __literal(BYTE,value)
-#define __WORD_LITERAL(value) __literal(WORD,value)
-#define __DWORD_LITERAL(value) __literal(DWORD,value,__32b_sufix)
-#define __LWORD_LITERAL(value) __literal(LWORD,value,__64b_sufix)
-
-
-typedef union __IL_DEFVAR_T {
- BOOL BOOLvar;
-
- SINT SINTvar;
- INT INTvar;
- DINT DINTvar;
- LINT LINTvar;
-
- USINT USINTvar;
- UINT UINTvar;
- UDINT UDINTvar;
- ULINT ULINTvar;
-
- BYTE BYTEvar;
- WORD WORDvar;
- DWORD DWORDvar;
- LWORD LWORDvar;
-
- REAL REALvar;
- LREAL LREALvar;
-
- TIME TIMEvar;
- TOD TODvar;
- DT DTvar;
- DATE DATEvar;
-} __IL_DEFVAR_T;
-
-
-/**********************************************************************/
-/**********************************************************************/
-/***** *****/
-/***** Some helper functions... *****/
-/***** ...used later: *****/
-/***** - when declaring the IEC 61131-3 standard functions *****/
-/***** - in the C source code itself in SFC and ST expressions *****/
-/***** *****/
-/**********************************************************************/
-/**********************************************************************/
-
-
-/****************************/
-/* Notify IEC runtime error */
-/****************************/
-
-/* function that generates an IEC runtime error */
-static inline void __iec_error(void) {
- /* TODO... */
- fprintf(stderr, "IEC 61131-3 runtime error.\n");
- /*exit(1);*/
-}
-
-/*******************************/
-/* Time normalization function */
-/*******************************/
-
-static inline void __normalize_timespec (IEC_TIMESPEC *ts) {
- if( ts->tv_nsec < -1000000000 || (( ts->tv_sec > 0 ) && ( ts->tv_nsec < 0 ))){
- ts->tv_sec--;
- ts->tv_nsec += 1000000000;
- }
- if( ts->tv_nsec > 1000000000 || (( ts->tv_sec < 0 ) && ( ts->tv_nsec > 0 ))){
- ts->tv_sec++;
- ts->tv_nsec -= 1000000000;
- }
-}
-
-/**********************************************/
-/* Time conversion to/from timespec functions */
-/**********************************************/
-/* NOTE: The following function was turned into a macro, so it could be used to initialize the initial value of TIME variables.
- * Since each macro parameter is evaluated several times, the macro may result in multiple function invocations if an expression
- * containing a function invocation is passed as a parameter. However, currently matiec only uses this conversion macro with
- * constant literals, so it is safe to change it into a macro.
- */
-/* NOTE: I (Mario - msousa@fe.up.pt) believe that the following function contains a bug when handling negative times.
- * The equivalent macro has this bug fixed.
- * e.g.;
- * T#3.8s
- * using the function, will result in a timespec of 3.8s !!!:
- * tv_sec = 4 <----- 1 * 3.8 is rounded up when converting a double to an int!
- * tv_nsec = -200 000 000 <----- 1 * (3.8 - 4)*1e9
- *
- * -T#3.8s
- * using the function, will result in a timespec of -11.8s !!!:
- * tv_sec = -4 <----- -1 * 3.8 is rounded down when converting a double to an int!
- * tv_nsec = -7 800 000 000 <----- -1 * (3.8 - -4)*1e9
- */
-/* NOTE: Due to the fact that the C compiler may round a tv_sec number away from zero,
- * the following macro may result in a timespec that is not normalized, i.e. with a tv_sec > 0, and a tv_nsec < 0 !!!!
- * This is due to the rounding that C compiler applies when converting a (long double) to a (long int).
- * To produce normalized timespec's we need to use floor(), but we cannot call any library functions since we want this macro to be
- * useable as a variable initializer.
- * VAR x : TIME = T#3.5h; END_VAR ---> IEC_TIME x = __time_to_timespec(1, 0, 0, 0, 3.5, 0);
- */
-/*
-static inline IEC_TIMESPEC __time_to_timespec(int sign, double mseconds, double seconds, double minutes, double hours, double days) {
- IEC_TIMESPEC ts;
-
- // sign is 1 for positive values, -1 for negative time...
- long double total_sec = ((days*24 + hours)*60 + minutes)*60 + seconds + mseconds/1e3;
- if (sign >= 0) sign = 1; else sign = -1;
- ts.tv_sec = sign * (long int)total_sec;
- ts.tv_nsec = sign * (long int)((total_sec - ts.tv_sec)*1e9);
-
- return ts;
-}
-*/
-/* NOTE: Unfortunately older versions of ANSI C (e.g. C99) do not allow explicit identification of elements in initializers
- * e.g. {tv_sec = 1, tv_nsec = 300}
- * They are therefore commented out. This however means that any change to the definition of IEC_TIMESPEC may require this
- * macro to be updated too!
- */
-#define __time_to_timespec(sign,mseconds,seconds,minutes,hours,days) \
- ((IEC_TIMESPEC){\
- /*tv_sec =*/ ((long int) (((sign>=0)?1:-1)*((((long double)days*24 + (long double)hours)*60 + (long double)minutes)*60 + (long double)seconds + (long double)mseconds/1e3))), \
- /*tv_nsec =*/ ((long int)(( \
- ((long double)(((sign>=0)?1:-1)*((((long double)days*24 + (long double)hours)*60 + (long double)minutes)*60 + (long double)seconds + (long double)mseconds/1e3))) - \
- ((long int) (((sign>=0)?1:-1)*((((long double)days*24 + (long double)hours)*60 + (long double)minutes)*60 + (long double)seconds + (long double)mseconds/1e3))) \
- )*1e9))\
- })
-
-
-
-
-/* NOTE: The following function was turned into a macro, so it could be used to initialize the initial value of TOD (TIME_OF_DAY) variables */
-/* NOTE: many (but not all) of the same comments made regarding __time_to_timespec() are also valid here, so go and read those comments too!
-/*
-static inline IEC_TIMESPEC __tod_to_timespec(double seconds, double minutes, double hours) {
- IEC_TIMESPEC ts;
-
- long double total_sec = (hours*60 + minutes)*60 + seconds;
- ts.tv_sec = (long int)total_sec;
- ts.tv_nsec = (long int)((total_sec - ts.tv_sec)*1e9);
-
- return ts;
-}
-*/
-#define __tod_to_timespec(seconds,minutes,hours) \
- ((IEC_TIMESPEC){\
- /*tv_sec =*/ ((long int) ((((long double)hours)*60 + (long double)minutes)*60 + (long double)seconds)), \
- /*tv_nsec =*/ ((long int)(( \
- ((long double)((((long double)hours)*60 + (long double)minutes)*60 + (long double)seconds)) - \
- ((long int) ((((long double)hours)*60 + (long double)minutes)*60 + (long double)seconds)) \
- )*1e9))\
- })
-
-
-#define EPOCH_YEAR 1970
-#define SECONDS_PER_MINUTE 60
-#define SECONDS_PER_HOUR (60 * SECONDS_PER_MINUTE)
-#define SECONDS_PER_DAY (24 * SECONDS_PER_HOUR)
-#define __isleap(year) \
- ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
-static const unsigned short int __mon_yday[2][13] =
-{
- /* Normal years. */
- { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
- /* Leap years. */
- { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}
-};
-
-typedef struct {
- int tm_sec; /* Seconds. [0-60] (1 leap second) */
- int tm_min; /* Minutes. [0-59] */
- int tm_hour; /* Hours. [0-23] */
- int tm_day; /* Day. [1-31] */
- int tm_mon; /* Month. [0-11] */
- int tm_year; /* Year */
-} tm;
-
-static inline tm convert_seconds_to_date_and_time(long int seconds) {
- tm dt;
- long int days, rem;
- days = seconds / SECONDS_PER_DAY;
- rem = seconds % SECONDS_PER_DAY;
- if (rem < 0) {
- rem += SECONDS_PER_DAY;
- days--;
- }
-
- // time of day
- dt.tm_hour = rem / SECONDS_PER_HOUR;
- rem %= SECONDS_PER_HOUR;
- dt.tm_min = rem / 60;
- dt.tm_sec = rem % 60;
-
- // date
- dt.tm_year = EPOCH_YEAR;
- while (days >= (rem = __isleap(dt.tm_year) ? 366 : 365)) {
- dt.tm_year++;
- days -= rem;
- }
- while (days < 0) {
- dt.tm_year--;
- days += __isleap(dt.tm_year) ? 366 : 365;
- }
- dt.tm_mon = 1;
- while (days > __mon_yday[__isleap(dt.tm_year)][dt.tm_mon]) {
- dt.tm_mon += 1;
- }
- dt.tm_day = days - __mon_yday[__isleap(dt.tm_year)][dt.tm_mon - 1] + 1;
-
- return dt;
-}
-
-static inline IEC_TIMESPEC __date_to_timespec(int day, int month, int year) {
- IEC_TIMESPEC ts;
- int a4, b4, a100, b100, a400, b400;
- int yday;
- int intervening_leap_days;
-
- if (month < 1 || month > 12)
- __iec_error();
-
- yday = __mon_yday[__isleap(year)][month - 1] + day;
-
- if (yday > __mon_yday[__isleap(year)][month])
- __iec_error();
-
- a4 = (year >> 2) - ! (year & 3);
- b4 = (EPOCH_YEAR >> 2) - ! (EPOCH_YEAR & 3);
- a100 = a4 / 25 - (a4 % 25 < 0);
- b100 = b4 / 25 - (b4 % 25 < 0);
- a400 = a100 >> 2;
- b400 = b100 >> 2;
- intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
-
- ts.tv_sec = ((year - EPOCH_YEAR) * 365 + intervening_leap_days + yday - 1) * 24 * 60 * 60;
- ts.tv_nsec = 0;
-
- return ts;
-}
-
-static inline IEC_TIMESPEC __dt_to_timespec(double seconds, double minutes, double hours, int day, int month, int year) {
- IEC_TIMESPEC ts_date = __date_to_timespec(day, month, year);
- IEC_TIMESPEC ts = __tod_to_timespec(seconds, minutes, hours);
-
- ts.tv_sec += ts_date.tv_sec;
-
- return ts;
-}
-
-/*******************/
-/* Time operations */
-/*******************/
-
-#define __time_cmp(t1, t2) (t2.tv_sec == t1.tv_sec ? t1.tv_nsec - t2.tv_nsec : t1.tv_sec - t2.tv_sec)
-
-static inline TIME __time_add(TIME IN1, TIME IN2){
- TIME res ={IN1.tv_sec + IN2.tv_sec,
- IN1.tv_nsec + IN2.tv_nsec };
- __normalize_timespec(&res);
- return res;
-}
-static inline TIME __time_sub(TIME IN1, TIME IN2){
- TIME res ={IN1.tv_sec - IN2.tv_sec,
- IN1.tv_nsec - IN2.tv_nsec };
- __normalize_timespec(&res);
- return res;
-}
-static inline TIME __time_mul(TIME IN1, LREAL IN2){
- LREAL s_f = IN1.tv_sec * IN2;
- time_t s = (time_t)s_f;
- div_t ns = div((int)((LREAL)IN1.tv_nsec * IN2), 1000000000);
- TIME res = {(long)s + ns.quot,
- (long)ns.rem + (s_f - s) * 1000000000 };
- __normalize_timespec(&res);
- return res;
-}
-static inline TIME __time_div(TIME IN1, LREAL IN2){
- LREAL s_f = IN1.tv_sec / IN2;
- time_t s = (time_t)s_f;
- TIME res = {(long)s,
- (long)(IN1.tv_nsec / IN2 + (s_f - s) * 1000000000) };
- __normalize_timespec(&res);
- return res;
-}
-
-
-/***************/
-/* Convertions */
-/***************/
- /*****************/
- /* REAL_TO_INT */
- /*****************/
-static inline LINT __real_round(LREAL IN) {
- return fmod(IN, 1) == 0 ? ((LINT)IN / 2) * 2 : (LINT)IN;
-}
-static inline LINT __preal_to_sint(LREAL IN) {
- return IN >= 0 ? __real_round(IN + 0.5) : __real_round(IN - 0.5);
-}
-static inline LINT __preal_to_uint(LREAL IN) {
- return IN >= 0 ? __real_round(IN + 0.5) : 0;
-}
-static inline LINT __real_to_sint(LREAL IN) {return (LINT)__preal_to_sint(IN);}
-static inline LWORD __real_to_bit(LREAL IN) {return (LWORD)__preal_to_uint(IN);}
-static inline ULINT __real_to_uint(LREAL IN) {return (ULINT)__preal_to_uint(IN);}
-
- /***************/
- /* TO_STRING */
- /***************/
-static inline STRING __bool_to_string(BOOL IN) {
- if(IN) return (STRING){4, "TRUE"};
- return (STRING){5,"FALSE"};
-}
-static inline STRING __bit_to_string(LWORD IN) {
- STRING res;
- res = __INIT_STRING;
- res.len = snprintf((char*)res.body, STR_MAX_LEN, "16#%llx",(long long unsigned int)IN);
- if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
- return res;
-}
-static inline STRING __real_to_string(LREAL IN) {
- STRING res;
- res = __INIT_STRING;
- res.len = snprintf((char*)res.body, STR_MAX_LEN, "%.10g", IN);
- if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
- return res;
-}
-static inline STRING __sint_to_string(LINT IN) {
- STRING res;
- res = __INIT_STRING;
- res.len = snprintf((char*)res.body, STR_MAX_LEN, "%lld", (long long int)IN);
- if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
- return res;
-}
-static inline STRING __uint_to_string(ULINT IN) {
- STRING res;
- res = __INIT_STRING;
- res.len = snprintf((char*)res.body, STR_MAX_LEN, "%llu", (long long unsigned int)IN);
- if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
- return res;
-}
- /***************/
- /* FROM_STRING */
- /***************/
-static inline BOOL __string_to_bool(STRING IN) {
- int i;
- if (IN.len == 1) return !memcmp(&IN.body,"1", IN.len);
- for (i = 0; i < IN.len; i++) IN.body[i] = toupper(IN.body[i]);
- return IN.len == 4 ? !memcmp(&IN.body,"TRUE", IN.len) : 0;
-}
-
-static inline LINT __pstring_to_sint(STRING* IN) {
- LINT res = 0;
- __strlen_t l;
- unsigned int shift = 0;
-
- if(IN->body[0]=='2' && IN->body[1]=='#'){
- /* 2#0101_1010_1011_1111 */
- for(l = IN->len - 1; l >= 2 && shift < 64; l--)
- {
- char c = IN->body[l];
- if( c >= '0' && c <= '1'){
- res |= ( c - '0') << shift;
- shift += 1;
- }
- }
- }else if(IN->body[0]=='8' && IN->body[1]=='#'){
- /* 8#1234_5665_4321 */
- for(l = IN->len - 1; l >= 2 && shift < 64; l--)
- {
- char c = IN->body[l];
- if( c >= '0' && c <= '7'){
- res |= ( c - '0') << shift;
- shift += 3;
- }
- }
- }else if(IN->body[0]=='1' && IN->body[1]=='6' && IN->body[2]=='#'){
- /* 16#1234_5678_9abc_DEFG */
- for(l = IN->len - 1; l >= 3 && shift < 64; l--)
- {
- char c = IN->body[l];
- if( c >= '0' && c <= '9'){
- res |= (LWORD)( c - '0') << shift;
- shift += 4;
- }else if( c >= 'a' && c <= 'f'){
- res |= (LWORD)( c - 'a' + 10 ) << shift;
- shift += 4;
- }else if( c >= 'A' && c <= 'F'){
- res |= (LWORD)( c - 'A' + 10 ) << shift;
- shift += 4;
- }
- }
- }else{
- /* -123456789 */
- LINT fac = IN->body[0] == '-' ? -1 : 1;
- for(l = IN->len - 1; l >= 0 && shift < 20; l--)
- {
- char c = IN->body[l];
- if( c >= '0' && c <= '9'){
- res += ( c - '0') * fac;
- fac *= 10;
- shift += 1;
- }else if( c >= '.' ){ /* reset value */
- res = 0;
- fac = IN->body[0] == '-' ? -1 : 1;
- shift = 0;
- }
- }
- }
- return res;
-}
-
-static inline LINT __string_to_sint(STRING IN) {return (LINT)__pstring_to_sint(&IN);}
-static inline LWORD __string_to_bit (STRING IN) {return (LWORD)__pstring_to_sint(&IN);}
-static inline ULINT __string_to_uint(STRING IN) {return (ULINT)__pstring_to_sint(&IN);}
-static inline LREAL __string_to_real(STRING IN) {
- __strlen_t l;
- l = IN.len;
- /* search the dot */
- while(--l > 0 && IN.body[l] != '.');
- if(l != 0){
- return atof((const char *)&IN.body);
- }else{
- return (LREAL)__pstring_to_sint(&IN);
- }
-}
-
- /***************/
- /* TO_TIME */
- /***************/
-static inline TIME __int_to_time(LINT IN) {return (TIME){IN, 0};}
-static inline TIME __real_to_time(LREAL IN) {return (TIME){IN, (IN - (LINT)IN) * 1000000000};}
-static inline TIME __string_to_time(STRING IN){
- __strlen_t l;
- /* TODO :
- *
- * Duration literals without underlines: T#14ms T#-14ms T#14.7s T#14.7m
- * short prefix T#14.7h t#14.7d t#25h15m
- * t#5d14h12m18s3.5ms
- * long prefix TIME#14ms TIME#-14ms time#14.7s
- * Duration literals with underlines:
- * short prefix t#25h_15m t#5d_14h_12m_18s_3.5ms
- * long prefix TIME#25h_15m
- * time#5d_14h_12m_18s_3.5ms
- *
- * Long prefix notation Short prefix notation
- * DATE#1984-06-25 D#1984-06-25
- * date#1984-06-25 d#1984-06-25
- * TIME_OF_DAY#15:36:55.36 TOD#15:36:55.36
- * time_of_day#15:36:55.36 tod#15:36:55.36
- * DATE_AND_TIME#1984-06-25-15:36:55.36 DT#1984-06-25-15:36:55.36
- * date_and_time#1984-06-25-15:36:55.36 dt#1984-06-25-15:36:55.36
- *
- */
- /* Quick hack : only transform seconds */
- /* search the dot */
- l = IN.len;
- while(--l > 0 && IN.body[l] != '.');
- if(l != 0){
- LREAL IN_val = atof((const char *)&IN.body);
- return (TIME){(long)IN_val, (long)(IN_val - (LINT)IN_val)*1000000000};
- }else{
- return (TIME){(long)__pstring_to_sint(&IN), 0};
- }
-}
-
- /***************/
- /* FROM_TIME */
- /***************/
-static inline LREAL __time_to_real(TIME IN){
- return (LREAL)IN.tv_sec + ((LREAL)IN.tv_nsec/1000000000);
-}
-static inline LINT __time_to_int(TIME IN) {return IN.tv_sec;}
-static inline STRING __time_to_string(TIME IN){
- STRING res;
- div_t days;
- /*t#5d14h12m18s3.5ms*/
- res = __INIT_STRING;
- days = div(IN.tv_sec, SECONDS_PER_DAY);
- if(!days.rem && IN.tv_nsec == 0){
- res.len = snprintf((char*)&res.body, STR_MAX_LEN, "T#%dd", days.quot);
- }else{
- div_t hours = div(days.rem, SECONDS_PER_HOUR);
- if(!hours.rem && IN.tv_nsec == 0){
- res.len = snprintf((char*)&res.body, STR_MAX_LEN, "T#%dd%dh", days.quot, hours.quot);
- }else{
- div_t minuts = div(hours.rem, SECONDS_PER_MINUTE);
- if(!minuts.rem && IN.tv_nsec == 0){
- res.len = snprintf((char*)&res.body, STR_MAX_LEN, "T#%dd%dh%dm", days.quot, hours.quot, minuts.quot);
- }else{
- if(IN.tv_nsec == 0){
- res.len = snprintf((char*)&res.body, STR_MAX_LEN, "T#%dd%dh%dm%ds", days.quot, hours.quot, minuts.quot, minuts.rem);
- }else{
- res.len = snprintf((char*)&res.body, STR_MAX_LEN, "T#%dd%dh%dm%ds%gms", days.quot, hours.quot, minuts.quot, minuts.rem, (LREAL)IN.tv_nsec / 1000000);
- }
- }
- }
- }
- if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
- return res;
-}
-static inline STRING __date_to_string(DATE IN){
- STRING res;
- tm broken_down_time;
- /* D#1984-06-25 */
- broken_down_time = convert_seconds_to_date_and_time(IN.tv_sec);
- res = __INIT_STRING;
- res.len = snprintf((char*)&res.body, STR_MAX_LEN, "D#%d-%2.2d-%2.2d",
- broken_down_time.tm_year,
- broken_down_time.tm_mon,
- broken_down_time.tm_day);
- if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
- return res;
-}
-static inline STRING __tod_to_string(TOD IN){
- STRING res;
- tm broken_down_time;
- time_t seconds;
- /* TOD#15:36:55.36 */
- seconds = IN.tv_sec;
- if (seconds >= SECONDS_PER_DAY){
- __iec_error();
- return (STRING){9,"TOD#ERROR"};
- }
- broken_down_time = convert_seconds_to_date_and_time(seconds);
- res = __INIT_STRING;
- if(IN.tv_nsec == 0){
- res.len = snprintf((char*)&res.body, STR_MAX_LEN, "TOD#%2.2d:%2.2d:%2.2d",
- broken_down_time.tm_hour,
- broken_down_time.tm_min,
- broken_down_time.tm_sec);
- }else{
- res.len = snprintf((char*)&res.body, STR_MAX_LEN, "TOD#%2.2d:%2.2d:%09.6f",
- broken_down_time.tm_hour,
- broken_down_time.tm_min,
- (LREAL)broken_down_time.tm_sec + (LREAL)IN.tv_nsec / 1e9);
- }
- if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
- return res;
-}
-static inline STRING __dt_to_string(DT IN){
- STRING res;
- tm broken_down_time;
- /* DT#1984-06-25-15:36:55.36 */
- broken_down_time = convert_seconds_to_date_and_time(IN.tv_sec);
- if(IN.tv_nsec == 0){
- res.len = snprintf((char*)&res.body, STR_MAX_LEN, "DT#%d-%2.2d-%2.2d-%2.2d:%2.2d:%2.2d",
- broken_down_time.tm_year,
- broken_down_time.tm_mon,
- broken_down_time.tm_day,
- broken_down_time.tm_hour,
- broken_down_time.tm_min,
- broken_down_time.tm_sec);
- }else{
- res.len = snprintf((char*)&res.body, STR_MAX_LEN, "DT#%d-%2.2d-%2.2d-%2.2d:%2.2d:%09.6f",
- broken_down_time.tm_year,
- broken_down_time.tm_mon,
- broken_down_time.tm_day,
- broken_down_time.tm_hour,
- broken_down_time.tm_min,
- (LREAL)broken_down_time.tm_sec + ((LREAL)IN.tv_nsec / 1e9));
- }
- if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
- return res;
-}
-
- /**********************************************/
- /* [ANY_DATE | TIME] _TO_ [ANY_DATE | TIME] */
- /**********************************************/
-
-static inline TOD __date_and_time_to_time_of_day(DT IN) {
- return (TOD){
- IN.tv_sec % SECONDS_PER_DAY + (IN.tv_sec < 0 ? SECONDS_PER_DAY : 0),
- IN.tv_nsec};
-}
-static inline DATE __date_and_time_to_date(DT IN){
- return (DATE){
- IN.tv_sec - IN.tv_sec % SECONDS_PER_DAY - (IN.tv_sec < 0 ? SECONDS_PER_DAY : 0),
- 0};
-}
-
- /*****************/
- /* FROM/TO BCD */
- /*****************/
-
-static inline BOOL __test_bcd(LWORD IN) {
- while (IN) {
- if ((IN & 0xf) > 9) return 1;
- IN >>= 4;
- }
- return 0;
-}
-
-static inline ULINT __bcd_to_uint(LWORD IN){
- ULINT res = IN & 0xf;
- ULINT factor = 10ULL;
-
- while (IN >>= 4) {
- res += (IN & 0xf) * factor;
- factor *= 10;
- }
- return res;
-}
-
-static inline LWORD __uint_to_bcd(ULINT IN){
- LWORD res = IN % 10;
- USINT shift = 4;
-
- while (IN /= 10) {
- res |= (IN % 10) << shift;
- shift += 4;
- }
- return res;
-}
-
-
- /************/
- /* MOVE_* */
- /************/
-
-/* some helpful __move_[ANY] functions, used in the *_TO_** and MOVE standard functions */
-/* e.g. __move_BOOL, __move_BYTE, __move_REAL, __move_TIME, ... */
-#define __move_(TYPENAME)\
-static inline TYPENAME __move_##TYPENAME(TYPENAME op1) {return op1;}
-__ANY(__move_)
-
-
-
-/*****************************************************************/
-/*****************************************************************/
-/***** *****/
-/***** IEC 61131-3 *****/
-/***** S T A N D A R D F U N C T I O N S *****/
-/***** *****/
-/*****************************************************************/
-/*****************************************************************/
-
-/* NOTE: If you want to know what all these strange macros are doing,
- * just parse this file through a C preprocessor, and analyse the output!
- * $gcc -E iec_std_lib.h
- */
-
-/* NOTE: We only define and declare the explicitly typed standard functions
- * (e.g., SIN_REAL, SIN_LREAL, ..., ADD_SINT, ADD_INT, ADD_LINT, ...)
- * We do not declare/define the overloaded functions
- * (SIN, ADD, ...).
- * When handling a call to an overloaded function, the iec2c compiler
- * will determine in stage3 the data type of the parameter being passed,
- * and in stage4 generate the C code to call the correct
- * typed standard function.
- */
-
-/* NOTE on explicit typing of:
- * - Table 25 - Standard bit shift functions
- * - Table 29 - Character string Functions
- *
- * In section 2.5.1.4 (Typing, overloading, and type conversion) of the IEC 61131-3 (version 2)
- * of the standard, it is stated:
- * "A standard function, [...] is said to be overloaded when it
- * can operate on input data elements of various types within a generic type designator as defined in
- * 2.3.2. For instance, an overloaded addition function on generic type ANY_NUM can operate on data
- * of types LREAL, REAL, DINT, INT, and SINT."
- * [...]
- * "When a function which normally represents an overloaded operator is to be typed, i.e., the types
- * of its inputs and outputs restricted to a particular elementary or derived data type as defined in
- * 2.3, this shall be done by appending an "underline" character followed by the required type, as
- * shown in table 21."
- *
- * However, this explanation (as well as the example in table 21) only refers to functions where the same
- * generic data type is used for the single input and the output parameter.
- * How can we create explicitly types functions when this is not the case?
- * It does not seem to be covered by the standard.
- *
- * For this reason, we do not define the LEN_SINT, LEN_INT, LEN_STRING, LEN_[ANY_INT], LEN_[ANY_STRING] functions...
- */
-
-
-/********************/
-/* EN/ENO PARAMS */
-/********************/
-
-#define EN_ENO_PARAMS BOOL EN, BOOL *ENO
-#define EN_ENO EN, ENO
-
-#define TEST_EN(TYPENAME)\
- if (!EN) {\
- if (ENO != NULL)\
- *ENO = __BOOL_LITERAL(FALSE);\
- return __INIT_##TYPENAME;\
- }\
- else if (ENO != NULL)\
- *ENO = __BOOL_LITERAL(TRUE);
-
-#define TEST_EN_COND(TYPENAME, COND)\
- if (!EN || (COND)) {\
- if (ENO != NULL)\
- *ENO = __BOOL_LITERAL(FALSE);\
- return __INIT_##TYPENAME;\
- }\
- else if (ENO != NULL)\
- *ENO = __BOOL_LITERAL(TRUE);
-
-
-
-/*****************************************/
-/*****************************************/
-/* 2.5.1.5.1 Type Conversion Functions */
-/*****************************************/
-/*****************************************/
-
-#define __convert_type(from_TYPENAME,to_TYPENAME, oper) \
-static inline to_TYPENAME from_TYPENAME##_TO_##to_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\
- TEST_EN(to_TYPENAME)\
- return (to_TYPENAME)oper(op);\
-}
-
-/******** [ANY_NUM | ANY_NBIT]_TO_BOOL ************/
-#define __convert_num_to_bool(TYPENAME) \
-static inline BOOL TYPENAME##_TO_BOOL(EN_ENO_PARAMS, TYPENAME op){\
- TEST_EN(BOOL)\
- return op == 0 ? 0 : 1;\
-}
-__ANY_NUM(__convert_num_to_bool)
-__ANY_NBIT(__convert_num_to_bool)
-
-/******** [TIME | ANY_DATE]_TO_BOOL ************/
-#define __convert_time_to_bool(TYPENAME) \
-static inline BOOL TYPENAME##_TO_BOOL(EN_ENO_PARAMS, TYPENAME op){\
- TEST_EN(BOOL)\
- return op.tv_sec == 0 && op.tv_nsec == 0 ? 0 : 1;\
-}
-__convert_time_to_bool(TIME)
-__ANY_DATE(__convert_time_to_bool)
-
-#define __to_anynum_(from_TYPENAME) __ANY_NUM_1(__iec_,from_TYPENAME)
-#define __to_anyint_(from_TYPENAME) __ANY_INT_1(__iec_,from_TYPENAME)
-#define __to_anybit_(from_TYPENAME) __ANY_BIT_1(__iec_,from_TYPENAME)
-#define __to_anynbit_(from_TYPENAME) __ANY_NBIT_1(__iec_,from_TYPENAME)
-#define __to_anysint_(from_TYPENAME) __ANY_SINT_1(__iec_,from_TYPENAME)
-#define __to_anyuint_(from_TYPENAME) __ANY_UINT_1(__iec_,from_TYPENAME)
-#define __to_anyreal_(from_TYPENAME) __ANY_REAL_1(__iec_,from_TYPENAME)
-#define __to_anydate_(from_TYPENAME) __ANY_DATE_1(__iec_,from_TYPENAME)
-
-/******** [ANY_BIT]_TO_[ANY_NUM | ANT_NBIT] ************/
-#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __move_##to_TYPENAME)
-__ANY_BIT(__to_anynum_)
-__ANY_BIT(__to_anynbit_)
-#undef __iec_
-
-/******** [ANY_INT]_TO_[ANY_NUM | ANT_NBIT] ************/
-#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __move_##to_TYPENAME)
-__ANY_INT(__to_anynum_)
-__ANY_INT(__to_anynbit_)
-#undef __iec_
-
-/******** [ANY_REAL]_TO_[ANY_NBIT] ************/
-#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_bit)
-__ANY_REAL(__to_anynbit_)
-#undef __iec_
-
-/******** [ANY_REAL]_TO_[ANY_NINT] ************/
-#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_sint)
-__ANY_REAL(__to_anysint_)
-#undef __iec_
-#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_uint)
-__ANY_REAL(__to_anyuint_)
-#undef __iec_
-
-/******** [ANY_REAL]_TO_[ANY_REAL] ************/
-#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __move_##to_TYPENAME)
-__ANY_REAL(__to_anyreal_)
-#undef __iec_
-
-/******** [ANY_BIT | ANY_INT]_TO_[TIME | ANY_DATE] ************/
-#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, TIME, __int_to_time)
-__ANY_BIT(__iec_)
-__ANY_INT(__iec_)
-#undef __iec_
-#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __int_to_time)
-__ANY_BIT(__to_anydate_)
-__ANY_INT(__to_anydate_)
-#undef __iec_
-
-/******** [ANY_REAL]_TO_[TIME | ANY_DATE] ************/
-#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, TIME, __real_to_time)
-__ANY_REAL(__iec_)
-#undef __iec_
-#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_time)
-__ANY_REAL(__to_anydate_)
-#undef __iec_
-
-/******** [TIME | ANY_DATE]_TO_[ANY_BIT | ANY_INT] ************/
-#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __time_to_int)
-__to_anyint_(TIME)
-__to_anynbit_(TIME)
-__ANY_DATE(__to_anyint_)
-__ANY_DATE(__to_anynbit_)
-#undef __iec_
-
-/******** [TIME | ANY_DATE]_TO_[ANY_REAL] ************/
-#define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __time_to_real)
-__to_anyreal_(TIME)
-__ANY_DATE(__to_anyreal_)
-#undef __iec_
-
-
-/******** [ANY_DATE]_TO_[ANY_DATE | TIME] ************/
-/* Not supported: DT_TO_TIME */
-__convert_type(DT, DATE, __date_and_time_to_date)
-static inline DATE DATE_AND_TIME_TO_DATE(EN_ENO_PARAMS, DT op){
- return DT_TO_DATE(EN_ENO, op);
-}
-__convert_type(DT, DT, __move_DT)
-__convert_type(DT, TOD, __date_and_time_to_time_of_day)
-static inline DATE DATE_AND_TIME_TO_TIME_OF_DAY(EN_ENO_PARAMS, DT op){
- return DT_TO_TOD(EN_ENO, op);
-}
-/* Not supported: DATE_TO_TIME */
-__convert_type(DATE, DATE, __move_DATE)
-/* Not supported: DATE_TO_DT */
-/* Not supported: DATE_TO_TOD */
-/* Not supported: TOD_TO_TIME */
-/* Not supported: TOD_TO_DATE */
-/* Not supported: TOD_TO_DT */
-__convert_type(TOD, TOD, __move_TOD)
-
-
-/******** TIME_TO_[ANY_DATE] ************/
-/* Not supported: TIME_TO_DATE */
-/* Not supported: TIME_TO_DT */
-/* Not supported: TIME_TO_TOD */
-
-/******** TIME_TO_TIME ************/
-__convert_type(TIME, TIME, __move_TIME)
-
-
-/******** [ANY_BIT]_TO_STRING ************/
-__convert_type(BOOL, STRING, __bool_to_string)
-#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __bit_to_string)
-__ANY_NBIT(__iec_)
-#undef __iec_
-
-/******** [ANY_INT]_TO_STRING ************/
-#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __sint_to_string)
-__ANY_SINT(__iec_)
-#undef __iec_
-#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __uint_to_string)
-__ANY_UINT(__iec_)
-#undef __iec_
-
-/******** [ANY_REAL]_TO_STRING ************/
-#define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __real_to_string)
-__ANY_REAL(__iec_)
-#undef __iec_
-
-/******** [ANY_DATE]_TO_STRING ************/
-__convert_type(DATE, STRING, __date_to_string)
-__convert_type(DT, STRING, __dt_to_string)
-__convert_type(TOD, STRING, __tod_to_string)
-
-/******** TIME_TO_STRING ************/
-__convert_type(TIME, STRING, __time_to_string)
-
-
-/******** STRING_TO_[ANY_BIT] ************/
-__convert_type(STRING, BOOL, __string_to_bool)
-#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_bit)
-__ANY_NBIT(__iec_)
-#undef __iec_
-
-/******** STRING_TO_[ANY_INT] ************/
-#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_sint)
-__ANY_SINT(__iec_)
-#undef __iec_
-#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_uint)
-__ANY_UINT(__iec_)
-#undef __iec_
-
-/******** STRING_TO_[ANY_REAL] ************/
-#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_real)
-__ANY_REAL(__iec_)
-#undef __iec_
-
-/******** STRING_TO_[ANY_DATE] ************/
-#define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_time)
-__ANY_DATE(__iec_)
-#undef __iec_
-
-/******** STRING_TO_TIME ************/
-__convert_type(STRING, TIME, __string_to_time)
-
-
-/******** TRUNC ************/
-#define __iec_(to_TYPENAME,from_TYPENAME) \
-static inline to_TYPENAME TRUNC__##to_TYPENAME##__##from_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\
- TEST_EN(to_TYPENAME)\
- return (to_TYPENAME)__move_##to_TYPENAME(op);\
-}
-__ANY_REAL(__to_anyint_)
-#undef __iec_
-
-
-/******** _TO_BCD ************/
-#define __iec_(to_TYPENAME,from_TYPENAME) \
-static inline to_TYPENAME from_TYPENAME##_TO_BCD_##to_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\
- TEST_EN(to_TYPENAME)\
- return (to_TYPENAME)__uint_to_bcd(op);\
-}\
-static inline to_TYPENAME from_TYPENAME##_TO_BCD__##to_TYPENAME##__##from_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\
- return from_TYPENAME##_TO_BCD_##to_TYPENAME(EN_ENO, op);\
-}
-__ANY_UINT(__to_anynbit_)
-#undef __iec_
-
-
-/******** BCD_TO_ ************/
-#define __iec_(to_TYPENAME,from_TYPENAME) \
-static inline to_TYPENAME from_TYPENAME##_BCD_TO_##to_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\
- TEST_EN_COND(to_TYPENAME, __test_bcd(op))\
- return (to_TYPENAME)__bcd_to_uint(op);\
-}\
-static inline to_TYPENAME BCD_TO_##to_TYPENAME##__##to_TYPENAME##__##from_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\
- return from_TYPENAME##_BCD_TO_##to_TYPENAME(EN_ENO, op);\
-}
-__ANY_NBIT(__to_anyuint_)
-#undef __iec_
-
-
-/***********************************/
-/***********************************/
-/* 2.5.1.5.2 Numerical Functions */
-/***********************************/
-/***********************************/
-
-/* workaround for va-args limitation on shorter than int params */
-#define VA_ARGS_REAL LREAL
-#define VA_ARGS_LREAL LREAL
-#define VA_ARGS_SINT DINT
-#define VA_ARGS_INT DINT
-#define VA_ARGS_DINT DINT
-#define VA_ARGS_LINT LINT
-#define VA_ARGS_USINT UDINT
-#define VA_ARGS_UINT UDINT
-#define VA_ARGS_UDINT UDINT
-#define VA_ARGS_ULINT ULINT
-#define VA_ARGS_TIME TIME
-#define VA_ARGS_BOOL DWORD
-#define VA_ARGS_BYTE DWORD
-#define VA_ARGS_WORD DWORD
-#define VA_ARGS_DWORD DWORD
-#define VA_ARGS_LWORD LWORD
-#define VA_ARGS_STRING STRING
-#define VA_ARGS_WSTRING WSTRING
-#define VA_ARGS_DATE DATE
-#define VA_ARGS_TOD TOD
-#define VA_ARGS_DT DT
-
-
-#define __numeric(fname,TYPENAME, FUNC) \
-/* explicitly typed function */\
-static inline TYPENAME fname##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\
- TEST_EN(TYPENAME)\
- return FUNC(op);\
-}\
-/* overloaded function */\
-static inline TYPENAME fname##_##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op) {\
- return fname##TYPENAME(EN_ENO, op);\
-}
-
-/******************************************************************/
-/*** Table 23 - Standard functions of one numeric variable ***/
-/******************************************************************/
-
- /**************/
- /* ABS */
- /**************/
-#define __abs_signed(TYPENAME) \
-/* explicitly typed function */\
-static inline TYPENAME ABS_##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\
- TEST_EN(TYPENAME)\
- if (op < 0)\
- return -op;\
- return op;\
-}\
-/* overloaded function */\
-static inline TYPENAME ABS__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op) {\
- return ABS_##TYPENAME(EN_ENO, op);\
-}
-
-#define __abs_unsigned(TYPENAME) \
-/* explicitly typed function */\
-static inline TYPENAME ABS_##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\
- TEST_EN(TYPENAME)\
- return op;\
-}\
-/* overloaded function */\
-static inline TYPENAME ABS__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op) {\
- return ABS_##TYPENAME(EN_ENO, op);\
-}
-
-__ANY_REAL(__abs_signed)
-__ANY_SINT(__abs_signed)
-__ANY_UINT(__abs_unsigned)
-
-
- /**************/
- /* SQRT */
- /**************/
-#define __sqrt(TYPENAME) __numeric(SQRT_, TYPENAME, sqrt)
-__ANY_REAL(__sqrt)
-
-
-/**************/
- /* LN */
- /**************/
-#define __ln(TYPENAME) __numeric(LN_, TYPENAME, log)
-__ANY_REAL(__ln)
-
-
- /**************/
- /* LOG */
- /**************/
-#define __log(TYPENAME) __numeric(LOG_, TYPENAME, log10)
-__ANY_REAL(__log)
-
-
- /**************/
- /* EXP */
- /**************/
-#define __exp(TYPENAME) __numeric(EXP_, TYPENAME, exp)
-__ANY_REAL(__exp)
-
-
- /**************/
- /* SIN */
- /**************/
-#define __sin(TYPENAME) __numeric(SIN_, TYPENAME, sin)
-__ANY_REAL(__sin)
-
-
- /**************/
- /* COS */
- /**************/
-#define __cos(TYPENAME) __numeric(COS_, TYPENAME, cos)
-__ANY_REAL(__cos)
-
- /**************/
- /* TAN */
- /**************/
-#define __tan(TYPENAME) __numeric(TAN_, TYPENAME, tan)
-__ANY_REAL(__tan)
-
-
- /**************/
- /* ASIN */
- /**************/
-#define __asin(TYPENAME) __numeric(ASIN_, TYPENAME, asin)
-__ANY_REAL(__asin)
-
- /**************/
- /* ACOS */
- /**************/
-#define __acos(TYPENAME) __numeric(ACOS_, TYPENAME, acos)
-__ANY_REAL(__acos)
-
- /**************/
- /* ATAN */
- /**************/
-#define __atan(TYPENAME) __numeric(ATAN_, TYPENAME, atan)
-__ANY_REAL(__atan)
-
-
-
-/*****************************************************/
-/*** Table 24 - Standard arithmetic functions ***/
-/*****************************************************/
-
-#define __arith_expand(fname,TYPENAME, OP)\
-static inline TYPENAME fname(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\
- va_list ap;\
- UINT i;\
- TEST_EN(TYPENAME)\
- \
- va_start (ap, op1); /* Initialize the argument list. */\
- \
- for (i = 0; i < param_count - 1; i++){\
- op1 = op1 OP va_arg (ap, VA_ARGS_##TYPENAME);\
- }\
- \
- va_end (ap); /* Clean up. */\
- return op1;\
-}
-
-#define __arith_static(fname,TYPENAME, OP)\
-/* explicitly typed function */\
-static inline TYPENAME fname##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
- TEST_EN(TYPENAME)\
- return op1 OP op2;\
-}\
-/* overloaded function */\
-static inline TYPENAME fname##_##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
- return fname##TYPENAME(EN_ENO, op1, op2);\
-}
-
- /**************/
- /* ADD */
- /**************/
-#define __add(TYPENAME) \
-__arith_expand(ADD_##TYPENAME, TYPENAME, +) /* explicitly typed function */\
-__arith_expand(ADD__##TYPENAME##__##TYPENAME, TYPENAME, +) /* overloaded function */
-__ANY_NUM(__add)
-
-
- /**************/
- /* MUL */
- /**************/
-#define __mul(TYPENAME) \
-__arith_expand(MUL_##TYPENAME, TYPENAME, *) /* explicitly typed function */\
-__arith_expand(MUL__##TYPENAME##__##TYPENAME, TYPENAME, *) /* overloaded function */
-__ANY_NUM(__mul)
-
-
- /**************/
- /* SUB */
- /**************/
-#define __sub(TYPENAME) __arith_static(SUB_, TYPENAME, -)
-__ANY_NUM(__sub)
-
-
- /**************/
- /* DIV */
- /**************/
-#define __div(TYPENAME)\
-/* The explicitly typed standard functions */\
-static inline TYPENAME DIV_##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
- TEST_EN_COND(TYPENAME, op2 == 0)\
- return op1 / op2;\
-}\
-/* The overloaded standard functions */\
-static inline TYPENAME DIV__##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
- return DIV_##TYPENAME(EN_ENO, op1, op2);\
-}
-__ANY_NUM(__div)
-
-
- /**************/
- /* MOD */
- /**************/
-#define __mod(TYPENAME)\
-/* The explicitly typed standard functions */\
-static inline TYPENAME MOD_##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
- TEST_EN(TYPENAME)\
- if (op2 == 0) return 0;\
- return op1 % op2;\
-}\
-/* The overloaded standard functions */\
-static inline TYPENAME MOD__##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
- return MOD_##TYPENAME(EN_ENO, op1, op2);\
-}
-__ANY_INT(__mod)
-
- /**************/
- /* EXPT */
- /**************/
-/* overloaded function */
-#define __iec_(in1_TYPENAME,in2_TYPENAME) \
-static inline in1_TYPENAME EXPT__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME\
- (EN_ENO_PARAMS, in1_TYPENAME IN1, in2_TYPENAME IN2){\
- TEST_EN(in1_TYPENAME)\
- return pow(IN1, IN2);\
-}
-#define __in1_anyreal_(in2_TYPENAME) __ANY_REAL_1(__iec_,in2_TYPENAME)
-__ANY_NUM(__in1_anyreal_)
-#undef __iec_
-
-
-
- /***************/
- /* MOVE */
- /***************/
-/* The explicitly typed standard functions */
-#define __iec_(TYPENAME)\
-static inline TYPENAME MOVE_##TYPENAME(EN_ENO_PARAMS, TYPENAME op1){\
- TEST_EN(TYPENAME)\
- return op1;\
-}
-__ANY(__iec_)
-#undef __iec_
-
-/* Overloaded function */
-#define __iec_(TYPENAME)\
-static inline TYPENAME MOVE__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1){\
- TEST_EN(TYPENAME)\
- return op1;\
-}
-__ANY(__iec_)
-#undef __iec_
-
-
-
-
-
-
-/***********************************/
-/***********************************/
-/* 2.5.1.5.3 Bit String Functions */
-/***********************************/
-/***********************************/
-
-/****************************************************/
-/*** Table 25 - Standard bit shift functions ***/
-/****************************************************/
-
-/* We do not delcare explcitly typed versions of the functions in table 25.
- * See note above regarding explicitly typed functions for more details.
- */
-#define __in1_anynbit_(in2_TYPENAME) __ANY_NBIT_1(__iec_,in2_TYPENAME)
-
-#define __shift_(fname, in1_TYPENAME, in2_TYPENAME, OP)\
-static inline in1_TYPENAME fname(EN_ENO_PARAMS, in1_TYPENAME IN, in2_TYPENAME N) {\
- TEST_EN(in1_TYPENAME)\
- return IN OP N;\
-}
-
- /**************/
- /* SHL */
- /**************/
-#define __iec_(TYPENAME) \
-/* Overloaded function */\
-static inline BOOL SHL__BOOL__##TYPENAME(EN_ENO_PARAMS, BOOL IN, TYPENAME N) { \
- TEST_EN(BOOL);\
- return (N==0)? IN : __INIT_BOOL; /* shifting by N>1 will always introduce a 0 */\
-}
-__ANY_INT(__iec_)
-#undef __iec_
-
-
-#define __iec_(in1_TYPENAME,in2_TYPENAME) \
-__shift_(SHL__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME, in1_TYPENAME, in2_TYPENAME, << )/* Overloaded function */
-__ANY_INT(__in1_anynbit_)
-#undef __iec_
-
-
- /**************/
- /* SHR */
- /**************/
-#define __iec_(TYPENAME) \
-/* Overloaded function */\
-static inline BOOL SHR__BOOL__##TYPENAME(EN_ENO_PARAMS, BOOL IN, TYPENAME N) { \
- TEST_EN(BOOL);\
- return (N==0)? IN : __INIT_BOOL; /* shifting by N>1 will always introduce a 0 */\
-}
-__ANY_INT(__iec_)
-#undef __iec_
-
-
-#define __iec_(in1_TYPENAME,in2_TYPENAME) \
-__shift_(SHR__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME, in1_TYPENAME, in2_TYPENAME, >> )/* Overloaded function */
-__ANY_INT(__in1_anynbit_)
-#undef __iec_
-
-
- /**************/
- /* ROR */
- /**************/
-#define __iec_(TYPENAME) \
-/* Overloaded function */\
-static inline BOOL ROR__BOOL__##TYPENAME(EN_ENO_PARAMS, BOOL IN, TYPENAME N) { \
- TEST_EN(BOOL);\
- return IN; /* rotating a single bit by any value N will not change that bit! */\
-}
-__ANY_INT(__iec_)
-#undef __iec_
-
-
-#define __iec_(in1_TYPENAME,in2_TYPENAME) \
-static inline in1_TYPENAME ROR__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME(EN_ENO_PARAMS, in1_TYPENAME IN, in2_TYPENAME N){\
- TEST_EN(in1_TYPENAME)\
- N %= 8*sizeof(in1_TYPENAME);\
- return (IN >> N) | (IN << (8*sizeof(in1_TYPENAME)-N));\
-}
-__ANY_INT(__in1_anynbit_)
-#undef __iec_
-
-
- /**************/
- /* ROL */
- /**************/
-#define __iec_(TYPENAME) \
-/* Overloaded function */\
-static inline BOOL ROL__BOOL__##TYPENAME(EN_ENO_PARAMS, BOOL IN, TYPENAME N) { \
- TEST_EN(BOOL);\
- return IN; /* rotating a single bit by any value N will not change that bit! */\
-}
-__ANY_INT(__iec_)
-#undef __iec_
-
-
-#define __iec_(in1_TYPENAME,in2_TYPENAME) \
-static inline in1_TYPENAME ROL__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME(EN_ENO_PARAMS, in1_TYPENAME IN, in2_TYPENAME N){\
- TEST_EN(in1_TYPENAME)\
- N %= 8*sizeof(in1_TYPENAME);\
- return (IN << N) | (IN >> (8*sizeof(in1_TYPENAME)-N));\
-}
-__ANY_INT(__in1_anynbit_)
-#undef __iec_
-
-
-
-/*********************/
-/*** Table 26 ***/
-/*********************/
-
- /**************/
- /* AND */
- /**************/
-__arith_expand(AND_BOOL, BOOL, && ) /* The explicitly typed standard functions */
-__arith_expand(AND__BOOL__BOOL, BOOL, && ) /* Overloaded function */
-
-#define __iec_(TYPENAME) \
-__arith_expand(AND_##TYPENAME, TYPENAME, &) /* The explicitly typed standard functions */\
-__arith_expand(AND__##TYPENAME##__##TYPENAME, TYPENAME, &) /* Overloaded function */
-__ANY_NBIT(__iec_)
-#undef __iec_
-
- /*************/
- /* OR */
- /*************/
-__arith_expand(OR_BOOL, BOOL, || ) /* The explicitly typed standard functions */
-__arith_expand(OR__BOOL__BOOL, BOOL, || ) /* Overloaded function */
-
-#define __iec_(TYPENAME) \
-__arith_expand(OR_##TYPENAME, TYPENAME, |) /* The explicitly typed standard functions */\
-__arith_expand(OR__##TYPENAME##__##TYPENAME, TYPENAME, |) /* Overloaded function */
-__ANY_NBIT(__iec_)
-#undef __iec_
-
- /**************/
- /* XOR */
- /**************/
-#define __xorbool_expand(fname) \
-static inline BOOL fname(EN_ENO_PARAMS, UINT param_count, BOOL op1, ...){ \
- va_list ap; \
- UINT i; \
- TEST_EN(BOOL) \
-\
- va_start (ap, op1); /* Initialize the argument list. */ \
-\
- for (i = 0; i < param_count - 1; i++){ \
- BOOL tmp = va_arg (ap, VA_ARGS_BOOL); \
- op1 = (op1 && !tmp) || (!op1 && tmp); \
- } \
-\
- va_end (ap); /* Clean up. */ \
- return op1; \
-}
-
-__xorbool_expand(XOR_BOOL) /* The explicitly typed standard functions */
-__xorbool_expand(XOR__BOOL__BOOL) /* Overloaded function */
-
-#define __iec_(TYPENAME) \
-__arith_expand(XOR_##TYPENAME, TYPENAME, ^) /* The explicitly typed standard functions */\
-__arith_expand(XOR__##TYPENAME##__##TYPENAME, TYPENAME, ^) /* Overloaded function */\
-__ANY_NBIT(__iec_)
-#undef __iec_
-
-
- /**************/
- /* NOT */
- /**************/
-/* The explicitly typed standard functions */
-static inline BOOL NOT_BOOL(EN_ENO_PARAMS, BOOL op1){
- TEST_EN(BOOL)
- return !op1;
-}
-
-/* Overloaded function */
-static inline BOOL NOT__BOOL__BOOL(EN_ENO_PARAMS, BOOL op1){
- TEST_EN(BOOL)
- return !op1;
-}
-
-/* The explicitly typed standard functions */
-#define __iec_(TYPENAME)\
-static inline TYPENAME NOT_##TYPENAME(EN_ENO_PARAMS, TYPENAME op1){\
- TEST_EN(TYPENAME)\
- return ~op1;\
-}
-__ANY_NBIT(__iec_)
-#undef __iec_
-
-/* Overloaded function */
-#define __iec_(TYPENAME)\
-static inline TYPENAME NOT__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1){\
- TEST_EN(TYPENAME)\
- return ~op1;\
-}
-__ANY_NBIT(__iec_)
-#undef __iec_
-
-
-
-
-
-
-/***************************************************/
-/***************************************************/
-/* 2.5.1.5.4 Selection and comparison Functions */
-/***************************************************/
-/***************************************************/
-
-/*********************/
-/*** Table 27 ***/
-/*********************/
-
-
- /**************/
- /* SEL */
- /**************/
-
-/* The explicitly typed standard functions */
-#define __iec_(TYPENAME)\
-static inline TYPENAME SEL_##TYPENAME(EN_ENO_PARAMS, BOOL G, TYPENAME op0, TYPENAME op1){\
- TEST_EN(TYPENAME)\
- return G ? op1 : op0;\
-}
-__ANY(__iec_)
-#undef __iec_
-
-/* Overloaded function */
-#define __iec_(TYPENAME)\
-static inline TYPENAME SEL__##TYPENAME##__BOOL__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, BOOL G, TYPENAME op0, TYPENAME op1){\
- TEST_EN(TYPENAME)\
- return G ? op1 : op0;\
-}
-__ANY(__iec_)
-#undef __iec_
-
-
- /**************/
- /* MAX */
- /**************/
-
-#define __extrem_(fname,TYPENAME, COND) \
-static inline TYPENAME fname(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\
- va_list ap;\
- UINT i;\
- TEST_EN(TYPENAME)\
- \
- va_start (ap, op1); /* Initialize the argument list. */\
- \
- for (i = 0; i < param_count - 1; i++){\
- TYPENAME tmp = va_arg (ap, VA_ARGS_##TYPENAME);\
- op1 = COND ? tmp : op1;\
- }\
- \
- va_end (ap); /* Clean up. */\
- return op1;\
-}
-
-/* Max for numerical data types */
-#define __iec_(TYPENAME) \
-__extrem_(MAX_##TYPENAME,TYPENAME, op1 < tmp) /* The explicitly typed standard functions */\
-__extrem_(MAX__##TYPENAME##__##TYPENAME,TYPENAME, op1 < tmp) /* Overloaded function */
-__ANY_BIT(__iec_)
-__ANY_NUM(__iec_)
-#undef __iec_
-
-/* Max for time data types */
-#define __iec_(TYPENAME) \
-__extrem_(MAX_##TYPENAME, TYPENAME, __time_cmp(op1, tmp) < 0) /* The explicitly typed standard functions */\
-__extrem_(MAX__##TYPENAME##__##TYPENAME, TYPENAME, __time_cmp(op1, tmp) < 0) /* Overloaded function */
-__ANY_DATE(__iec_)
-__iec_(TIME)
-#undef __iec_
-
-#define __STR_CMP(str1, str2) memcmp((char*)&str1.body,(char*)&str2.body, str1.len < str2.len ? str1.len : str2.len)
-
-/* Max for string data types */
-__extrem_(MAX_STRING, STRING, __STR_CMP(op1,tmp) < 0) /* The explicitly typed standard functions */
-__extrem_(MAX__STRING__STRING, STRING, __STR_CMP(op1,tmp) < 0) /* Overloaded function */
-
- /**************/
- /* MIN */
- /**************/
-/* Min for numerical data types */
-#define __iec_(TYPENAME) \
-__extrem_(MIN_##TYPENAME, TYPENAME, op1 > tmp) /* The explicitly typed standard functions */\
-__extrem_(MIN__##TYPENAME##__##TYPENAME, TYPENAME, op1 > tmp) /* Overloaded function */
-__ANY_NBIT(__iec_)
-__ANY_NUM(__iec_)
-#undef __iec_
-
-/* Min for time data types */
-#define __iec_(TYPENAME) \
-__extrem_(MIN_##TYPENAME, TYPENAME, __time_cmp(op1, tmp) > 0) /* The explicitly typed standard functions */\
-__extrem_(MIN__##TYPENAME##__##TYPENAME, TYPENAME, __time_cmp(op1, tmp) > 0) /* Overloaded function */
-__ANY_DATE(__iec_)
-__iec_(TIME)
-#undef __iec_
-
-/* Min for string data types */
-__extrem_(MIN_STRING, STRING, __STR_CMP(op1,tmp) > 0) /* The explicitly typed standard functions */
-__extrem_(MIN__STRING__STRING, STRING, __STR_CMP(op1,tmp) > 0) /* Overloaded function */
-
- /**************/
- /* LIMIT */
- /**************/
-
-/* Limit for numerical data types */
-#define __iec_(TYPENAME)\
-/* The explicitly typed standard functions */\
-static inline TYPENAME LIMIT_##TYPENAME(EN_ENO_PARAMS, TYPENAME MN, TYPENAME IN, TYPENAME MX){\
- TEST_EN(TYPENAME)\
- return IN > MN ? IN < MX ? IN : MX : MN;\
-}\
-/* Overloaded function */\
-static inline TYPENAME LIMIT__##TYPENAME##__##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME MN, TYPENAME IN, TYPENAME MX){\
- TEST_EN(TYPENAME)\
- return IN > MN ? IN < MX ? IN : MX : MN;\
-}
-__ANY_NBIT(__iec_)
-__ANY_NUM(__iec_)
-#undef __iec_
-
-
-/* Limit for time data types */
-#define __iec_(TYPENAME)\
-/* The explicitly typed standard functions */\
-static inline TYPENAME LIMIT_##TYPENAME(EN_ENO_PARAMS, TYPENAME MN, TYPENAME IN, TYPENAME MX){\
- TEST_EN(TYPENAME)\
- return __time_cmp(IN, MN) > 0 ? /* IN>MN ?*/\
- __time_cmp(IN, MX) < 0 ? /* IN<MX ?*/\
- IN : MX : MN;\
-}\
-/* Overloaded function */\
-static inline TYPENAME LIMIT__##TYPENAME##__##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME MN, TYPENAME IN, TYPENAME MX){\
- TEST_EN(TYPENAME)\
- return __time_cmp(IN, MN) > 0 ? /* IN>MN ?*/\
- __time_cmp(IN, MX) < 0 ? /* IN<MX ?*/\
- IN : MX : MN;\
-}
-
-__ANY_DATE(__iec_)
-__iec_(TIME)
-#undef __iec_
-
-/* Limit for string data types */
-/* The explicitly typed standard functions */
-static inline STRING LIMIT_STRING(EN_ENO_PARAMS, STRING MN, STRING IN, STRING MX){
- TEST_EN(STRING)
- return __STR_CMP(IN, MN) > 0 ? __STR_CMP(IN, MX) < 0 ? IN : MX : MN;
-}
-
-/* Overloaded function */
-static inline STRING LIMIT__STRING__STRING__STRING__STRING(EN_ENO_PARAMS, STRING MN, STRING IN, STRING MX){
- TEST_EN(STRING)
- return __STR_CMP(IN, MN) > 0 ? __STR_CMP(IN, MX) < 0 ? IN : MX : MN;
-}
-
-
- /**************/
- /* MUX */
- /**************/
-/* The standard states that the inputs for SEL and MUX must be named starting off from 0,
- * unlike remaining functions, that start off at 1.
- */
-/* The explicitly typed standard functions */
-#define __in1_anyint_(in2_TYPENAME) __ANY_INT_1(__iec_,in2_TYPENAME)
-#define __iec_(in1_TYPENAME,in2_TYPENAME) \
-static inline in2_TYPENAME MUX__##in2_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME(EN_ENO_PARAMS, in1_TYPENAME K, UINT param_count, ...){\
- va_list ap;\
- UINT i;\
- in2_TYPENAME tmp;\
- TEST_EN_COND(in2_TYPENAME, K >= param_count)\
- tmp = __INIT_##in2_TYPENAME;\
- \
- va_start (ap, param_count); /* Initialize the argument list. */\
- \
- for (i = 0; i < param_count; i++){\
- if(K == i){\
- tmp = va_arg (ap, VA_ARGS_##in2_TYPENAME);\
- va_end (ap); /* Clean up. */\
- return tmp;\
- }else{\
- va_arg (ap, VA_ARGS_##in2_TYPENAME);\
- }\
- }\
- \
- va_end (ap); /* Clean up. */\
- return tmp;\
-}
-
-__ANY(__in1_anyint_)
-#undef __iec_
-
-
-/******************************************/
-/*** Table 28 ***/
-/*** Standard comparison functions ***/
-/******************************************/
-
-#define __compare_(fname,TYPENAME, COND) \
-static inline BOOL fname(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\
- va_list ap;\
- UINT i;\
- TEST_EN(BOOL)\
- \
- va_start (ap, op1); /* Initialize the argument list. */\
- DBG(#fname #TYPENAME "\n")\
- DBG_TYPE(TYPENAME, op1)\
- \
- for (i = 0; i < param_count - 1; i++){\
- TYPENAME tmp = va_arg (ap, VA_ARGS_##TYPENAME);\
- DBG_TYPE(TYPENAME, tmp)\
- if(COND){\
- op1 = tmp;\
- }else{\
- va_end (ap); /* Clean up. */\
- return 0;\
- }\
- }\
- \
- va_end (ap); /* Clean up. */\
- return 1;\
-}
-
-#define __compare_num(fname, TYPENAME, TEST) __compare_(fname, TYPENAME, op1 TEST tmp )
-#define __compare_time(fname, TYPENAME, TEST) __compare_(fname, TYPENAME, __time_cmp(op1, tmp) TEST 0)
-#define __compare_string(fname, TEST) __compare_(fname, STRING, __STR_CMP(op1, tmp) TEST 0 )
-
-
- /**************/
- /* GT */
- /**************/
-/* Comparison for numerical data types */
-#define __iec_(TYPENAME) \
-__compare_num(GT_##TYPENAME, TYPENAME, > ) /* The explicitly typed standard functions */\
-__compare_num(GT__BOOL__##TYPENAME, TYPENAME, > ) /* Overloaded function */
-__ANY_NBIT(__iec_)
-__ANY_NUM(__iec_)
-#undef __iec_
-
-/* Comparison for time data types */
-#define __iec_(TYPENAME) \
-__compare_time(GT_##TYPENAME, TYPENAME, > ) /* The explicitly typed standard functions */\
-__compare_time(GT__BOOL__##TYPENAME, TYPENAME, > ) /* Overloaded function */
-__ANY_DATE(__iec_)
-__iec_(TIME)
-#undef __iec_
-
-/* Comparison for string data types */
-__compare_string(GT_STRING, > ) /* The explicitly typed standard functions */
-__compare_string(GT__BOOL__STRING, > ) /* Overloaded function */
-
- /**************/
- /* GE */
- /**************/
-/* Comparison for numerical data types */
-#define __iec_(TYPENAME) \
-__compare_num(GE_##TYPENAME, TYPENAME, >= ) /* The explicitly typed standard functions */\
-__compare_num(GE__BOOL__##TYPENAME, TYPENAME, >= ) /* Overloaded function */
-__ANY_NBIT(__iec_)
-__ANY_NUM(__iec_)
-#undef __iec_
-
-/* Comparison for time data types */
-#define __iec_(TYPENAME) \
-__compare_time(GE_##TYPENAME, TYPENAME, >= ) /* The explicitly typed standard functions */\
-__compare_time(GE__BOOL__##TYPENAME, TYPENAME, >= ) /* Overloaded function */
-__ANY_DATE(__iec_)
-__iec_(TIME)
-#undef __iec_
-
-/* Comparison for string data types */
-__compare_string(GE_STRING, >= ) /* The explicitly typed standard functions */
-__compare_string(GE__BOOL__STRING, >= ) /* Overloaded function */
-
-
-
- /**************/
- /* EQ */
- /**************/
-/* Comparison for numerical data types */
-#define __iec_(TYPENAME) \
-__compare_num(EQ_##TYPENAME, TYPENAME, == ) /* The explicitly typed standard functions */\
-__compare_num(EQ__BOOL__##TYPENAME, TYPENAME, == ) /* Overloaded function */
-__ANY_NBIT(__iec_)
-__ANY_NUM(__iec_)
-#undef __iec_
-
-/* Comparison for time data types */
-#define __iec_(TYPENAME) \
-__compare_time(EQ_##TYPENAME, TYPENAME, == ) /* The explicitly typed standard functions */\
-__compare_time(EQ__BOOL__##TYPENAME, TYPENAME, == ) /* Overloaded function */
-__ANY_DATE(__iec_)
-__iec_(TIME)
-#undef __iec_
-
-/* Comparison for string data types */
-__compare_string(EQ_STRING, == ) /* The explicitly typed standard functions */
-__compare_string(EQ__BOOL__STRING, == ) /* Overloaded function */
-
-
- /**************/
- /* LT */
- /**************/
-/* Comparison for numerical data types */
-#define __iec_(TYPENAME) \
-__compare_num(LT_##TYPENAME, TYPENAME, < ) /* The explicitly typed standard functions */\
-__compare_num(LT__BOOL__##TYPENAME, TYPENAME, < ) /* Overloaded function */
-__ANY_NBIT(__iec_)
-__ANY_NUM(__iec_)
-#undef __iec_
-
-/* Comparison for time data types */
-#define __iec_(TYPENAME) \
-__compare_time(LT_##TYPENAME, TYPENAME, < ) /* The explicitly typed standard functions */\
-__compare_time(LT__BOOL__##TYPENAME, TYPENAME, < ) /* Overloaded function */
-__ANY_DATE(__iec_)
-__iec_(TIME)
-#undef __iec_
-
-/* Comparison for string data types */
-__compare_string(LT_STRING, < ) /* The explicitly typed standard functions */
-__compare_string(LT__BOOL__STRING, < ) /* Overloaded function */
-
-
- /**************/
- /* LE */
- /**************/
-/* Comparison for numerical data types */
-#define __iec_(TYPENAME) \
-__compare_num(LE_##TYPENAME, TYPENAME, <= ) /* The explicitly typed standard functions */\
-__compare_num(LE__BOOL__##TYPENAME, TYPENAME, <= ) /* Overloaded function */
-__ANY_NBIT(__iec_)
-__ANY_NUM(__iec_)
-#undef __iec_
-
-/* Comparison for time data types */
-#define __iec_(TYPENAME) \
-__compare_time(LE_##TYPENAME, TYPENAME, <= ) /* The explicitly typed standard functions */\
-__compare_time(LE__BOOL__##TYPENAME, TYPENAME, <= ) /* Overloaded function */
-__ANY_DATE(__iec_)
-__iec_(TIME)
-#undef __iec_
-
-/* Comparison for string data types */
-__compare_string(LE_STRING, <= ) /* The explicitly typed standard functions */
-__compare_string(LE__BOOL__STRING, <= ) /* Overloaded function */
-
-
- /**************/
- /* NE */
- /**************/
-#define __ne_num(fname, TYPENAME) \
-static inline BOOL fname(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
- TEST_EN(BOOL)\
- return op1 != op2 ? 1 : 0;\
-}
-
-#define __ne_time(fname, TYPENAME) \
-static inline BOOL fname(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
- TEST_EN(BOOL)\
- return __time_cmp(op1, op2) != 0 ? 1 : 0;\
-}
-
-#define __ne_string(fname, TYPENAME) \
-static inline BOOL fname(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\
- TEST_EN(BOOL)\
- return __STR_CMP(op1, op2) != 0 ? 1 : 0;\
-}
-
-/* Comparison for numerical data types */
-#define __iec_(TYPENAME) \
-__ne_num(NE_##TYPENAME, TYPENAME) /* The explicitly typed standard functions */\
-__ne_num(NE__BOOL__##TYPENAME##__##TYPENAME, TYPENAME) /* Overloaded function */
-__ANY_NBIT(__iec_)
-__ANY_NUM(__iec_)
-#undef __iec_
-
-/* Comparison for time data types */
-#define __iec_(TYPENAME) \
-__ne_time(NE_##TYPENAME, TYPENAME) /* The explicitly typed standard functions */\
-__ne_time(NE__BOOL__##TYPENAME##__##TYPENAME, TYPENAME) /* Overloaded function */
-__ANY_DATE(__iec_)
-__iec_(TIME)
-#undef __iec_
-
-/* Comparison for string data types */
-__ne_string(NE_STRING, STRING) /* The explicitly typed standard functions */
-__ne_string(NE__BOOL__STRING__STRING, STRING) /* Overloaded function */
-
-
-
-
-
-
-/*********************************************/
-/*********************************************/
-/* 2.5.1.5.5 Character string Functions */
-/*********************************************/
-/*********************************************/
-
-/*************************************/
-/*** Table 29 ***/
-/*** Character string Functions ***/
-/*************************************/
-
-/* We do not delcare explcitly typed versions of the functions in table 29.
- * See note above regarding explicitly typed functions for more details.
- */
-
-
-
-
- /***************/
- /* LEN */
- /***************/
-static inline __strlen_t __len(STRING IN) {return IN.len;}
-
-/* A function, with 1 input paramter, implementing a generic OPERATION */
-#define __genoper_1p_(fname,ret_TYPENAME, par_TYPENAME, OPERATION) \
-static inline ret_TYPENAME fname(EN_ENO_PARAMS, par_TYPENAME par1){\
- TEST_EN(ret_TYPENAME)\
- return (ret_TYPENAME)OPERATION(par1);\
-}
-
-#define __iec_(TYPENAME) __genoper_1p_(LEN__##TYPENAME##__STRING, TYPENAME, STRING, __len)
-__ANY_INT(__iec_)
-#undef __iec_
-
-
- /****************/
- /* LEFT */
- /****************/
-
-#define __left(TYPENAME) \
-static inline STRING LEFT__STRING__STRING__##TYPENAME(EN_ENO_PARAMS, STRING IN, TYPENAME L){\
- STRING res;\
- TEST_EN_COND(STRING, L < 0)\
- res = __INIT_STRING;\
- L = L < (TYPENAME)IN.len ? L : (TYPENAME)IN.len;\
- memcpy(&res.body, &IN.body, (size_t)L);\
- res.len = (__strlen_t)L;\
- return res;\
-}
-__ANY_INT(__left)
-
-
- /*****************/
- /* RIGHT */
- /*****************/
-
-#define __right(TYPENAME) \
-static inline STRING RIGHT__STRING__STRING__##TYPENAME(EN_ENO_PARAMS, STRING IN, TYPENAME L){\
- STRING res;\
- TEST_EN_COND(STRING, L < 0)\
- res = __INIT_STRING;\
- L = L < (TYPENAME)IN.len ? L : (TYPENAME)IN.len;\
- memcpy(&res.body, &IN.body[(TYPENAME)IN.len - L], (size_t)L);\
- res.len = (__strlen_t)L;\
- return res;\
-}
-__ANY_INT(__right)
-
-
- /***************/
- /* MID */
- /***************/
-
-#define __mid(TYPENAME) \
-static inline STRING MID__STRING__STRING__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, STRING IN, TYPENAME L, TYPENAME P){\
- STRING res;\
- TEST_EN_COND(STRING, L < 0 || P < 0)\
- res = __INIT_STRING;\
- if(P <= (TYPENAME)IN.len){\
- P -= 1; /* now can be used as [index]*/\
- L = L + P <= (TYPENAME)IN.len ? L : (TYPENAME)IN.len - P;\
- memcpy(&res.body, &IN.body[P] , (size_t)L);\
- res.len = (__strlen_t)L;\
- }\
- return res;\
-}
-__ANY_INT(__mid)
-
-
- /******************/
- /* CONCAT */
- /******************/
-
-static inline STRING CONCAT(EN_ENO_PARAMS, UINT param_count, ...){
- UINT i;
- STRING res;
- va_list ap;
- __strlen_t charcount;
- TEST_EN(STRING)
- charcount = 0;
- res = __INIT_STRING;
-
- va_start (ap, param_count); /* Initialize the argument list. */
-
- for (i = 0; i < param_count && charcount < STR_MAX_LEN; i++)
- {
- STRING tmp = va_arg(ap, STRING);
- __strlen_t charrem = STR_MAX_LEN - charcount;
- __strlen_t to_write = tmp.len > charrem ? charrem : tmp.len;
- memcpy(&res.body[charcount], &tmp.body , to_write);
- charcount += to_write;
- }
-
- res.len = charcount;
-
- va_end (ap); /* Clean up. */
- return res;
-}
-
- /******************/
- /* INSERT */
- /******************/
-
-static inline STRING __insert(STRING IN1, STRING IN2, __strlen_t P){
- STRING res;
- __strlen_t to_copy;
- res = __INIT_STRING;
-
- to_copy = P > IN1.len ? IN1.len : P;
- memcpy(&res.body, &IN1.body , to_copy);
- P = res.len = to_copy;
-
- to_copy = IN2.len + res.len > STR_MAX_LEN ? STR_MAX_LEN - res.len : IN2.len;
- memcpy(&res.body[res.len], &IN2.body , to_copy);
- res.len += to_copy;
-
- to_copy = IN1.len - P < STR_MAX_LEN - res.len ? IN1.len - P : STR_MAX_LEN - res.len ;
- memcpy(&res.body[res.len], &IN1.body[P] , to_copy);
- res.len += to_copy;
-
- return res;
-}
-
-#define __iec_(TYPENAME) \
-static inline STRING INSERT__STRING__STRING__STRING__##TYPENAME(EN_ENO_PARAMS, STRING str1, STRING str2, TYPENAME P){\
- TEST_EN_COND(STRING, P < 0)\
- return (STRING)__insert(str1,str2,(__strlen_t)P);\
-}
-__ANY_INT(__iec_)
-#undef __iec_
-
-
- /******************/
- /* DELETE */
- /******************/
-
-static inline STRING __delete(STRING IN, __strlen_t L, __strlen_t P){
- STRING res;
- __strlen_t to_copy;
- res = __INIT_STRING;
-
- to_copy = P > IN.len ? IN.len : P-1;
- memcpy(&res.body, &IN.body , to_copy);
- P = res.len = to_copy;
-
- if( IN.len > P + L ){
- to_copy = IN.len - P - L;
- memcpy(&res.body[res.len], &IN.body[P + L], to_copy);
- res.len += to_copy;
- }
-
- return res;
-}
-
-#define __iec_(TYPENAME) \
-static inline STRING DELETE__STRING__STRING__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, STRING str, TYPENAME L, TYPENAME P){\
- TEST_EN_COND(STRING, L < 0 || P < 0)\
- return (STRING)__delete(str,(__strlen_t)L,(__strlen_t)P);\
-}
-__ANY_INT(__iec_)
-#undef __iec_
-
-
- /*******************/
- /* REPLACE */
- /*******************/
-
-static inline STRING __replace(STRING IN1, STRING IN2, __strlen_t L, __strlen_t P){
- STRING res;
- __strlen_t to_copy;
- res = __INIT_STRING;
-
- to_copy = P > IN1.len ? IN1.len : P-1;
- memcpy(&res.body, &IN1.body , to_copy);
- P = res.len = to_copy;
-
- to_copy = IN2.len < L ? IN2.len : L;
-
- if( to_copy + res.len > STR_MAX_LEN )
- to_copy = STR_MAX_LEN - res.len;
-
- memcpy(&res.body[res.len], &IN2.body , to_copy);
- res.len += to_copy;
-
- P += L;
- if( res.len < STR_MAX_LEN && P < IN1.len)
- {
- to_copy = IN1.len - P;
- memcpy(&res.body[res.len], &IN1.body[P] , to_copy);
- res.len += to_copy;
- }
-
- return res;
-}
-
-#define __iec_(TYPENAME) \
-static inline STRING REPLACE__STRING__STRING__STRING__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, STRING str1, STRING str2, TYPENAME L, TYPENAME P){\
- TEST_EN_COND(STRING, L < 0 || P < 0)\
- return (STRING)__replace(str1,str2,(__strlen_t)L,(__strlen_t)P);\
-}
-__ANY_INT(__iec_)
-#undef __iec_
-
- /****************/
- /* FIND */
- /****************/
-
-static inline __strlen_t __pfind(STRING* IN1, STRING* IN2){
- UINT count1 = 0; /* offset of first matching char in IN1 */
- UINT count2 = 0; /* count of matching char */
- while(count1 + count2 < IN1->len && count2 < IN2->len)
- {
- if(IN1->body[count1 + count2] != IN2->body[count2]){
- count1 += count2 + 1;
- count2 = 0;
- }
- else {
- count2++;
- }
- }
- return count2 == IN2->len -1 ? 0 : count1 + 1;
-}
-
-#define __iec_(TYPENAME) \
-static inline TYPENAME FIND__##TYPENAME##__STRING__STRING(EN_ENO_PARAMS, STRING str1, STRING str2){\
- TEST_EN(TYPENAME)\
- return (TYPENAME)__pfind(&str1,&str2);\
-}
-__ANY_INT(__iec_)
-#undef __iec_
-
-
-/*********************************************/
-/*********************************************/
-/* 2.5.1.5.6 Functions of time data types */
-/*********************************************/
-/*********************************************/
-
-/**************************************/
-/*** Table 30 ***/
-/*** Functions of time data types ***/
-/**************************************/
-
-
-static inline TIME ADD_TIME(EN_ENO_PARAMS, TIME IN1, TIME IN2){
- TEST_EN(TIME)
- return __time_add(IN1, IN2);
-}
-
-static inline TOD ADD_TOD_TIME(EN_ENO_PARAMS, TOD IN1, TIME IN2){
- TEST_EN(TOD)
- return __time_add(IN1, IN2);
-}
-
-static inline DT ADD_DT_TIME(EN_ENO_PARAMS, DT IN1, TIME IN2){
- TEST_EN(DT)
- return __time_add(IN1, IN2);
-}
-
-static inline TIME SUB_TIME(EN_ENO_PARAMS, TIME IN1, TIME IN2){
- TEST_EN(TIME)
- return __time_sub(IN1, IN2);
-}
-
-static inline TIME SUB_DATE_DATE(EN_ENO_PARAMS, DATE IN1, DATE IN2){
- TEST_EN(TIME)
- return __time_sub(IN1, IN2);
-}
-
-static inline TOD SUB_TOD_TIME(EN_ENO_PARAMS, TOD IN1, TIME IN2){
- TEST_EN(TOD)
- return __time_sub(IN1, IN2);
-}
-
-static inline TIME SUB_TOD_TOD(EN_ENO_PARAMS, TOD IN1, TOD IN2){
- TEST_EN(TIME)
- return __time_sub(IN1, IN2);
-}
-
-static inline DT SUB_DT_TIME(EN_ENO_PARAMS, DT IN1, TIME IN2){
- TEST_EN(DT)
- return __time_sub(IN1, IN2);
-}
-
-static inline TIME SUB_DT_DT(EN_ENO_PARAMS, DT IN1, DT IN2){
- TEST_EN(TIME)
- return __time_sub(IN1, IN2);
-}
-
-
-/*** MULTIME ***/
-#define __iec_(TYPENAME)\
-static inline TIME MULTIME__TIME__TIME__##TYPENAME(EN_ENO_PARAMS, TIME IN1, TYPENAME IN2){\
- TEST_EN(TIME)\
- return __time_mul(IN1, (LREAL)IN2);\
-}
-__ANY_NUM(__iec_)
-#undef __iec_
-
-/*** MUL ***/
-#define __iec_(TYPENAME)\
-static inline TIME MUL__TIME__TIME__##TYPENAME(EN_ENO_PARAMS, TIME IN1, TYPENAME IN2){\
- TEST_EN(TIME)\
- return __time_mul(IN1, (LREAL)IN2);\
-}
-__ANY_NUM(__iec_)
-#undef __iec_
-
-/*** DIVTIME ***/
-#define __iec_(TYPENAME)\
-static inline TIME DIVTIME__TIME__TIME__##TYPENAME(EN_ENO_PARAMS, TIME IN1, TYPENAME IN2){\
- TEST_EN(TIME)\
- return __time_div(IN1, (LREAL)IN2);\
-}
-__ANY_NUM(__iec_)
-#undef __iec_
-
-/*** DIV ***/
-#define __iec_(TYPENAME)\
-static inline TIME DIV__TIME__TIME__##TYPENAME(EN_ENO_PARAMS, TIME IN1, TYPENAME IN2){\
- TEST_EN(TIME)\
- return __time_div(IN1, (LREAL)IN2);\
-}
-__ANY_NUM(__iec_)
-#undef __iec_
-
-/*** CONCAT_DATE_TOD ***/
-static inline DT CONCAT_DATE_TOD(EN_ENO_PARAMS, DATE IN1, TOD IN2){
- TEST_EN(DT)
- return __time_add(IN1, IN2);
-}
-
-
-
-/****************************************************/
-/****************************************************/
-/* 2.5.1.5.6 Functions of enumerated data types */
-/****************************************************/
-/****************************************************/
-
-/********************************************/
-/*** Table 31 ***/
-/*** Functions of enumerated data types ***/
-/********************************************/
-
-/* Do we support this? */
-
-#endif /* _IEC_STD_LIB_H */
--- a/lib/iec_types.h Sun Jul 06 10:16:48 2014 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,83 +0,0 @@
-#ifndef IEC_TYPES_H
-#define IEC_TYPES_H
-
-#include <limits.h>
-#include <float.h>
-#include <stdint.h>
-
-/*********************/
-/* IEC Types defs */
-/*********************/
-
-typedef uint8_t IEC_BOOL;
-
-typedef int8_t IEC_SINT;
-typedef int16_t IEC_INT;
-typedef int32_t IEC_DINT;
-typedef int64_t IEC_LINT;
-
-typedef uint8_t IEC_USINT;
-typedef uint16_t IEC_UINT;
-typedef uint32_t IEC_UDINT;
-typedef uint64_t IEC_ULINT;
-
-typedef uint8_t IEC_BYTE;
-typedef uint16_t IEC_WORD;
-typedef uint32_t IEC_DWORD;
-typedef uint64_t IEC_LWORD;
-
-typedef float IEC_REAL;
-typedef double IEC_LREAL;
-
-/* WARNING: When editing the definition of IEC_TIMESPEC, take note that
- * if the order of the two elements 'tv_sec' and 'tv_nsec' is changed, then the macros
- * __time_to_timespec() and __tod_to_timespec() will need to be changed accordingly.
- * (these macros may be found in iec_std_lib.h)
- */
-typedef struct {
- long int tv_sec; /* Seconds. */
- long int tv_nsec; /* Nanoseconds. */
-} /* __attribute__((packed)) */ IEC_TIMESPEC; /* packed is gcc specific! */
-
-typedef IEC_TIMESPEC IEC_TIME;
-typedef IEC_TIMESPEC IEC_DATE;
-typedef IEC_TIMESPEC IEC_DT;
-typedef IEC_TIMESPEC IEC_TOD;
-
-#ifndef STR_MAX_LEN
-#define STR_MAX_LEN 126
-#endif
-
-#ifndef STR_LEN_TYPE
-#define STR_LEN_TYPE int8_t
-#endif
-
-#define __INIT_REAL 0
-#define __INIT_LREAL 0
-#define __INIT_SINT 0
-#define __INIT_INT 0
-#define __INIT_DINT 0
-#define __INIT_LINT 0
-#define __INIT_USINT 0
-#define __INIT_UINT 0
-#define __INIT_UDINT 0
-#define __INIT_ULINT 0
-#define __INIT_TIME (TIME){0,0}
-#define __INIT_BOOL 0
-#define __INIT_BYTE 0
-#define __INIT_WORD 0
-#define __INIT_DWORD 0
-#define __INIT_LWORD 0
-#define __INIT_STRING (STRING){0,""}
-//#define __INIT_WSTRING
-#define __INIT_DATE (DATE){0,0}
-#define __INIT_TOD (TOD){0,0}
-#define __INIT_DT (DT){0,0}
-
-typedef STR_LEN_TYPE __strlen_t;
-typedef struct {
- __strlen_t len;
- uint8_t body[STR_MAX_LEN];
-} /* __attribute__((packed)) */ IEC_STRING; /* packed is gcc specific! */
-
-#endif /*IEC_TYPES_H*/
--- a/lib/iec_types_all.h Sun Jul 06 10:16:48 2014 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,176 +0,0 @@
-/*
- * Copyright (C) 2007-2011: Edouard TISSERANT and Laurent BESSARD
- *
- * See COPYING and COPYING.LESSER files for copyright details.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef IEC_TYPES_ALL_H
-#define IEC_TYPES_ALL_H
-
-
-/* Macro that expand to subtypes */
-#define __ANY(DO) __ANY_DERIVED(DO) __ANY_ELEMENTARY(DO)
-#define __ANY_DERIVED(DO)
-#define __ANY_ELEMENTARY(DO) __ANY_MAGNITUDE(DO) __ANY_BIT(DO) __ANY_STRING(DO) __ANY_DATE(DO)
-#define __ANY_MAGNITUDE(DO) __ANY_NUM(DO) DO(TIME)
-#define __ANY_BIT(DO) __ANY_NBIT(DO) DO(BOOL)
-#define __ANY_NBIT(DO) DO(BYTE) DO(WORD) DO(DWORD) DO(LWORD)
-#define __ANY_STRING(DO) DO(STRING)
-#define __ANY_DATE(DO) DO(DATE) DO(TOD) DO(DT)
-#define __ANY_NUM(DO) __ANY_REAL(DO) __ANY_INT(DO)
-#define __ANY_REAL(DO) DO(REAL) DO(LREAL)
-#define __ANY_INT(DO) __ANY_SINT(DO) __ANY_UINT(DO)
-#define __ANY_SINT(DO) DO(SINT) DO(INT) DO(DINT) DO(LINT)
-#define __ANY_UINT(DO) DO(USINT) DO(UINT) DO(UDINT) DO(ULINT)
-
-
-/* Macro that expand to subtypes */
-#define __ANY_1(DO,P1) __ANY_DERIVED_1(DO,P1) __ANY_ELEMENTARY_1(DO,P1)
-#define __ANY_DERIVED_1(DO,P1)
-#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)
-#define __ANY_MAGNITUDE_1(DO,P1) __ANY_NUM_1(DO,P1) DO(TIME,P1)
-#define __ANY_BIT_1(DO,P1) __ANY_NBIT_1(DO,P1) DO(BOOL,P1)
-#define __ANY_NBIT_1(DO,P1) DO(BYTE,P1) DO(WORD,P1) DO(DWORD,P1) DO(LWORD,P1)
-#define __ANY_STRING_1(DO,P1) DO(STRING,P1)
-#define __ANY_DATE_1(DO,P1) DO(DATE,P1) DO(TOD,P1) DO(DT,P1)
-#define __ANY_NUM_1(DO,P1) __ANY_REAL_1(DO,P1) __ANY_INT_1(DO,P1)
-#define __ANY_REAL_1(DO,P1) DO(REAL,P1) DO(LREAL,P1)
-#define __ANY_INT_1(DO,P1) __ANY_SINT_1(DO,P1) __ANY_UINT_1(DO,P1)
-#define __ANY_SINT_1(DO,P1) DO(SINT,P1) DO(INT,P1) DO(DINT,P1) DO(LINT,P1)
-#define __ANY_UINT_1(DO,P1) DO(USINT,P1) DO(UINT,P1) DO(UDINT,P1) DO(ULINT,P1)
-
-
-
-/*********************/
-/* IEC Types defs */
-/*********************/
-
-/* Include non windows.h clashing typedefs */
-#include "iec_types.h"
-
-#ifndef TRUE
- #define TRUE 1
- #define FALSE 0
-#endif
-
-#define __IEC_DEBUG_FLAG 0x01
-#define __IEC_FORCE_FLAG 0x02
-#define __IEC_RETAIN_FLAG 0x04
-#define __IEC_OUTPUT_FLAG 0x08
-
-#define __DECLARE_IEC_TYPE(type)\
-typedef IEC_##type type;\
-\
-typedef struct {\
- IEC_##type value;\
- IEC_BYTE flags;\
-} __IEC_##type##_t;\
-\
-typedef struct {\
- IEC_##type *value;\
- IEC_BYTE flags;\
- IEC_##type fvalue;\
-} __IEC_##type##_p;
-
-#define __DECLARE_DERIVED_TYPE(type, base)\
-typedef base type;\
-typedef __IEC_##base##_t __IEC_##type##_t;\
-typedef __IEC_##base##_p __IEC_##type##_p;
-
-#define __DECLARE_COMPLEX_STRUCT(type)\
-typedef struct {\
- type value;\
- IEC_BYTE flags;\
-} __IEC_##type##_t;\
-\
-typedef struct {\
- type *value;\
- IEC_BYTE flags;\
- type fvalue;\
-} __IEC_##type##_p;
-
-#define __DECLARE_ENUMERATED_TYPE(type, ...)\
-typedef enum {\
- __VA_ARGS__\
-} type;\
-__DECLARE_COMPLEX_STRUCT(type)
-
-#define __DECLARE_ARRAY_TYPE(type, base, size)\
-typedef struct {\
- base table size;\
-} type;\
-__DECLARE_COMPLEX_STRUCT(type)
-
-#define __DECLARE_STRUCT_TYPE(type, elements)\
-typedef struct {\
- elements\
-} type;\
-__DECLARE_COMPLEX_STRUCT(type)
-
-/* Those typdefs clash with windows.h */
-/* i.e. this file cannot be included aside windows.h */
-__ANY(__DECLARE_IEC_TYPE)
-
-typedef struct {
- __IEC_BOOL_t X; // state; --> current step state. 0 : inative, 1: active. We name it 'X' as it may be accessed from IEC 61131.3 code using stepname.X syntax!!
- BOOL prev_state; // previous step state. 0 : inative, 1: active
- __IEC_TIME_t T; // elapsed_time; --> time since step is active. We name it 'T' as it may be accessed from IEC 61131.3 code using stepname.T syntax!!
-} STEP;
-
-
-typedef struct {
- BOOL stored; // action storing state. 0 : not stored, 1: stored
- __IEC_BOOL_t state; // current action state. 0 : inative, 1: active
- BOOL set; // set have been requested (reset each time the body is evaluated)
- BOOL reset; // reset have been requested (reset each time the body is evaluated)
- TIME set_remaining_time; // time before set will be requested
- TIME reset_remaining_time; // time before reset will be requested
-} ACTION;
-
-/* Extra debug types for SFC */
-#define __ANY_SFC(DO) DO(STEP) DO(TRANSITION) DO(ACTION)
-
-/* Enumerate native types */
-#define __decl_enum_type(TYPENAME) TYPENAME##_ENUM,
-#define __decl_enum_pointer(TYPENAME) TYPENAME##_P_ENUM,
-#define __decl_enum_output(TYPENAME) TYPENAME##_O_ENUM,
-typedef enum{
- __ANY(__decl_enum_type)
- __ANY(__decl_enum_pointer)
- __ANY(__decl_enum_output)
- /* SFC specific types are never external or global */
- UNKNOWN_ENUM
-} __IEC_types_enum;
-
-/* Get size of type from its number */
-#define __decl_size_case(TYPENAME) \
- case TYPENAME##_ENUM:\
- case TYPENAME##_O_ENUM:\
- case TYPENAME##_P_ENUM:\
- return sizeof(TYPENAME);
-static inline USINT __get_type_enum_size(__IEC_types_enum t){
- switch(t){
- __ANY(__decl_size_case)
- /* size do not correspond to real struct.
- * only a bool is used to represent state*/
- default:
- return 0;
- }
- return 0;
-}
-
-#endif /*IEC_TYPES_ALL_H*/