# HG changeset patch # User mjsousa # Date 1404641258 -3600 # Node ID 423ea3749212501aff1505d7c53f97bcda231246 # Parent f712705bef65e663626e7f17c07172364f601c23 Move library files compiled to C to their own subdiectory. diff -r f712705bef65 -r 423ea3749212 lib/C/accessor.h --- /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 diff -r f712705bef65 -r 423ea3749212 lib/C/iec_std_lib.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 +#include +#include +#include +#include + +#include +#include +#include +#include + +#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 0 ? /* IN>MN ?*/\ + __time_cmp(IN, MX) < 0 ? /* IN 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 */ diff -r f712705bef65 -r 423ea3749212 lib/C/iec_types.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 +#include +#include + +/*********************/ +/* 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*/ diff -r f712705bef65 -r 423ea3749212 lib/C/iec_types_all.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 . + * + */ + +#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*/ diff -r f712705bef65 -r 423ea3749212 lib/accessor.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 diff -r f712705bef65 -r 423ea3749212 lib/iec_std_lib.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 -#include -#include -#include -#include - -#include -#include -#include -#include - -#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 0 ? /* IN>MN ?*/\ - __time_cmp(IN, MX) < 0 ? /* IN 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 */ diff -r f712705bef65 -r 423ea3749212 lib/iec_types.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 -#include -#include - -/*********************/ -/* 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*/ diff -r f712705bef65 -r 423ea3749212 lib/iec_types_all.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 . - * - */ - -#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*/