matiec: comparison lib/iec_std

equal deleted inserted replaced

-:90782e241346
+:d7d92b2f87e9
 #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(value) __literal(STRING,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,__32b_sufix)
 }
 static inline struct timespec __date_to_timespec(int day, int month, int year) {
 struct timespec ts;
 struct tm broken_down_time;
+time_t epoch_seconds;
 broken_down_time.tm_sec = 0;
 broken_down_time.tm_min = 0;
 broken_down_time.tm_hour = 0;
 broken_down_time.tm_mday = day;  /* day of month, from 1 to 31 */
 broken_down_time.tm_mon = month - 1;   /* month since January, in the range 0 to 11 */
 broken_down_time.tm_year = year - 1900;  /* number of years since 1900 */
-time_t epoch_seconds = mktime(&broken_down_time); /* determine number of seconds since the epoch, i.e. Jan 1st 1970 */
+epoch_seconds = mktime(&broken_down_time); /* determine number of seconds since the epoch, i.e. Jan 1st 1970 */
 if ((time_t)(-1) == epoch_seconds)
 IEC_error();
 ts.tv_sec = epoch_seconds;
 return ts;
 }
 static inline struct timespec __dt_to_timespec(double seconds,  double minutes, double hours, int day, int month, int year) {
 struct timespec ts;
+struct tm broken_down_time;
+time_t epoch_seconds;
 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);
-struct tm broken_down_time;
 broken_down_time.tm_sec = 0;
 broken_down_time.tm_min = 0;
 broken_down_time.tm_hour = 0;
 broken_down_time.tm_mday = day;  /* day of month, from 1 to 31 */
 broken_down_time.tm_mon = month - 1;   /* month since January, in the range 0 to 11 */
 broken_down_time.tm_year = year - 1900;  /* number of years since 1900 */
