matiec: comparison lib/iec_std

equal deleted inserted replaced

-:a4eb4fd6b0d6
+:64334c5a00b1
 # if __WORDSIZE == 64
 #define __32b_sufix
 #define __64b_sufix L
 #else
 #define __32b_sufix L
 #define __64b_sufix LL
 #endif
 #define __lit(type,value,sfx) (type)value##sfx
 // Keep this macro expention step to let sfx change into L or LL
 #define __literal(type,value,sfx) __lit(type,value,sfx)
 #define __BOOL_LITERAL(value) __literal(BOOL,value,)
 #define __SINT_LITERAL(value) __literal(SINT,value,)
 #define __INT_LITERAL(value) __literal(INT,value,)
 }
 }
 static inline struct timespec __time_to_timespec(int sign, double mseconds, double seconds, double minutes, double hours, double days) {
 struct 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);
 }
 static inline struct timespec __tod_to_timespec(double seconds, double minutes, double hours) {
 struct 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;
 }
 static inline struct timespec __date_to_timespec(int day, int month, int year) {
 struct timespec ts;
 if ((time_t)(-1) == epoch_seconds)
 IEC_error();
 ts.tv_sec = epoch_seconds;
 ts.tv_nsec = 0;
 return ts;
 }
 static inline struct timespec __dt_to_timespec(double seconds,  double minutes, double hours, int day, int month, int year) {
 struct 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);
 struct tm broken_down_time;
 *ENO = __BOOL_LITERAL(TRUE);
 /***************/
 /*   Time ops  */
 /***************/
 #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);
 }
 static inline STRING __insert(EN_ENO_PARAMS, STRING IN1, STRING IN2, __strlen_t P){
 TEST_EN_COND(STRING, P < 0)
 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;
 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 ;
 }
 static inline STRING __delete(EN_ENO_PARAMS, STRING IN, __strlen_t L, __strlen_t P){
 TEST_EN_COND(STRING, L < 0 || P < 0)
 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;
 if( IN.len > P + L ){
 }
 static inline STRING __replace(EN_ENO_PARAMS, STRING IN1, STRING IN2, __strlen_t L, __strlen_t P){
 TEST_EN_COND(STRING, L < 0 || P < 0)
 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;
 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;
 while(count1 + count2 < IN1->len && count2 < IN2->len)
 {
 if(IN1->body[count1 + count2] != IN2->body[count2++]){
 count1 += count2;
 count2 = 0;
 }
 }
 return count2 == IN2->len -1 ? 0 : count1 + 1;
 }
 static inline __strlen_t __find(EN_ENO_PARAMS, STRING IN1, STRING IN2){
 TEST_EN(UINT)
 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 */
 for(l = IN->len - 1; l >= 2 && shift < 64; l--)
 {
 char c = IN->body[l];
 shift += 1;
 }else if( c >= '.' ){ /* reset value */
 res = 0;
 fac = IN->body[0] == '-' ? -1 : 1;
 shift = 0;
 }
 }
 }
 return res;
 }
 while(--l > 0 && IN.body[l] != '.');
 if(l != 0){
 return atof((const char *)&IN.body);
 }else{
 return (LREAL)__pstring_to_sint(&IN);
 }
 }
 /***************/
 /*   TO_TIME   */
 /***************/
 }
 if(res.len > STR_MAX_LEN) res.len = STR_MAX_LEN;
 return res;
 }
 /* BCD */
 #define __bcd_digit(fac)
 static inline ULINT __bcd_to_uint(EN_ENO_PARAMS, LWORD IN){
 TEST_EN(ULINT)
 return IN & 0xf +
 !(IN >>= 4) ? 0 : IN & 0xf * 10ULL +
 !(IN >>= 4) ? 0 : IN & 0xf * 100ULL +
 !(IN >>= 4) ? 0 : IN & 0xf * 1000ULL +
 !(IN >>= 4) ? 0 : IN & 0xf * 10000ULL +
 !(IN >>= 4) ? 0 : IN & 0xf * 100000ULL +
 !(IN >>= 4) ? 0 : IN & 0xf * 1000000ULL +
 !(IN >>= 4) ? 0 : IN & 0xf * 10000000ULL +
 !(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){
 TEST_EN(LWORD)
 return (IN - (IN /= 10))|
 (IN - (IN /= 10)) << 4 |
 (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
 #define VA_ARGS_SINT DINT
 #define VA_ARGS_INT DINT
 #define VA_ARGS_DINT DINT
 /**************/
 static inline BOOL __xor_BOOL(EN_ENO_PARAMS, UINT param_count, BOOL op1, ...){
 TEST_EN(BOOL)
 va_list ap;
 UINT i;
 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;
 }
 #define __xor_(TYPENAME) __arith_expand(__xor_, TYPENAME, ^)
 ANY_NBIT(__xor_)
 }
 /**************/
 /*    ABS     */
 /**************/
-#define __abs_(TYPENAME) __numeric(__abs_, TYPENAME, abs)
+#define __abs_(TYPENAME) \
+static inline TYPENAME __abs_##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\
+TEST_EN(TYPENAME)\
+if (op < 0)\
+return -op;\
+return op;\
+}
 ANY_NUM(__abs_)
 /**************/
 /*    SQRT    */
 /**************/

changeset 180	64334c5a00b1
parent 165	83963465b773
child 187	f2cd0b5236f7