-time_t epoch_seconds = mktime(&broken_down_time); /* determine number of seconds since the epoch, i.e. Jan 1st 1970 */
+epoch_seconds = mktime(&broken_down_time); /* determine number of seconds since the epoch, i.e. Jan 1st 1970 */
 if ((time_t)(-1) == epoch_seconds)
 IEC_error();
 ts.tv_sec += epoch_seconds;
 if (ts.tv_sec < epoch_seconds)
 static inline __strlen_t __len(EN_ENO_PARAMS, STRING IN){
 TEST_EN(UINT)
 return IN.len;
 }
 static inline STRING __left(EN_ENO_PARAMS, STRING IN, __strlen_t L){
+STRING res;
 TEST_EN_COND(STRING, L < 0)
-STRING res = __INIT_STRING;
+res = __INIT_STRING;
 L = L < IN.len ? L : IN.len;
 memcpy(&res.body, &IN.body, L);
 res.len = L;
 return res;
 }
 static inline STRING __right(EN_ENO_PARAMS, STRING IN, __strlen_t L){
+STRING res;
 TEST_EN_COND(STRING, L < 0)
-STRING res = __INIT_STRING;
+res = __INIT_STRING;
 L = L < IN.len ? L : IN.len;
 memcpy(&res.body, &IN.body[IN.len - L], L);
 res.len = L;
 return res;
 }
 static inline STRING __mid(EN_ENO_PARAMS, STRING IN, __strlen_t L, __strlen_t P){
+STRING res;
 TEST_EN_COND(STRING, L < 0 || P < 0)
-STRING res = __INIT_STRING;
+res = __INIT_STRING;
 if(P <= IN.len){
 	    P -= 1; /* now can be used as [index]*/
 	    L = L + P <= IN.len ? L : IN.len - P;
 	    memcpy(&res.body, &IN.body[P] , L);
 res.len = L;
 }
 return res;
 }
 static inline STRING __concat(EN_ENO_PARAMS, UINT param_count, ...){
+UINT i;
+STRING res;
+va_list ap;
+__strlen_t charcount;
 TEST_EN(STRING)
-va_list ap;
+charcount = 0;
-UINT i;
+res = __INIT_STRING;
-__strlen_t charcount = 0;
-STRING res = __INIT_STRING;
 va_start (ap, param_count);         /* Initialize the argument list.  */
 for (i = 0; i < param_count && charcount < STR_MAX_LEN; i++)
 {
 va_end (ap);                  /* Clean up.  */
 return res;
 }
 static inline STRING __insert(EN_ENO_PARAMS, STRING IN1, STRING IN2, __strlen_t P){
+STRING res;
+__strlen_t to_copy;
 TEST_EN_COND(STRING, P < 0)
-STRING res = __INIT_STRING;
+res = __INIT_STRING;
-__strlen_t to_copy;
 to_copy = P > IN1.len ? IN1.len : P - 1;
 memcpy(&res.body, &IN1.body , to_copy);
 P = res.len = to_copy;
 res.len += to_copy;
 return res;
 }
 static inline STRING __delete(EN_ENO_PARAMS, STRING IN, __strlen_t L, __strlen_t P){
+STRING res;
+__strlen_t to_copy;
 TEST_EN_COND(STRING, L < 0 || P < 0)
-STRING res = __INIT_STRING;
+res = __INIT_STRING;
-__strlen_t to_copy;
 to_copy = P > IN.len ? IN.len : P-1;
 memcpy(&res.body, &IN.body , to_copy);
 P = res.len = to_copy;
 }
 return res;
 }
 static inline STRING __replace(EN_ENO_PARAMS, STRING IN1, STRING IN2, __strlen_t L, __strlen_t P){
+STRING res;
+__strlen_t to_copy;
 TEST_EN_COND(STRING, L < 0 || P < 0)
-STRING res = __INIT_STRING;
+res = __INIT_STRING;
-__strlen_t to_copy;
 to_copy = P > IN1.len ? IN1.len : P-1;
 memcpy(&res.body, &IN1.body , to_copy);
 P = res.len = to_copy;
 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++]){
+if(IN1->body[count1 + count2] != IN2->body[count2]){
-count1 += count2;
+count1 += count2 + 1;
 count2 = 0;
+}
+else {
+count2++;
 }
 }
 return count2 == IN2->len -1 ? 0 : count1 + 1;
 }
 static inline __strlen_t __find(EN_ENO_PARAMS, STRING IN1, STRING IN2){
 if(IN)
 return (STRING){4, "TRUE"};
 return (STRING){5,"FALSE"};
 }
 static inline STRING __bit_to_string(EN_ENO_PARAMS, LWORD IN){
+STRING res;
 TEST_EN(STRING)
-STRING res = __INIT_STRING;
+res = __INIT_STRING;
 res.len = snprintf((char*)res.body, STR_MAX_LEN, "16#%llx", IN);
 if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
 return res;
 }
 static inline STRING __real_to_string(EN_ENO_PARAMS, LREAL IN){
+STRING res;
 TEST_EN(STRING)
-STRING res = __INIT_STRING;
+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(EN_ENO_PARAMS, LINT IN){
+STRING res;
 TEST_EN(STRING)
-STRING res = __INIT_STRING;
+res = __INIT_STRING;
 res.len = snprintf((char*)res.body, STR_MAX_LEN, "%lld", IN);
 if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
 return res;
 }
 static inline STRING __uint_to_string(EN_ENO_PARAMS, ULINT IN){
+STRING res;
 TEST_EN(STRING)
-STRING res = __INIT_STRING;
+res = __INIT_STRING;
 res.len = snprintf((char*)res.body, STR_MAX_LEN, "%llu", IN);
 if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
 return res;
 }
 /***************/
 return IN.len == 5 ? !memcmp(&IN.body,"TRUE", IN.len) : 0;
 }
 static inline LINT __pstring_to_sint(STRING* IN){
 LINT res = 0;
-char tmp[STR_MAX_LEN];
-char tmp2[STR_MAX_LEN];
 __strlen_t l;
 unsigned int shift = 0;
 if(IN->body[0]=='2' && IN->body[1]=='#'){
 /* 2#0101_1010_1011_1111 */
 static inline ULINT __string_to_uint(EN_ENO_PARAMS, STRING IN){
 TEST_EN(ULINT)
 return (ULINT)__pstring_to_sint(&IN);
 }
 static inline LREAL __string_to_real(EN_ENO_PARAMS, STRING IN){
-TEST_EN(LREAL)
+	__strlen_t l;
+	TEST_EN(LREAL)
+	l = IN.len;
 /* search the dot */
-__strlen_t l = IN.len;
 while(--l > 0 && IN.body[l] != '.');
 if(l != 0){
 return atof((const char *)&IN.body);
 }else{
 return (LREAL)__pstring_to_sint(&IN);
 static inline TIME __real_to_time(EN_ENO_PARAMS, LREAL IN){
 TEST_EN(TIME)
 return (TIME){IN, (IN - (LINT)IN) * 1000000000};
 }
 static inline TIME __string_to_time(EN_ENO_PARAMS, STRING IN){
-TEST_EN(TIME)
+	__strlen_t l;
+	TEST_EN(TIME)
 /* 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
 *  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 */
-__strlen_t l = IN.len;
+	l = IN.len;
 while(--l > 0 && IN.body[l] != '.');
 if(l != 0){
 LREAL IN_val = atof((const char *)&IN.body);
 return  (TIME){IN_val, (IN_val - (LINT)IN_val)*1000000000};
 }else{
 static inline LINT __time_to_int(EN_ENO_PARAMS, TIME IN){
 TEST_EN(LINT)
 return IN.tv_sec;
 }
 static inline STRING __time_to_string(EN_ENO_PARAMS, TIME IN){
+STRING res;
+div_t days;
 TEST_EN(STRING)
 /*t#5d14h12m18s3.5ms*/
-STRING res = __INIT_STRING;
+res = __INIT_STRING;
-div_t days = div(IN.tv_sec ,86400);
+days = div(IN.tv_sec ,86400);
 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, 3600);
 if(!hours.rem && IN.tv_nsec == 0){
 }
 if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
 return res;
 }
 static inline STRING __date_to_string(EN_ENO_PARAMS, DATE IN){
-TEST_EN(STRING)
+STRING res;
+struct tm* broken_down_time;
+time_t seconds;
+	TEST_EN(STRING)
 /* D#1984-06-25 */
-STRING res = __INIT_STRING;
+res = __INIT_STRING;
-struct tm* broken_down_time;
+seconds = IN.tv_sec;
-time_t seconds = IN.tv_sec;
 if (NULL == (broken_down_time = localtime(&seconds))){ /* get the UTC (GMT) broken down time */
 IEC_error();
 return (STRING){7,"D#ERROR"};
 }
 res.len = snprintf((char*)&res.body, STR_MAX_LEN, "D#%d-%2.2d-%2.2d", broken_down_time->tm_year + 1900, broken_down_time->tm_mon + 1, broken_down_time->tm_mday);
 if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
 return res;
 }
 static inline STRING __tod_to_string(EN_ENO_PARAMS, TOD IN){
+STRING res;
+struct tm* broken_down_time;
+time_t seconds;
 TEST_EN(STRING)
 /* TOD#15:36:55.36 */
-STRING res = __INIT_STRING;
+res = __INIT_STRING;
-struct tm* broken_down_time;
+seconds = IN.tv_sec;
-time_t seconds = IN.tv_sec;
 if (NULL == (broken_down_time = localtime(&seconds))){ /* get the UTC (GMT) broken down time */
 IEC_error();
 return (STRING){9,"TOD#ERROR"};
 }
 if(IN.tv_nsec == 0){
 }
 if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
 return res;
 }
 static inline STRING __dt_to_string(EN_ENO_PARAMS, DT IN){
+STRING res;
+struct tm* broken_down_time;
+time_t seconds;
 TEST_EN(STRING)
 /* DT#1984-06-25-15:36:55.36 */
-STRING res;
+seconds = IN.tv_sec;
-struct tm* broken_down_time;
-time_t seconds = IN.tv_sec;
 if (NULL == (broken_down_time = localtime(&seconds))){ /* get the UTC (GMT) broken down time */
 IEC_error();
 return (STRING){8,"DT#ERROR"};
 }
 if(IN.tv_nsec == 0){
 return res;
 }
 /* BCD */
 #define __bcd_digit(fac)
 static inline ULINT __bcd_to_uint(EN_ENO_PARAMS, LWORD IN){
+ULINT res;
+ULINT i;
 TEST_EN(ULINT)
-return IN & 0xf +
-!(IN >>= 4) ? 0 : IN & 0xf * 10ULL +
+res = IN & 0xf;
-!(IN >>= 4) ? 0 : IN & 0xf * 100ULL +
+for(i = 10ULL; i <= 1000000000000000ULL; i *= 10){
-!(IN >>= 4) ? 0 : IN & 0xf * 1000ULL +
+if(!(IN >>= 4))
-!(IN >>= 4) ? 0 : IN & 0xf * 10000ULL +
+break;
-!(IN >>= 4) ? 0 : IN & 0xf * 100000ULL +
+res += (IN & 0xf) * i;
-!(IN >>= 4) ? 0 : IN & 0xf * 1000000ULL +
+}
-!(IN >>= 4) ? 0 : IN & 0xf * 10000000ULL +
+return res;
-!(IN >>= 4) ? 0 : IN & 0xf * 100000000ULL +
+}
-!(IN >>= 4) ? 0 : IN & 0xf * 1000000000ULL +
-!(IN >>= 4) ? 0 : IN & 0xf * 10000000000ULL +
-!(IN >>= 4) ? 0 : IN & 0xf * 100000000000ULL +
-!(IN >>= 4) ? 0 : IN & 0xf * 1000000000000ULL +
-!(IN >>= 4) ? 0 : IN & 0xf * 10000000000000ULL +
-!(IN >>= 4) ? 0 : IN & 0xf * 100000000000000ULL +
-!(IN >>= 4) ? 0 : IN & 0xf * 1000000000000000ULL;
-}
 static inline LWORD __uint_to_bcd(EN_ENO_PARAMS, ULINT IN){
+LWORD res;
+USINT i;
 TEST_EN(LWORD)
-return (IN - (IN /= 10))|
-(IN - (IN /= 10)) << 4 |
+res = IN % 10;
-(IN - (IN /= 10)) << 8 |
+for(i = 4; i<=60; i += 4){
-(IN - (IN /= 10)) << 12 |
+if(!(IN /= 10))
-(IN - (IN /= 10)) << 16 |
+break;
-(IN - (IN /= 10)) << 20 |
+res |= (IN % 10) << i;
-(IN - (IN /= 10)) << 24 |
+}
-(IN - (IN /= 10)) << 28 |
+return res;
-(IN - (IN /= 10)) << 32 |
-(IN - (IN /= 10)) << 36 |
-(IN - (IN /= 10)) << 40 |
-(IN - (IN /= 10)) << 44 |
-(IN - (IN /= 10)) << 48 |
-(IN - (IN /= 10)) << 52 |
-(IN - (IN /= 10)) << 56 |
-(IN - (IN /= 10)) << 60;
 }
 /* workaround for va-atgs limitation on shorter that int params */
 #define VA_ARGS_REAL LREAL
 #define VA_ARGS_LREAL LREAL
 /*******************************************/
 /*     Arithmetic and bitwise functions    */
 /*******************************************/
 #define __arith_expand(fname,TYPENAME, OP) \
 static inline TYPENAME fname##TYPENAME(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\
-TEST_EN(TYPENAME)\
 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);\
 /**************/
 /*     XOR    */
 /**************/
 static inline BOOL __xor_BOOL(EN_ENO_PARAMS, UINT param_count, BOOL op1, ...){
-TEST_EN(BOOL)
 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);
 #define __ror_(TYPENAME)\
 static inline TYPENAME __ror_##TYPENAME(EN_ENO_PARAMS, TYPENAME IN, USINT N){\
 TEST_EN(TYPENAME)\
 N %= 8*sizeof(TYPENAME);\
-return (IN >> N) | (IN << 8*sizeof(TYPENAME)-N);\
+return (IN >> N) | (IN << (8*sizeof(TYPENAME)-N));\
 }
 /* Call previously defined macro for each ANY_NBIT */
 ANY_NBIT(__ror_)
 #define __rol_(TYPENAME)\
 static inline TYPENAME __rol_##TYPENAME(EN_ENO_PARAMS, TYPENAME IN, USINT N){\
 TEST_EN(TYPENAME)\
 N %= 8*sizeof(TYPENAME);\
-return (IN << N) | (IN >> 8*sizeof(TYPENAME)-N);\
+return (IN << N) | (IN >> (8*sizeof(TYPENAME)-N));\
 }
 /* Call previously defined macro for each ANY_NBIT */
 ANY_NBIT(__rol_)
 /*******************************************/
 ANY_REAL(__sqrt_)
 /**************/
 /*     LN     */
 /**************/
-#define __ln_(TYPENAME) __numeric(__ln_, TYPENAME, ln)
+#define __ln_(TYPENAME) __numeric(__ln_, TYPENAME, log)
 ANY_REAL(__ln_)
 /**************/
 /*     LOG    */
 /**************/
-#define __log_(TYPENAME) __numeric(__log_, TYPENAME, log)
+#define __log_(TYPENAME) __numeric(__log_, TYPENAME, log10)
 ANY_REAL(__log_)
 /**************/
 /*     EXP    */
 /**************/
 /*     MAX    */
 /**************/
 #define __extrem_(fname,TYPENAME, COND) \
 static inline TYPENAME fname##TYPENAME(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\
-TEST_EN(TYPENAME)\
 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);\
 /**************/
 /*     MUX    */
 /**************/
 #define __mux_(TYPENAME) \
 static inline TYPENAME __mux_##TYPENAME(EN_ENO_PARAMS, UINT param_count, UINT K, ...){\
-TEST_EN_COND(TYPENAME, K >= param_count)\
 va_list ap;\
 UINT i;\
-TYPENAME tmp = __INIT_##TYPENAME;\
+TYPENAME tmp;\
+TEST_EN_COND(TYPENAME, K >= param_count)\
+tmp = __INIT_##TYPENAME;\
 \
 va_start (ap, K);         /* Initialize the argument list.  */\
 \
 for (i = 0; i < param_count; i++){\
 if(K == i){\
 /* Comparison */
 /**************/
 #define __compare_(fname,TYPENAME, COND) \
 static inline BOOL fname##TYPENAME(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\
-TEST_EN(BOOL)\
 va_list ap;\
 UINT i;\
+TEST_EN(BOOL)\
 \
 va_start (ap, op1);         /* Initialize the argument list.  */\
 DBG(#fname #TYPENAME "\n")\
 DBG_TYPE(TYPENAME, op1)\
 \
 __ne_time(TIME)
 __compare_string(__ne_, != )
-///* Get string representation of variable referenced by a void pointer
+/* Get string representation of variable referenced by a void pointer
-// * where type is given as its number */
+* where type is given as its number */
-//#define __decl_str_case(cat,TYPENAME) \
+/*#define __decl_str_case(cat,TYPENAME) \
-//    case TYPENAME##_ENUM:\
+case TYPENAME##_ENUM:\
-//        return __##cat##_to_string(*(TYPENAME*)p);
+return __##cat##_to_string(*(TYPENAME*)p);
-//#define __decl_str_case_bit(TYPENAME) __decl_str_case(bit,TYPENAME)
+#define __decl_str_case_bit(TYPENAME) __decl_str_case(bit,TYPENAME)
-//#define __decl_str_case_real(TYPENAME) __decl_str_case(real,TYPENAME)
+#define __decl_str_case_real(TYPENAME) __decl_str_case(real,TYPENAME)
-//#define __decl_str_case_sint(TYPENAME) __decl_str_case(sint,TYPENAME)
+#define __decl_str_case_sint(TYPENAME) __decl_str_case(sint,TYPENAME)
-//#define __decl_str_case_uint(TYPENAME) __decl_str_case(uint,TYPENAME)
+#define __decl_str_case_uint(TYPENAME) __decl_str_case(uint,TYPENAME)
-//static inline STRING __get_type_enum_str(__IEC_types_enum t, void* p){
+static inline STRING __get_type_enum_str(__IEC_types_enum t, void* p){
-// switch(t){
+switch(t){
-//  __decl_str_case(bool,BOOL)
+__decl_str_case(bool,BOOL)
-//  ANY_NBIT(__decl_str_case_bit)
+ANY_NBIT(__decl_str_case_bit)
-//  ANY_REAL(__decl_str_case_real)
+ANY_REAL(__decl_str_case_real)
-//  ANY_SINT(__decl_str_case_sint)
+ANY_SINT(__decl_str_case_sint)
-//  ANY_UINT(__decl_str_case_uint)
+ANY_UINT(__decl_str_case_uint)
-//  __decl_str_case(time,TIME)
+__decl_str_case(time,TIME)
-//  __decl_str_case(date,DATE)
+__decl_str_case(date,DATE)
-//  __decl_str_case(tod,TOD)
+__decl_str_case(tod,TOD)
-//  __decl_str_case(dt, DT)
+__decl_str_case(dt, DT)
-// }
+}
-//}
+}
-//
+*/

changeset 258	d7d92b2f87e9
parent 217	f5dfadf5de54
child 254	28bd86c56793
child 280	69a307407f7b