|
1 /* |
|
2 * copyright 2008 Edouard TISSERANT |
|
3 * copyright 2011 Mario de Sousa (msousa@fe.up.pt) |
|
4 * |
|
5 * Offered to the public under the terms of the GNU Lesser General Public |
|
6 * License as published by the Free Software Foundation; either version 2 |
|
7 * of the License, or (at your option) any later version. |
|
8 * |
|
9 * This program is distributed in the hope that it will be useful, but |
|
10 * WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser |
|
12 * General Public License for more details. |
|
13 * |
|
14 * This code is made available on the understanding that it will not be |
|
15 * used in safety-critical situations without a full and competent review. |
|
16 */ |
|
17 |
|
18 /**** |
|
19 * IEC 61131-3 standard function library |
|
20 */ |
|
21 |
|
22 /* NOTE: This file is full of (what may seem at first) very strange macros. |
|
23 * If you want to know what all these strange macros are doing, |
|
24 * just parse this file through a C preprocessor (e.g. cpp), |
|
25 * and analyse the output! |
|
26 * $gcc -E iec_std_lib.h |
|
27 */ |
|
28 |
|
29 #ifndef _IEC_STD_FUNCTIONS_H |
|
30 #define _IEC_STD_FUNCTIONS_H |
|
31 |
|
32 |
|
33 /*****************************************************************/ |
|
34 /*****************************************************************/ |
|
35 /***** *****/ |
|
36 /***** IEC 61131-3 *****/ |
|
37 /***** S T A N D A R D F U N C T I O N S *****/ |
|
38 /***** *****/ |
|
39 /*****************************************************************/ |
|
40 /*****************************************************************/ |
|
41 |
|
42 /* NOTE: If you want to know what all these strange macros are doing, |
|
43 * just parse this file through a C preprocessor, and analyse the output! |
|
44 * $gcc -E iec_std_lib.h |
|
45 */ |
|
46 |
|
47 /* NOTE: We only define and declare the explicitly typed standard functions |
|
48 * (e.g., SIN_REAL, SIN_LREAL, ..., ADD_SINT, ADD_INT, ADD_LINT, ...) |
|
49 * We do not declare/define the overloaded functions |
|
50 * (SIN, ADD, ...). |
|
51 * When handling a call to an overloaded function, the iec2c compiler |
|
52 * will determine in stage3 the data type of the parameter being passed, |
|
53 * and in stage4 generate the C code to call the correct |
|
54 * typed standard function. |
|
55 */ |
|
56 |
|
57 /* NOTE on explicit typing of: |
|
58 * - Table 25 - Standard bit shift functions |
|
59 * - Table 29 - Character string Functions |
|
60 * |
|
61 * In section 2.5.1.4 (Typing, overloading, and type conversion) of the IEC 61131-3 (version 2) |
|
62 * of the standard, it is stated: |
|
63 * "A standard function, [...] is said to be overloaded when it |
|
64 * can operate on input data elements of various types within a generic type designator as defined in |
|
65 * 2.3.2. For instance, an overloaded addition function on generic type ANY_NUM can operate on data |
|
66 * of types LREAL, REAL, DINT, INT, and SINT." |
|
67 * [...] |
|
68 * "When a function which normally represents an overloaded operator is to be typed, i.e., the types |
|
69 * of its inputs and outputs restricted to a particular elementary or derived data type as defined in |
|
70 * 2.3, this shall be done by appending an "underline" character followed by the required type, as |
|
71 * shown in table 21." |
|
72 * |
|
73 * However, this explanation (as well as the example in table 21) only refers to functions where the same |
|
74 * generic data type is used for the single input and the output parameter. |
|
75 * How can we create explicitly types functions when this is not the case? |
|
76 * It does not seem to be covered by the standard. |
|
77 * |
|
78 * For this reason, we do not define the LEN_SINT, LEN_INT, LEN_STRING, LEN_[ANY_INT], LEN_[ANY_STRING] functions... |
|
79 */ |
|
80 |
|
81 |
|
82 /********************/ |
|
83 /* EN/ENO PARAMS */ |
|
84 /********************/ |
|
85 |
|
86 #define EN_ENO_PARAMS BOOL EN, BOOL *ENO |
|
87 #define EN_ENO EN, ENO |
|
88 |
|
89 #define TEST_EN(TYPENAME)\ |
|
90 if (!EN) {\ |
|
91 if (ENO != NULL)\ |
|
92 *ENO = __BOOL_LITERAL(FALSE);\ |
|
93 return __INIT_##TYPENAME;\ |
|
94 }\ |
|
95 else if (ENO != NULL)\ |
|
96 *ENO = __BOOL_LITERAL(TRUE); |
|
97 |
|
98 #define TEST_EN_COND(TYPENAME, COND)\ |
|
99 if (!EN || (COND)) {\ |
|
100 if (ENO != NULL)\ |
|
101 *ENO = __BOOL_LITERAL(FALSE);\ |
|
102 return __INIT_##TYPENAME;\ |
|
103 }\ |
|
104 else if (ENO != NULL)\ |
|
105 *ENO = __BOOL_LITERAL(TRUE); |
|
106 |
|
107 |
|
108 |
|
109 /*****************************************/ |
|
110 /*****************************************/ |
|
111 /* 2.5.1.5.1 Type Conversion Functions */ |
|
112 /*****************************************/ |
|
113 /*****************************************/ |
|
114 |
|
115 #define __convert_type(from_TYPENAME,to_TYPENAME, oper) \ |
|
116 static inline to_TYPENAME from_TYPENAME##_TO_##to_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\ |
|
117 TEST_EN(to_TYPENAME)\ |
|
118 return (to_TYPENAME)oper(op);\ |
|
119 } |
|
120 |
|
121 /******** [ANY_NUM | ANY_NBIT]_TO_BOOL ************/ |
|
122 #define __convert_num_to_bool(TYPENAME) \ |
|
123 static inline BOOL TYPENAME##_TO_BOOL(EN_ENO_PARAMS, TYPENAME op){\ |
|
124 TEST_EN(BOOL)\ |
|
125 return op == 0 ? 0 : 1;\ |
|
126 } |
|
127 __ANY_NUM(__convert_num_to_bool) |
|
128 __ANY_NBIT(__convert_num_to_bool) |
|
129 |
|
130 /******** [TIME | ANY_DATE]_TO_BOOL ************/ |
|
131 #define __convert_time_to_bool(TYPENAME) \ |
|
132 static inline BOOL TYPENAME##_TO_BOOL(EN_ENO_PARAMS, TYPENAME op){\ |
|
133 TEST_EN(BOOL)\ |
|
134 return op.tv_sec == 0 && op.tv_nsec == 0 ? 0 : 1;\ |
|
135 } |
|
136 __convert_time_to_bool(TIME) |
|
137 __ANY_DATE(__convert_time_to_bool) |
|
138 |
|
139 #define __to_anynum_(from_TYPENAME) __ANY_NUM_1(__iec_,from_TYPENAME) |
|
140 #define __to_anyint_(from_TYPENAME) __ANY_INT_1(__iec_,from_TYPENAME) |
|
141 #define __to_anybit_(from_TYPENAME) __ANY_BIT_1(__iec_,from_TYPENAME) |
|
142 #define __to_anynbit_(from_TYPENAME) __ANY_NBIT_1(__iec_,from_TYPENAME) |
|
143 #define __to_anysint_(from_TYPENAME) __ANY_SINT_1(__iec_,from_TYPENAME) |
|
144 #define __to_anyuint_(from_TYPENAME) __ANY_UINT_1(__iec_,from_TYPENAME) |
|
145 #define __to_anyreal_(from_TYPENAME) __ANY_REAL_1(__iec_,from_TYPENAME) |
|
146 #define __to_anydate_(from_TYPENAME) __ANY_DATE_1(__iec_,from_TYPENAME) |
|
147 |
|
148 /******** [ANY_BIT]_TO_[ANY_NUM | ANT_NBIT] ************/ |
|
149 #define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __move_##to_TYPENAME) |
|
150 __ANY_BIT(__to_anynum_) |
|
151 __ANY_BIT(__to_anynbit_) |
|
152 #undef __iec_ |
|
153 |
|
154 /******** [ANY_INT]_TO_[ANY_NUM | ANT_NBIT] ************/ |
|
155 #define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __move_##to_TYPENAME) |
|
156 __ANY_INT(__to_anynum_) |
|
157 __ANY_INT(__to_anynbit_) |
|
158 #undef __iec_ |
|
159 |
|
160 /******** [ANY_REAL]_TO_[ANY_NBIT] ************/ |
|
161 #define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_bit) |
|
162 __ANY_REAL(__to_anynbit_) |
|
163 #undef __iec_ |
|
164 |
|
165 /******** [ANY_REAL]_TO_[ANY_NINT] ************/ |
|
166 #define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_sint) |
|
167 __ANY_REAL(__to_anysint_) |
|
168 #undef __iec_ |
|
169 #define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_uint) |
|
170 __ANY_REAL(__to_anyuint_) |
|
171 #undef __iec_ |
|
172 |
|
173 /******** [ANY_REAL]_TO_[ANY_REAL] ************/ |
|
174 #define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __move_##to_TYPENAME) |
|
175 __ANY_REAL(__to_anyreal_) |
|
176 #undef __iec_ |
|
177 |
|
178 /******** [ANY_BIT | ANY_INT]_TO_[TIME | ANY_DATE] ************/ |
|
179 #define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, TIME, __int_to_time) |
|
180 __ANY_BIT(__iec_) |
|
181 __ANY_INT(__iec_) |
|
182 #undef __iec_ |
|
183 #define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __int_to_time) |
|
184 __ANY_BIT(__to_anydate_) |
|
185 __ANY_INT(__to_anydate_) |
|
186 #undef __iec_ |
|
187 |
|
188 /******** [ANY_REAL]_TO_[TIME | ANY_DATE] ************/ |
|
189 #define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, TIME, __real_to_time) |
|
190 __ANY_REAL(__iec_) |
|
191 #undef __iec_ |
|
192 #define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __real_to_time) |
|
193 __ANY_REAL(__to_anydate_) |
|
194 #undef __iec_ |
|
195 |
|
196 /******** [TIME | ANY_DATE]_TO_[ANY_BIT | ANY_INT] ************/ |
|
197 #define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __time_to_int) |
|
198 __to_anyint_(TIME) |
|
199 __to_anynbit_(TIME) |
|
200 __ANY_DATE(__to_anyint_) |
|
201 __ANY_DATE(__to_anynbit_) |
|
202 #undef __iec_ |
|
203 |
|
204 /******** [TIME | ANY_DATE]_TO_[ANY_REAL] ************/ |
|
205 #define __iec_(to_TYPENAME,from_TYPENAME) __convert_type(from_TYPENAME, to_TYPENAME, __time_to_real) |
|
206 __to_anyreal_(TIME) |
|
207 __ANY_DATE(__to_anyreal_) |
|
208 #undef __iec_ |
|
209 |
|
210 |
|
211 /******** [ANY_DATE]_TO_[ANY_DATE | TIME] ************/ |
|
212 /* Not supported: DT_TO_TIME */ |
|
213 __convert_type(DT, DATE, __date_and_time_to_date) |
|
214 static inline DATE DATE_AND_TIME_TO_DATE(EN_ENO_PARAMS, DT op){ |
|
215 return DT_TO_DATE(EN_ENO, op); |
|
216 } |
|
217 __convert_type(DT, DT, __move_DT) |
|
218 __convert_type(DT, TOD, __date_and_time_to_time_of_day) |
|
219 static inline DATE DATE_AND_TIME_TO_TIME_OF_DAY(EN_ENO_PARAMS, DT op){ |
|
220 return DT_TO_TOD(EN_ENO, op); |
|
221 } |
|
222 /* Not supported: DATE_TO_TIME */ |
|
223 __convert_type(DATE, DATE, __move_DATE) |
|
224 /* Not supported: DATE_TO_DT */ |
|
225 /* Not supported: DATE_TO_TOD */ |
|
226 /* Not supported: TOD_TO_TIME */ |
|
227 /* Not supported: TOD_TO_DATE */ |
|
228 /* Not supported: TOD_TO_DT */ |
|
229 __convert_type(TOD, TOD, __move_TOD) |
|
230 |
|
231 |
|
232 /******** TIME_TO_[ANY_DATE] ************/ |
|
233 /* Not supported: TIME_TO_DATE */ |
|
234 /* Not supported: TIME_TO_DT */ |
|
235 /* Not supported: TIME_TO_TOD */ |
|
236 |
|
237 /******** TIME_TO_TIME ************/ |
|
238 __convert_type(TIME, TIME, __move_TIME) |
|
239 |
|
240 |
|
241 /******** [ANY_BIT]_TO_STRING ************/ |
|
242 __convert_type(BOOL, STRING, __bool_to_string) |
|
243 #define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __bit_to_string) |
|
244 __ANY_NBIT(__iec_) |
|
245 #undef __iec_ |
|
246 |
|
247 /******** [ANY_INT]_TO_STRING ************/ |
|
248 #define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __sint_to_string) |
|
249 __ANY_SINT(__iec_) |
|
250 #undef __iec_ |
|
251 #define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __uint_to_string) |
|
252 __ANY_UINT(__iec_) |
|
253 #undef __iec_ |
|
254 |
|
255 /******** [ANY_REAL]_TO_STRING ************/ |
|
256 #define __iec_(from_TYPENAME) __convert_type(from_TYPENAME, STRING, __real_to_string) |
|
257 __ANY_REAL(__iec_) |
|
258 #undef __iec_ |
|
259 |
|
260 /******** [ANY_DATE]_TO_STRING ************/ |
|
261 __convert_type(DATE, STRING, __date_to_string) |
|
262 __convert_type(DT, STRING, __dt_to_string) |
|
263 __convert_type(TOD, STRING, __tod_to_string) |
|
264 |
|
265 /******** TIME_TO_STRING ************/ |
|
266 __convert_type(TIME, STRING, __time_to_string) |
|
267 |
|
268 |
|
269 /******** STRING_TO_[ANY_BIT] ************/ |
|
270 __convert_type(STRING, BOOL, __string_to_bool) |
|
271 #define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_bit) |
|
272 __ANY_NBIT(__iec_) |
|
273 #undef __iec_ |
|
274 |
|
275 /******** STRING_TO_[ANY_INT] ************/ |
|
276 #define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_sint) |
|
277 __ANY_SINT(__iec_) |
|
278 #undef __iec_ |
|
279 #define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_uint) |
|
280 __ANY_UINT(__iec_) |
|
281 #undef __iec_ |
|
282 |
|
283 /******** STRING_TO_[ANY_REAL] ************/ |
|
284 #define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_real) |
|
285 __ANY_REAL(__iec_) |
|
286 #undef __iec_ |
|
287 |
|
288 /******** STRING_TO_[ANY_DATE] ************/ |
|
289 #define __iec_(to_TYPENAME) __convert_type(STRING, to_TYPENAME, __string_to_time) |
|
290 __ANY_DATE(__iec_) |
|
291 #undef __iec_ |
|
292 |
|
293 /******** STRING_TO_TIME ************/ |
|
294 __convert_type(STRING, TIME, __string_to_time) |
|
295 |
|
296 |
|
297 /******** TRUNC ************/ |
|
298 #define __iec_(to_TYPENAME,from_TYPENAME) \ |
|
299 static inline to_TYPENAME TRUNC__##to_TYPENAME##__##from_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\ |
|
300 TEST_EN(to_TYPENAME)\ |
|
301 return (to_TYPENAME)__move_##to_TYPENAME(op);\ |
|
302 } |
|
303 __ANY_REAL(__to_anyint_) |
|
304 #undef __iec_ |
|
305 |
|
306 |
|
307 /******** _TO_BCD ************/ |
|
308 #define __iec_(to_TYPENAME,from_TYPENAME) \ |
|
309 static inline to_TYPENAME from_TYPENAME##_TO_BCD_##to_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\ |
|
310 TEST_EN(to_TYPENAME)\ |
|
311 return (to_TYPENAME)__uint_to_bcd(op);\ |
|
312 }\ |
|
313 static inline to_TYPENAME from_TYPENAME##_TO_BCD__##to_TYPENAME##__##from_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\ |
|
314 return from_TYPENAME##_TO_BCD_##to_TYPENAME(EN_ENO, op);\ |
|
315 } |
|
316 __ANY_UINT(__to_anynbit_) |
|
317 #undef __iec_ |
|
318 |
|
319 |
|
320 /******** BCD_TO_ ************/ |
|
321 #define __iec_(to_TYPENAME,from_TYPENAME) \ |
|
322 static inline to_TYPENAME from_TYPENAME##_BCD_TO_##to_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\ |
|
323 TEST_EN_COND(to_TYPENAME, __test_bcd(op))\ |
|
324 return (to_TYPENAME)__bcd_to_uint(op);\ |
|
325 }\ |
|
326 static inline to_TYPENAME BCD_TO_##to_TYPENAME##__##to_TYPENAME##__##from_TYPENAME(EN_ENO_PARAMS, from_TYPENAME op){\ |
|
327 return from_TYPENAME##_BCD_TO_##to_TYPENAME(EN_ENO, op);\ |
|
328 } |
|
329 __ANY_NBIT(__to_anyuint_) |
|
330 #undef __iec_ |
|
331 |
|
332 |
|
333 /***********************************/ |
|
334 /***********************************/ |
|
335 /* 2.5.1.5.2 Numerical Functions */ |
|
336 /***********************************/ |
|
337 /***********************************/ |
|
338 |
|
339 /* workaround for va-args limitation on shorter than int params */ |
|
340 #define VA_ARGS_REAL LREAL |
|
341 #define VA_ARGS_LREAL LREAL |
|
342 #define VA_ARGS_SINT DINT |
|
343 #define VA_ARGS_INT DINT |
|
344 #define VA_ARGS_DINT DINT |
|
345 #define VA_ARGS_LINT LINT |
|
346 #define VA_ARGS_USINT UDINT |
|
347 #define VA_ARGS_UINT UDINT |
|
348 #define VA_ARGS_UDINT UDINT |
|
349 #define VA_ARGS_ULINT ULINT |
|
350 #define VA_ARGS_TIME TIME |
|
351 #define VA_ARGS_BOOL DWORD |
|
352 #define VA_ARGS_BYTE DWORD |
|
353 #define VA_ARGS_WORD DWORD |
|
354 #define VA_ARGS_DWORD DWORD |
|
355 #define VA_ARGS_LWORD LWORD |
|
356 #define VA_ARGS_STRING STRING |
|
357 #define VA_ARGS_WSTRING WSTRING |
|
358 #define VA_ARGS_DATE DATE |
|
359 #define VA_ARGS_TOD TOD |
|
360 #define VA_ARGS_DT DT |
|
361 |
|
362 |
|
363 #define __numeric(fname,TYPENAME, FUNC) \ |
|
364 /* explicitly typed function */\ |
|
365 static inline TYPENAME fname##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\ |
|
366 TEST_EN(TYPENAME)\ |
|
367 return FUNC(op);\ |
|
368 }\ |
|
369 /* overloaded function */\ |
|
370 static inline TYPENAME fname##_##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op) {\ |
|
371 return fname##TYPENAME(EN_ENO, op);\ |
|
372 } |
|
373 |
|
374 /******************************************************************/ |
|
375 /*** Table 23 - Standard functions of one numeric variable ***/ |
|
376 /******************************************************************/ |
|
377 |
|
378 /**************/ |
|
379 /* ABS */ |
|
380 /**************/ |
|
381 #define __abs_signed(TYPENAME) \ |
|
382 /* explicitly typed function */\ |
|
383 static inline TYPENAME ABS_##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\ |
|
384 TEST_EN(TYPENAME)\ |
|
385 if (op < 0)\ |
|
386 return -op;\ |
|
387 return op;\ |
|
388 }\ |
|
389 /* overloaded function */\ |
|
390 static inline TYPENAME ABS__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op) {\ |
|
391 return ABS_##TYPENAME(EN_ENO, op);\ |
|
392 } |
|
393 |
|
394 #define __abs_unsigned(TYPENAME) \ |
|
395 /* explicitly typed function */\ |
|
396 static inline TYPENAME ABS_##TYPENAME(EN_ENO_PARAMS, TYPENAME op){\ |
|
397 TEST_EN(TYPENAME)\ |
|
398 return op;\ |
|
399 }\ |
|
400 /* overloaded function */\ |
|
401 static inline TYPENAME ABS__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op) {\ |
|
402 return ABS_##TYPENAME(EN_ENO, op);\ |
|
403 } |
|
404 |
|
405 __ANY_REAL(__abs_signed) |
|
406 __ANY_SINT(__abs_signed) |
|
407 __ANY_UINT(__abs_unsigned) |
|
408 |
|
409 |
|
410 /**************/ |
|
411 /* SQRT */ |
|
412 /**************/ |
|
413 #define __sqrt(TYPENAME) __numeric(SQRT_, TYPENAME, sqrt) |
|
414 __ANY_REAL(__sqrt) |
|
415 |
|
416 |
|
417 /**************/ |
|
418 /* LN */ |
|
419 /**************/ |
|
420 #define __ln(TYPENAME) __numeric(LN_, TYPENAME, log) |
|
421 __ANY_REAL(__ln) |
|
422 |
|
423 |
|
424 /**************/ |
|
425 /* LOG */ |
|
426 /**************/ |
|
427 #define __log(TYPENAME) __numeric(LOG_, TYPENAME, log10) |
|
428 __ANY_REAL(__log) |
|
429 |
|
430 |
|
431 /**************/ |
|
432 /* EXP */ |
|
433 /**************/ |
|
434 #define __exp(TYPENAME) __numeric(EXP_, TYPENAME, exp) |
|
435 __ANY_REAL(__exp) |
|
436 |
|
437 |
|
438 /**************/ |
|
439 /* SIN */ |
|
440 /**************/ |
|
441 #define __sin(TYPENAME) __numeric(SIN_, TYPENAME, sin) |
|
442 __ANY_REAL(__sin) |
|
443 |
|
444 |
|
445 /**************/ |
|
446 /* COS */ |
|
447 /**************/ |
|
448 #define __cos(TYPENAME) __numeric(COS_, TYPENAME, cos) |
|
449 __ANY_REAL(__cos) |
|
450 |
|
451 /**************/ |
|
452 /* TAN */ |
|
453 /**************/ |
|
454 #define __tan(TYPENAME) __numeric(TAN_, TYPENAME, tan) |
|
455 __ANY_REAL(__tan) |
|
456 |
|
457 |
|
458 /**************/ |
|
459 /* ASIN */ |
|
460 /**************/ |
|
461 #define __asin(TYPENAME) __numeric(ASIN_, TYPENAME, asin) |
|
462 __ANY_REAL(__asin) |
|
463 |
|
464 /**************/ |
|
465 /* ACOS */ |
|
466 /**************/ |
|
467 #define __acos(TYPENAME) __numeric(ACOS_, TYPENAME, acos) |
|
468 __ANY_REAL(__acos) |
|
469 |
|
470 /**************/ |
|
471 /* ATAN */ |
|
472 /**************/ |
|
473 #define __atan(TYPENAME) __numeric(ATAN_, TYPENAME, atan) |
|
474 __ANY_REAL(__atan) |
|
475 |
|
476 |
|
477 |
|
478 /*****************************************************/ |
|
479 /*** Table 24 - Standard arithmetic functions ***/ |
|
480 /*****************************************************/ |
|
481 |
|
482 #define __arith_expand(fname,TYPENAME, OP)\ |
|
483 static inline TYPENAME fname(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\ |
|
484 va_list ap;\ |
|
485 UINT i;\ |
|
486 TEST_EN(TYPENAME)\ |
|
487 \ |
|
488 va_start (ap, op1); /* Initialize the argument list. */\ |
|
489 \ |
|
490 for (i = 0; i < param_count - 1; i++){\ |
|
491 op1 = op1 OP va_arg (ap, VA_ARGS_##TYPENAME);\ |
|
492 }\ |
|
493 \ |
|
494 va_end (ap); /* Clean up. */\ |
|
495 return op1;\ |
|
496 } |
|
497 |
|
498 #define __arith_static(fname,TYPENAME, OP)\ |
|
499 /* explicitly typed function */\ |
|
500 static inline TYPENAME fname##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\ |
|
501 TEST_EN(TYPENAME)\ |
|
502 return op1 OP op2;\ |
|
503 }\ |
|
504 /* overloaded function */\ |
|
505 static inline TYPENAME fname##_##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\ |
|
506 return fname##TYPENAME(EN_ENO, op1, op2);\ |
|
507 } |
|
508 |
|
509 /**************/ |
|
510 /* ADD */ |
|
511 /**************/ |
|
512 #define __add(TYPENAME) \ |
|
513 __arith_expand(ADD_##TYPENAME, TYPENAME, +) /* explicitly typed function */\ |
|
514 __arith_expand(ADD__##TYPENAME##__##TYPENAME, TYPENAME, +) /* overloaded function */ |
|
515 __ANY_NUM(__add) |
|
516 |
|
517 |
|
518 /**************/ |
|
519 /* MUL */ |
|
520 /**************/ |
|
521 #define __mul(TYPENAME) \ |
|
522 __arith_expand(MUL_##TYPENAME, TYPENAME, *) /* explicitly typed function */\ |
|
523 __arith_expand(MUL__##TYPENAME##__##TYPENAME, TYPENAME, *) /* overloaded function */ |
|
524 __ANY_NUM(__mul) |
|
525 |
|
526 |
|
527 /**************/ |
|
528 /* SUB */ |
|
529 /**************/ |
|
530 #define __sub(TYPENAME) __arith_static(SUB_, TYPENAME, -) |
|
531 __ANY_NUM(__sub) |
|
532 |
|
533 |
|
534 /**************/ |
|
535 /* DIV */ |
|
536 /**************/ |
|
537 #define __div(TYPENAME)\ |
|
538 /* The explicitly typed standard functions */\ |
|
539 static inline TYPENAME DIV_##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\ |
|
540 TEST_EN_COND(TYPENAME, op2 == 0)\ |
|
541 return op1 / op2;\ |
|
542 }\ |
|
543 /* The overloaded standard functions */\ |
|
544 static inline TYPENAME DIV__##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\ |
|
545 return DIV_##TYPENAME(EN_ENO, op1, op2);\ |
|
546 } |
|
547 __ANY_NUM(__div) |
|
548 |
|
549 |
|
550 /**************/ |
|
551 /* MOD */ |
|
552 /**************/ |
|
553 #define __mod(TYPENAME)\ |
|
554 /* The explicitly typed standard functions */\ |
|
555 static inline TYPENAME MOD_##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\ |
|
556 TEST_EN(TYPENAME)\ |
|
557 if (op2 == 0) return 0;\ |
|
558 return op1 % op2;\ |
|
559 }\ |
|
560 /* The overloaded standard functions */\ |
|
561 static inline TYPENAME MOD__##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\ |
|
562 return MOD_##TYPENAME(EN_ENO, op1, op2);\ |
|
563 } |
|
564 __ANY_INT(__mod) |
|
565 |
|
566 /**************/ |
|
567 /* EXPT */ |
|
568 /**************/ |
|
569 /* overloaded function */ |
|
570 #define __iec_(in1_TYPENAME,in2_TYPENAME) \ |
|
571 static inline in1_TYPENAME EXPT__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME\ |
|
572 (EN_ENO_PARAMS, in1_TYPENAME IN1, in2_TYPENAME IN2){\ |
|
573 TEST_EN(in1_TYPENAME)\ |
|
574 return pow(IN1, IN2);\ |
|
575 } |
|
576 #define __in1_anyreal_(in2_TYPENAME) __ANY_REAL_1(__iec_,in2_TYPENAME) |
|
577 __ANY_NUM(__in1_anyreal_) |
|
578 #undef __iec_ |
|
579 |
|
580 |
|
581 |
|
582 /***************/ |
|
583 /* MOVE */ |
|
584 /***************/ |
|
585 /* The explicitly typed standard functions */ |
|
586 #define __iec_(TYPENAME)\ |
|
587 static inline TYPENAME MOVE_##TYPENAME(EN_ENO_PARAMS, TYPENAME op1){\ |
|
588 TEST_EN(TYPENAME)\ |
|
589 return op1;\ |
|
590 } |
|
591 __ANY(__iec_) |
|
592 #undef __iec_ |
|
593 |
|
594 /* Overloaded function */ |
|
595 #define __iec_(TYPENAME)\ |
|
596 static inline TYPENAME MOVE__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1){\ |
|
597 TEST_EN(TYPENAME)\ |
|
598 return op1;\ |
|
599 } |
|
600 __ANY(__iec_) |
|
601 #undef __iec_ |
|
602 |
|
603 |
|
604 |
|
605 |
|
606 |
|
607 |
|
608 /***********************************/ |
|
609 /***********************************/ |
|
610 /* 2.5.1.5.3 Bit String Functions */ |
|
611 /***********************************/ |
|
612 /***********************************/ |
|
613 |
|
614 /****************************************************/ |
|
615 /*** Table 25 - Standard bit shift functions ***/ |
|
616 /****************************************************/ |
|
617 |
|
618 /* We do not delcare explcitly typed versions of the functions in table 25. |
|
619 * See note above regarding explicitly typed functions for more details. |
|
620 */ |
|
621 #define __in1_anynbit_(in2_TYPENAME) __ANY_NBIT_1(__iec_,in2_TYPENAME) |
|
622 |
|
623 #define __shift_(fname, in1_TYPENAME, in2_TYPENAME, OP)\ |
|
624 static inline in1_TYPENAME fname(EN_ENO_PARAMS, in1_TYPENAME IN, in2_TYPENAME N) {\ |
|
625 TEST_EN(in1_TYPENAME)\ |
|
626 return IN OP N;\ |
|
627 } |
|
628 |
|
629 /**************/ |
|
630 /* SHL */ |
|
631 /**************/ |
|
632 #define __iec_(TYPENAME) \ |
|
633 /* Overloaded function */\ |
|
634 static inline BOOL SHL__BOOL__##TYPENAME(EN_ENO_PARAMS, BOOL IN, TYPENAME N) { \ |
|
635 TEST_EN(BOOL);\ |
|
636 return (N==0)? IN : __INIT_BOOL; /* shifting by N>1 will always introduce a 0 */\ |
|
637 } |
|
638 __ANY_INT(__iec_) |
|
639 #undef __iec_ |
|
640 |
|
641 |
|
642 #define __iec_(in1_TYPENAME,in2_TYPENAME) \ |
|
643 __shift_(SHL__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME, in1_TYPENAME, in2_TYPENAME, << )/* Overloaded function */ |
|
644 __ANY_INT(__in1_anynbit_) |
|
645 #undef __iec_ |
|
646 |
|
647 |
|
648 /**************/ |
|
649 /* SHR */ |
|
650 /**************/ |
|
651 #define __iec_(TYPENAME) \ |
|
652 /* Overloaded function */\ |
|
653 static inline BOOL SHR__BOOL__##TYPENAME(EN_ENO_PARAMS, BOOL IN, TYPENAME N) { \ |
|
654 TEST_EN(BOOL);\ |
|
655 return (N==0)? IN : __INIT_BOOL; /* shifting by N>1 will always introduce a 0 */\ |
|
656 } |
|
657 __ANY_INT(__iec_) |
|
658 #undef __iec_ |
|
659 |
|
660 |
|
661 #define __iec_(in1_TYPENAME,in2_TYPENAME) \ |
|
662 __shift_(SHR__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME, in1_TYPENAME, in2_TYPENAME, >> )/* Overloaded function */ |
|
663 __ANY_INT(__in1_anynbit_) |
|
664 #undef __iec_ |
|
665 |
|
666 |
|
667 /**************/ |
|
668 /* ROR */ |
|
669 /**************/ |
|
670 #define __iec_(TYPENAME) \ |
|
671 /* Overloaded function */\ |
|
672 static inline BOOL ROR__BOOL__##TYPENAME(EN_ENO_PARAMS, BOOL IN, TYPENAME N) { \ |
|
673 TEST_EN(BOOL);\ |
|
674 return IN; /* rotating a single bit by any value N will not change that bit! */\ |
|
675 } |
|
676 __ANY_INT(__iec_) |
|
677 #undef __iec_ |
|
678 |
|
679 |
|
680 #define __iec_(in1_TYPENAME,in2_TYPENAME) \ |
|
681 static inline in1_TYPENAME ROR__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME(EN_ENO_PARAMS, in1_TYPENAME IN, in2_TYPENAME N){\ |
|
682 TEST_EN(in1_TYPENAME)\ |
|
683 N %= 8*sizeof(in1_TYPENAME);\ |
|
684 return (IN >> N) | (IN << (8*sizeof(in1_TYPENAME)-N));\ |
|
685 } |
|
686 __ANY_INT(__in1_anynbit_) |
|
687 #undef __iec_ |
|
688 |
|
689 |
|
690 /**************/ |
|
691 /* ROL */ |
|
692 /**************/ |
|
693 #define __iec_(TYPENAME) \ |
|
694 /* Overloaded function */\ |
|
695 static inline BOOL ROL__BOOL__##TYPENAME(EN_ENO_PARAMS, BOOL IN, TYPENAME N) { \ |
|
696 TEST_EN(BOOL);\ |
|
697 return IN; /* rotating a single bit by any value N will not change that bit! */\ |
|
698 } |
|
699 __ANY_INT(__iec_) |
|
700 #undef __iec_ |
|
701 |
|
702 |
|
703 #define __iec_(in1_TYPENAME,in2_TYPENAME) \ |
|
704 static inline in1_TYPENAME ROL__##in1_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME(EN_ENO_PARAMS, in1_TYPENAME IN, in2_TYPENAME N){\ |
|
705 TEST_EN(in1_TYPENAME)\ |
|
706 N %= 8*sizeof(in1_TYPENAME);\ |
|
707 return (IN << N) | (IN >> (8*sizeof(in1_TYPENAME)-N));\ |
|
708 } |
|
709 __ANY_INT(__in1_anynbit_) |
|
710 #undef __iec_ |
|
711 |
|
712 |
|
713 |
|
714 /*********************/ |
|
715 /*** Table 26 ***/ |
|
716 /*********************/ |
|
717 |
|
718 /**************/ |
|
719 /* AND */ |
|
720 /**************/ |
|
721 __arith_expand(AND_BOOL, BOOL, && ) /* The explicitly typed standard functions */ |
|
722 __arith_expand(AND__BOOL__BOOL, BOOL, && ) /* Overloaded function */ |
|
723 |
|
724 #define __iec_(TYPENAME) \ |
|
725 __arith_expand(AND_##TYPENAME, TYPENAME, &) /* The explicitly typed standard functions */\ |
|
726 __arith_expand(AND__##TYPENAME##__##TYPENAME, TYPENAME, &) /* Overloaded function */ |
|
727 __ANY_NBIT(__iec_) |
|
728 #undef __iec_ |
|
729 |
|
730 /*************/ |
|
731 /* OR */ |
|
732 /*************/ |
|
733 __arith_expand(OR_BOOL, BOOL, || ) /* The explicitly typed standard functions */ |
|
734 __arith_expand(OR__BOOL__BOOL, BOOL, || ) /* Overloaded function */ |
|
735 |
|
736 #define __iec_(TYPENAME) \ |
|
737 __arith_expand(OR_##TYPENAME, TYPENAME, |) /* The explicitly typed standard functions */\ |
|
738 __arith_expand(OR__##TYPENAME##__##TYPENAME, TYPENAME, |) /* Overloaded function */ |
|
739 __ANY_NBIT(__iec_) |
|
740 #undef __iec_ |
|
741 |
|
742 /**************/ |
|
743 /* XOR */ |
|
744 /**************/ |
|
745 #define __xorbool_expand(fname) \ |
|
746 static inline BOOL fname(EN_ENO_PARAMS, UINT param_count, BOOL op1, ...){ \ |
|
747 va_list ap; \ |
|
748 UINT i; \ |
|
749 TEST_EN(BOOL) \ |
|
750 \ |
|
751 va_start (ap, op1); /* Initialize the argument list. */ \ |
|
752 \ |
|
753 for (i = 0; i < param_count - 1; i++){ \ |
|
754 BOOL tmp = va_arg (ap, VA_ARGS_BOOL); \ |
|
755 op1 = (op1 && !tmp) || (!op1 && tmp); \ |
|
756 } \ |
|
757 \ |
|
758 va_end (ap); /* Clean up. */ \ |
|
759 return op1; \ |
|
760 } |
|
761 |
|
762 __xorbool_expand(XOR_BOOL) /* The explicitly typed standard functions */ |
|
763 __xorbool_expand(XOR__BOOL__BOOL) /* Overloaded function */ |
|
764 |
|
765 #define __iec_(TYPENAME) \ |
|
766 __arith_expand(XOR_##TYPENAME, TYPENAME, ^) /* The explicitly typed standard functions */\ |
|
767 __arith_expand(XOR__##TYPENAME##__##TYPENAME, TYPENAME, ^) /* Overloaded function */\ |
|
768 __ANY_NBIT(__iec_) |
|
769 #undef __iec_ |
|
770 |
|
771 |
|
772 /**************/ |
|
773 /* NOT */ |
|
774 /**************/ |
|
775 /* The explicitly typed standard functions */ |
|
776 static inline BOOL NOT_BOOL(EN_ENO_PARAMS, BOOL op1){ |
|
777 TEST_EN(BOOL) |
|
778 return !op1; |
|
779 } |
|
780 |
|
781 /* Overloaded function */ |
|
782 static inline BOOL NOT__BOOL__BOOL(EN_ENO_PARAMS, BOOL op1){ |
|
783 TEST_EN(BOOL) |
|
784 return !op1; |
|
785 } |
|
786 |
|
787 /* The explicitly typed standard functions */ |
|
788 #define __iec_(TYPENAME)\ |
|
789 static inline TYPENAME NOT_##TYPENAME(EN_ENO_PARAMS, TYPENAME op1){\ |
|
790 TEST_EN(TYPENAME)\ |
|
791 return ~op1;\ |
|
792 } |
|
793 __ANY_NBIT(__iec_) |
|
794 #undef __iec_ |
|
795 |
|
796 /* Overloaded function */ |
|
797 #define __iec_(TYPENAME)\ |
|
798 static inline TYPENAME NOT__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME op1){\ |
|
799 TEST_EN(TYPENAME)\ |
|
800 return ~op1;\ |
|
801 } |
|
802 __ANY_NBIT(__iec_) |
|
803 #undef __iec_ |
|
804 |
|
805 |
|
806 |
|
807 |
|
808 |
|
809 |
|
810 /***************************************************/ |
|
811 /***************************************************/ |
|
812 /* 2.5.1.5.4 Selection and comparison Functions */ |
|
813 /***************************************************/ |
|
814 /***************************************************/ |
|
815 |
|
816 /*********************/ |
|
817 /*** Table 27 ***/ |
|
818 /*********************/ |
|
819 |
|
820 |
|
821 /**************/ |
|
822 /* SEL */ |
|
823 /**************/ |
|
824 |
|
825 /* The explicitly typed standard functions */ |
|
826 #define __iec_(TYPENAME)\ |
|
827 static inline TYPENAME SEL_##TYPENAME(EN_ENO_PARAMS, BOOL G, TYPENAME op0, TYPENAME op1){\ |
|
828 TEST_EN(TYPENAME)\ |
|
829 return G ? op1 : op0;\ |
|
830 } |
|
831 __ANY(__iec_) |
|
832 #undef __iec_ |
|
833 |
|
834 /* Overloaded function */ |
|
835 #define __iec_(TYPENAME)\ |
|
836 static inline TYPENAME SEL__##TYPENAME##__BOOL__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, BOOL G, TYPENAME op0, TYPENAME op1){\ |
|
837 TEST_EN(TYPENAME)\ |
|
838 return G ? op1 : op0;\ |
|
839 } |
|
840 __ANY(__iec_) |
|
841 #undef __iec_ |
|
842 |
|
843 |
|
844 /**************/ |
|
845 /* MAX */ |
|
846 /**************/ |
|
847 |
|
848 #define __extrem_(fname,TYPENAME, COND) \ |
|
849 static inline TYPENAME fname(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\ |
|
850 va_list ap;\ |
|
851 UINT i;\ |
|
852 TEST_EN(TYPENAME)\ |
|
853 \ |
|
854 va_start (ap, op1); /* Initialize the argument list. */\ |
|
855 \ |
|
856 for (i = 0; i < param_count - 1; i++){\ |
|
857 TYPENAME tmp = va_arg (ap, VA_ARGS_##TYPENAME);\ |
|
858 op1 = COND ? tmp : op1;\ |
|
859 }\ |
|
860 \ |
|
861 va_end (ap); /* Clean up. */\ |
|
862 return op1;\ |
|
863 } |
|
864 |
|
865 /* Max for numerical data types */ |
|
866 #define __iec_(TYPENAME) \ |
|
867 __extrem_(MAX_##TYPENAME,TYPENAME, op1 < tmp) /* The explicitly typed standard functions */\ |
|
868 __extrem_(MAX__##TYPENAME##__##TYPENAME,TYPENAME, op1 < tmp) /* Overloaded function */ |
|
869 __ANY_BIT(__iec_) |
|
870 __ANY_NUM(__iec_) |
|
871 #undef __iec_ |
|
872 |
|
873 /* Max for time data types */ |
|
874 #define __iec_(TYPENAME) \ |
|
875 __extrem_(MAX_##TYPENAME, TYPENAME, __time_cmp(op1, tmp) < 0) /* The explicitly typed standard functions */\ |
|
876 __extrem_(MAX__##TYPENAME##__##TYPENAME, TYPENAME, __time_cmp(op1, tmp) < 0) /* Overloaded function */ |
|
877 __ANY_DATE(__iec_) |
|
878 __iec_(TIME) |
|
879 #undef __iec_ |
|
880 |
|
881 #define __STR_CMP(str1, str2) memcmp((char*)&str1.body,(char*)&str2.body, str1.len < str2.len ? str1.len : str2.len) |
|
882 |
|
883 /* Max for string data types */ |
|
884 __extrem_(MAX_STRING, STRING, __STR_CMP(op1,tmp) < 0) /* The explicitly typed standard functions */ |
|
885 __extrem_(MAX__STRING__STRING, STRING, __STR_CMP(op1,tmp) < 0) /* Overloaded function */ |
|
886 |
|
887 /**************/ |
|
888 /* MIN */ |
|
889 /**************/ |
|
890 /* Min for numerical data types */ |
|
891 #define __iec_(TYPENAME) \ |
|
892 __extrem_(MIN_##TYPENAME, TYPENAME, op1 > tmp) /* The explicitly typed standard functions */\ |
|
893 __extrem_(MIN__##TYPENAME##__##TYPENAME, TYPENAME, op1 > tmp) /* Overloaded function */ |
|
894 __ANY_NBIT(__iec_) |
|
895 __ANY_NUM(__iec_) |
|
896 #undef __iec_ |
|
897 |
|
898 /* Min for time data types */ |
|
899 #define __iec_(TYPENAME) \ |
|
900 __extrem_(MIN_##TYPENAME, TYPENAME, __time_cmp(op1, tmp) > 0) /* The explicitly typed standard functions */\ |
|
901 __extrem_(MIN__##TYPENAME##__##TYPENAME, TYPENAME, __time_cmp(op1, tmp) > 0) /* Overloaded function */ |
|
902 __ANY_DATE(__iec_) |
|
903 __iec_(TIME) |
|
904 #undef __iec_ |
|
905 |
|
906 /* Min for string data types */ |
|
907 __extrem_(MIN_STRING, STRING, __STR_CMP(op1,tmp) > 0) /* The explicitly typed standard functions */ |
|
908 __extrem_(MIN__STRING__STRING, STRING, __STR_CMP(op1,tmp) > 0) /* Overloaded function */ |
|
909 |
|
910 /**************/ |
|
911 /* LIMIT */ |
|
912 /**************/ |
|
913 |
|
914 /* Limit for numerical data types */ |
|
915 #define __iec_(TYPENAME)\ |
|
916 /* The explicitly typed standard functions */\ |
|
917 static inline TYPENAME LIMIT_##TYPENAME(EN_ENO_PARAMS, TYPENAME MN, TYPENAME IN, TYPENAME MX){\ |
|
918 TEST_EN(TYPENAME)\ |
|
919 return IN > MN ? IN < MX ? IN : MX : MN;\ |
|
920 }\ |
|
921 /* Overloaded function */\ |
|
922 static inline TYPENAME LIMIT__##TYPENAME##__##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME MN, TYPENAME IN, TYPENAME MX){\ |
|
923 TEST_EN(TYPENAME)\ |
|
924 return IN > MN ? IN < MX ? IN : MX : MN;\ |
|
925 } |
|
926 __ANY_NBIT(__iec_) |
|
927 __ANY_NUM(__iec_) |
|
928 #undef __iec_ |
|
929 |
|
930 |
|
931 /* Limit for time data types */ |
|
932 #define __iec_(TYPENAME)\ |
|
933 /* The explicitly typed standard functions */\ |
|
934 static inline TYPENAME LIMIT_##TYPENAME(EN_ENO_PARAMS, TYPENAME MN, TYPENAME IN, TYPENAME MX){\ |
|
935 TEST_EN(TYPENAME)\ |
|
936 return __time_cmp(IN, MN) > 0 ? /* IN>MN ?*/\ |
|
937 __time_cmp(IN, MX) < 0 ? /* IN<MX ?*/\ |
|
938 IN : MX : MN;\ |
|
939 }\ |
|
940 /* Overloaded function */\ |
|
941 static inline TYPENAME LIMIT__##TYPENAME##__##TYPENAME##__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, TYPENAME MN, TYPENAME IN, TYPENAME MX){\ |
|
942 TEST_EN(TYPENAME)\ |
|
943 return __time_cmp(IN, MN) > 0 ? /* IN>MN ?*/\ |
|
944 __time_cmp(IN, MX) < 0 ? /* IN<MX ?*/\ |
|
945 IN : MX : MN;\ |
|
946 } |
|
947 |
|
948 __ANY_DATE(__iec_) |
|
949 __iec_(TIME) |
|
950 #undef __iec_ |
|
951 |
|
952 /* Limit for string data types */ |
|
953 /* The explicitly typed standard functions */ |
|
954 static inline STRING LIMIT_STRING(EN_ENO_PARAMS, STRING MN, STRING IN, STRING MX){ |
|
955 TEST_EN(STRING) |
|
956 return __STR_CMP(IN, MN) > 0 ? __STR_CMP(IN, MX) < 0 ? IN : MX : MN; |
|
957 } |
|
958 |
|
959 /* Overloaded function */ |
|
960 static inline STRING LIMIT__STRING__STRING__STRING__STRING(EN_ENO_PARAMS, STRING MN, STRING IN, STRING MX){ |
|
961 TEST_EN(STRING) |
|
962 return __STR_CMP(IN, MN) > 0 ? __STR_CMP(IN, MX) < 0 ? IN : MX : MN; |
|
963 } |
|
964 |
|
965 |
|
966 /**************/ |
|
967 /* MUX */ |
|
968 /**************/ |
|
969 /* The standard states that the inputs for SEL and MUX must be named starting off from 0, |
|
970 * unlike remaining functions, that start off at 1. |
|
971 */ |
|
972 /* The explicitly typed standard functions */ |
|
973 #define __in1_anyint_(in2_TYPENAME) __ANY_INT_1(__iec_,in2_TYPENAME) |
|
974 #define __iec_(in1_TYPENAME,in2_TYPENAME) \ |
|
975 static inline in2_TYPENAME MUX__##in2_TYPENAME##__##in1_TYPENAME##__##in2_TYPENAME(EN_ENO_PARAMS, in1_TYPENAME K, UINT param_count, ...){\ |
|
976 va_list ap;\ |
|
977 UINT i;\ |
|
978 in2_TYPENAME tmp;\ |
|
979 TEST_EN_COND(in2_TYPENAME, K >= param_count)\ |
|
980 tmp = __INIT_##in2_TYPENAME;\ |
|
981 \ |
|
982 va_start (ap, param_count); /* Initialize the argument list. */\ |
|
983 \ |
|
984 for (i = 0; i < param_count; i++){\ |
|
985 if(K == i){\ |
|
986 tmp = va_arg (ap, VA_ARGS_##in2_TYPENAME);\ |
|
987 va_end (ap); /* Clean up. */\ |
|
988 return tmp;\ |
|
989 }else{\ |
|
990 va_arg (ap, VA_ARGS_##in2_TYPENAME);\ |
|
991 }\ |
|
992 }\ |
|
993 \ |
|
994 va_end (ap); /* Clean up. */\ |
|
995 return tmp;\ |
|
996 } |
|
997 |
|
998 __ANY(__in1_anyint_) |
|
999 #undef __iec_ |
|
1000 |
|
1001 |
|
1002 /******************************************/ |
|
1003 /*** Table 28 ***/ |
|
1004 /*** Standard comparison functions ***/ |
|
1005 /******************************************/ |
|
1006 |
|
1007 #define __compare_(fname,TYPENAME, COND) \ |
|
1008 static inline BOOL fname(EN_ENO_PARAMS, UINT param_count, TYPENAME op1, ...){\ |
|
1009 va_list ap;\ |
|
1010 UINT i;\ |
|
1011 TEST_EN(BOOL)\ |
|
1012 \ |
|
1013 va_start (ap, op1); /* Initialize the argument list. */\ |
|
1014 DBG(#fname #TYPENAME "\n")\ |
|
1015 DBG_TYPE(TYPENAME, op1)\ |
|
1016 \ |
|
1017 for (i = 0; i < param_count - 1; i++){\ |
|
1018 TYPENAME tmp = va_arg (ap, VA_ARGS_##TYPENAME);\ |
|
1019 DBG_TYPE(TYPENAME, tmp)\ |
|
1020 if(COND){\ |
|
1021 op1 = tmp;\ |
|
1022 }else{\ |
|
1023 va_end (ap); /* Clean up. */\ |
|
1024 return 0;\ |
|
1025 }\ |
|
1026 }\ |
|
1027 \ |
|
1028 va_end (ap); /* Clean up. */\ |
|
1029 return 1;\ |
|
1030 } |
|
1031 |
|
1032 #define __compare_num(fname, TYPENAME, TEST) __compare_(fname, TYPENAME, op1 TEST tmp ) |
|
1033 #define __compare_time(fname, TYPENAME, TEST) __compare_(fname, TYPENAME, __time_cmp(op1, tmp) TEST 0) |
|
1034 #define __compare_string(fname, TEST) __compare_(fname, STRING, __STR_CMP(op1, tmp) TEST 0 ) |
|
1035 |
|
1036 |
|
1037 /**************/ |
|
1038 /* GT */ |
|
1039 /**************/ |
|
1040 /* Comparison for numerical data types */ |
|
1041 #define __iec_(TYPENAME) \ |
|
1042 __compare_num(GT_##TYPENAME, TYPENAME, > ) /* The explicitly typed standard functions */\ |
|
1043 __compare_num(GT__BOOL__##TYPENAME, TYPENAME, > ) /* Overloaded function */ |
|
1044 __ANY_NBIT(__iec_) |
|
1045 __ANY_NUM(__iec_) |
|
1046 #undef __iec_ |
|
1047 |
|
1048 /* Comparison for time data types */ |
|
1049 #define __iec_(TYPENAME) \ |
|
1050 __compare_time(GT_##TYPENAME, TYPENAME, > ) /* The explicitly typed standard functions */\ |
|
1051 __compare_time(GT__BOOL__##TYPENAME, TYPENAME, > ) /* Overloaded function */ |
|
1052 __ANY_DATE(__iec_) |
|
1053 __iec_(TIME) |
|
1054 #undef __iec_ |
|
1055 |
|
1056 /* Comparison for string data types */ |
|
1057 __compare_string(GT_STRING, > ) /* The explicitly typed standard functions */ |
|
1058 __compare_string(GT__BOOL__STRING, > ) /* Overloaded function */ |
|
1059 |
|
1060 /**************/ |
|
1061 /* GE */ |
|
1062 /**************/ |
|
1063 /* Comparison for numerical data types */ |
|
1064 #define __iec_(TYPENAME) \ |
|
1065 __compare_num(GE_##TYPENAME, TYPENAME, >= ) /* The explicitly typed standard functions */\ |
|
1066 __compare_num(GE__BOOL__##TYPENAME, TYPENAME, >= ) /* Overloaded function */ |
|
1067 __ANY_NBIT(__iec_) |
|
1068 __ANY_NUM(__iec_) |
|
1069 #undef __iec_ |
|
1070 |
|
1071 /* Comparison for time data types */ |
|
1072 #define __iec_(TYPENAME) \ |
|
1073 __compare_time(GE_##TYPENAME, TYPENAME, >= ) /* The explicitly typed standard functions */\ |
|
1074 __compare_time(GE__BOOL__##TYPENAME, TYPENAME, >= ) /* Overloaded function */ |
|
1075 __ANY_DATE(__iec_) |
|
1076 __iec_(TIME) |
|
1077 #undef __iec_ |
|
1078 |
|
1079 /* Comparison for string data types */ |
|
1080 __compare_string(GE_STRING, >= ) /* The explicitly typed standard functions */ |
|
1081 __compare_string(GE__BOOL__STRING, >= ) /* Overloaded function */ |
|
1082 |
|
1083 |
|
1084 |
|
1085 /**************/ |
|
1086 /* EQ */ |
|
1087 /**************/ |
|
1088 /* Comparison for numerical data types */ |
|
1089 #define __iec_(TYPENAME) \ |
|
1090 __compare_num(EQ_##TYPENAME, TYPENAME, == ) /* The explicitly typed standard functions */\ |
|
1091 __compare_num(EQ__BOOL__##TYPENAME, TYPENAME, == ) /* Overloaded function */ |
|
1092 __ANY_NBIT(__iec_) |
|
1093 __ANY_NUM(__iec_) |
|
1094 #undef __iec_ |
|
1095 |
|
1096 /* Comparison for time data types */ |
|
1097 #define __iec_(TYPENAME) \ |
|
1098 __compare_time(EQ_##TYPENAME, TYPENAME, == ) /* The explicitly typed standard functions */\ |
|
1099 __compare_time(EQ__BOOL__##TYPENAME, TYPENAME, == ) /* Overloaded function */ |
|
1100 __ANY_DATE(__iec_) |
|
1101 __iec_(TIME) |
|
1102 #undef __iec_ |
|
1103 |
|
1104 /* Comparison for string data types */ |
|
1105 __compare_string(EQ_STRING, == ) /* The explicitly typed standard functions */ |
|
1106 __compare_string(EQ__BOOL__STRING, == ) /* Overloaded function */ |
|
1107 |
|
1108 |
|
1109 /**************/ |
|
1110 /* LT */ |
|
1111 /**************/ |
|
1112 /* Comparison for numerical data types */ |
|
1113 #define __iec_(TYPENAME) \ |
|
1114 __compare_num(LT_##TYPENAME, TYPENAME, < ) /* The explicitly typed standard functions */\ |
|
1115 __compare_num(LT__BOOL__##TYPENAME, TYPENAME, < ) /* Overloaded function */ |
|
1116 __ANY_NBIT(__iec_) |
|
1117 __ANY_NUM(__iec_) |
|
1118 #undef __iec_ |
|
1119 |
|
1120 /* Comparison for time data types */ |
|
1121 #define __iec_(TYPENAME) \ |
|
1122 __compare_time(LT_##TYPENAME, TYPENAME, < ) /* The explicitly typed standard functions */\ |
|
1123 __compare_time(LT__BOOL__##TYPENAME, TYPENAME, < ) /* Overloaded function */ |
|
1124 __ANY_DATE(__iec_) |
|
1125 __iec_(TIME) |
|
1126 #undef __iec_ |
|
1127 |
|
1128 /* Comparison for string data types */ |
|
1129 __compare_string(LT_STRING, < ) /* The explicitly typed standard functions */ |
|
1130 __compare_string(LT__BOOL__STRING, < ) /* Overloaded function */ |
|
1131 |
|
1132 |
|
1133 /**************/ |
|
1134 /* LE */ |
|
1135 /**************/ |
|
1136 /* Comparison for numerical data types */ |
|
1137 #define __iec_(TYPENAME) \ |
|
1138 __compare_num(LE_##TYPENAME, TYPENAME, <= ) /* The explicitly typed standard functions */\ |
|
1139 __compare_num(LE__BOOL__##TYPENAME, TYPENAME, <= ) /* Overloaded function */ |
|
1140 __ANY_NBIT(__iec_) |
|
1141 __ANY_NUM(__iec_) |
|
1142 #undef __iec_ |
|
1143 |
|
1144 /* Comparison for time data types */ |
|
1145 #define __iec_(TYPENAME) \ |
|
1146 __compare_time(LE_##TYPENAME, TYPENAME, <= ) /* The explicitly typed standard functions */\ |
|
1147 __compare_time(LE__BOOL__##TYPENAME, TYPENAME, <= ) /* Overloaded function */ |
|
1148 __ANY_DATE(__iec_) |
|
1149 __iec_(TIME) |
|
1150 #undef __iec_ |
|
1151 |
|
1152 /* Comparison for string data types */ |
|
1153 __compare_string(LE_STRING, <= ) /* The explicitly typed standard functions */ |
|
1154 __compare_string(LE__BOOL__STRING, <= ) /* Overloaded function */ |
|
1155 |
|
1156 |
|
1157 /**************/ |
|
1158 /* NE */ |
|
1159 /**************/ |
|
1160 #define __ne_num(fname, TYPENAME) \ |
|
1161 static inline BOOL fname(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\ |
|
1162 TEST_EN(BOOL)\ |
|
1163 return op1 != op2 ? 1 : 0;\ |
|
1164 } |
|
1165 |
|
1166 #define __ne_time(fname, TYPENAME) \ |
|
1167 static inline BOOL fname(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\ |
|
1168 TEST_EN(BOOL)\ |
|
1169 return __time_cmp(op1, op2) != 0 ? 1 : 0;\ |
|
1170 } |
|
1171 |
|
1172 #define __ne_string(fname, TYPENAME) \ |
|
1173 static inline BOOL fname(EN_ENO_PARAMS, TYPENAME op1, TYPENAME op2){\ |
|
1174 TEST_EN(BOOL)\ |
|
1175 return __STR_CMP(op1, op2) != 0 ? 1 : 0;\ |
|
1176 } |
|
1177 |
|
1178 /* Comparison for numerical data types */ |
|
1179 #define __iec_(TYPENAME) \ |
|
1180 __ne_num(NE_##TYPENAME, TYPENAME) /* The explicitly typed standard functions */\ |
|
1181 __ne_num(NE__BOOL__##TYPENAME##__##TYPENAME, TYPENAME) /* Overloaded function */ |
|
1182 __ANY_NBIT(__iec_) |
|
1183 __ANY_NUM(__iec_) |
|
1184 #undef __iec_ |
|
1185 |
|
1186 /* Comparison for time data types */ |
|
1187 #define __iec_(TYPENAME) \ |
|
1188 __ne_time(NE_##TYPENAME, TYPENAME) /* The explicitly typed standard functions */\ |
|
1189 __ne_time(NE__BOOL__##TYPENAME##__##TYPENAME, TYPENAME) /* Overloaded function */ |
|
1190 __ANY_DATE(__iec_) |
|
1191 __iec_(TIME) |
|
1192 #undef __iec_ |
|
1193 |
|
1194 /* Comparison for string data types */ |
|
1195 __ne_string(NE_STRING, STRING) /* The explicitly typed standard functions */ |
|
1196 __ne_string(NE__BOOL__STRING__STRING, STRING) /* Overloaded function */ |
|
1197 |
|
1198 |
|
1199 |
|
1200 |
|
1201 |
|
1202 |
|
1203 /*********************************************/ |
|
1204 /*********************************************/ |
|
1205 /* 2.5.1.5.5 Character string Functions */ |
|
1206 /*********************************************/ |
|
1207 /*********************************************/ |
|
1208 |
|
1209 /*************************************/ |
|
1210 /*** Table 29 ***/ |
|
1211 /*** Character string Functions ***/ |
|
1212 /*************************************/ |
|
1213 |
|
1214 /* We do not delcare explcitly typed versions of the functions in table 29. |
|
1215 * See note above regarding explicitly typed functions for more details. |
|
1216 */ |
|
1217 |
|
1218 |
|
1219 |
|
1220 |
|
1221 /***************/ |
|
1222 /* LEN */ |
|
1223 /***************/ |
|
1224 static inline __strlen_t __len(STRING IN) {return IN.len;} |
|
1225 |
|
1226 /* A function, with 1 input paramter, implementing a generic OPERATION */ |
|
1227 #define __genoper_1p_(fname,ret_TYPENAME, par_TYPENAME, OPERATION) \ |
|
1228 static inline ret_TYPENAME fname(EN_ENO_PARAMS, par_TYPENAME par1){\ |
|
1229 TEST_EN(ret_TYPENAME)\ |
|
1230 return (ret_TYPENAME)OPERATION(par1);\ |
|
1231 } |
|
1232 |
|
1233 #define __iec_(TYPENAME) __genoper_1p_(LEN__##TYPENAME##__STRING, TYPENAME, STRING, __len) |
|
1234 __ANY_INT(__iec_) |
|
1235 #undef __iec_ |
|
1236 |
|
1237 |
|
1238 /****************/ |
|
1239 /* LEFT */ |
|
1240 /****************/ |
|
1241 |
|
1242 #define __left(TYPENAME) \ |
|
1243 static inline STRING LEFT__STRING__STRING__##TYPENAME(EN_ENO_PARAMS, STRING IN, TYPENAME L){\ |
|
1244 STRING res;\ |
|
1245 TEST_EN_COND(STRING, L < 0)\ |
|
1246 res = __INIT_STRING;\ |
|
1247 L = L < (TYPENAME)IN.len ? L : (TYPENAME)IN.len;\ |
|
1248 memcpy(&res.body, &IN.body, (size_t)L);\ |
|
1249 res.len = (__strlen_t)L;\ |
|
1250 return res;\ |
|
1251 } |
|
1252 __ANY_INT(__left) |
|
1253 |
|
1254 |
|
1255 /*****************/ |
|
1256 /* RIGHT */ |
|
1257 /*****************/ |
|
1258 |
|
1259 #define __right(TYPENAME) \ |
|
1260 static inline STRING RIGHT__STRING__STRING__##TYPENAME(EN_ENO_PARAMS, STRING IN, TYPENAME L){\ |
|
1261 STRING res;\ |
|
1262 TEST_EN_COND(STRING, L < 0)\ |
|
1263 res = __INIT_STRING;\ |
|
1264 L = L < (TYPENAME)IN.len ? L : (TYPENAME)IN.len;\ |
|
1265 memcpy(&res.body, &IN.body[(TYPENAME)IN.len - L], (size_t)L);\ |
|
1266 res.len = (__strlen_t)L;\ |
|
1267 return res;\ |
|
1268 } |
|
1269 __ANY_INT(__right) |
|
1270 |
|
1271 |
|
1272 /***************/ |
|
1273 /* MID */ |
|
1274 /***************/ |
|
1275 |
|
1276 #define __mid(TYPENAME) \ |
|
1277 static inline STRING MID__STRING__STRING__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, STRING IN, TYPENAME L, TYPENAME P){\ |
|
1278 STRING res;\ |
|
1279 TEST_EN_COND(STRING, L < 0 || P < 0)\ |
|
1280 res = __INIT_STRING;\ |
|
1281 if(P <= (TYPENAME)IN.len){\ |
|
1282 P -= 1; /* now can be used as [index]*/\ |
|
1283 L = L + P <= (TYPENAME)IN.len ? L : (TYPENAME)IN.len - P;\ |
|
1284 memcpy(&res.body, &IN.body[P] , (size_t)L);\ |
|
1285 res.len = (__strlen_t)L;\ |
|
1286 }\ |
|
1287 return res;\ |
|
1288 } |
|
1289 __ANY_INT(__mid) |
|
1290 |
|
1291 |
|
1292 /******************/ |
|
1293 /* CONCAT */ |
|
1294 /******************/ |
|
1295 |
|
1296 static inline STRING CONCAT(EN_ENO_PARAMS, UINT param_count, ...){ |
|
1297 UINT i; |
|
1298 STRING res; |
|
1299 va_list ap; |
|
1300 __strlen_t charcount; |
|
1301 TEST_EN(STRING) |
|
1302 charcount = 0; |
|
1303 res = __INIT_STRING; |
|
1304 |
|
1305 va_start (ap, param_count); /* Initialize the argument list. */ |
|
1306 |
|
1307 for (i = 0; i < param_count && charcount < STR_MAX_LEN; i++) |
|
1308 { |
|
1309 STRING tmp = va_arg(ap, STRING); |
|
1310 __strlen_t charrem = STR_MAX_LEN - charcount; |
|
1311 __strlen_t to_write = tmp.len > charrem ? charrem : tmp.len; |
|
1312 memcpy(&res.body[charcount], &tmp.body , to_write); |
|
1313 charcount += to_write; |
|
1314 } |
|
1315 |
|
1316 res.len = charcount; |
|
1317 |
|
1318 va_end (ap); /* Clean up. */ |
|
1319 return res; |
|
1320 } |
|
1321 |
|
1322 /******************/ |
|
1323 /* INSERT */ |
|
1324 /******************/ |
|
1325 |
|
1326 static inline STRING __insert(STRING IN1, STRING IN2, __strlen_t P){ |
|
1327 STRING res; |
|
1328 __strlen_t to_copy; |
|
1329 res = __INIT_STRING; |
|
1330 |
|
1331 to_copy = P > IN1.len ? IN1.len : P; |
|
1332 memcpy(&res.body, &IN1.body , to_copy); |
|
1333 P = res.len = to_copy; |
|
1334 |
|
1335 to_copy = IN2.len + res.len > STR_MAX_LEN ? STR_MAX_LEN - res.len : IN2.len; |
|
1336 memcpy(&res.body[res.len], &IN2.body , to_copy); |
|
1337 res.len += to_copy; |
|
1338 |
|
1339 to_copy = IN1.len - P < STR_MAX_LEN - res.len ? IN1.len - P : STR_MAX_LEN - res.len ; |
|
1340 memcpy(&res.body[res.len], &IN1.body[P] , to_copy); |
|
1341 res.len += to_copy; |
|
1342 |
|
1343 return res; |
|
1344 } |
|
1345 |
|
1346 #define __iec_(TYPENAME) \ |
|
1347 static inline STRING INSERT__STRING__STRING__STRING__##TYPENAME(EN_ENO_PARAMS, STRING str1, STRING str2, TYPENAME P){\ |
|
1348 TEST_EN_COND(STRING, P < 0)\ |
|
1349 return (STRING)__insert(str1,str2,(__strlen_t)P);\ |
|
1350 } |
|
1351 __ANY_INT(__iec_) |
|
1352 #undef __iec_ |
|
1353 |
|
1354 |
|
1355 /******************/ |
|
1356 /* DELETE */ |
|
1357 /******************/ |
|
1358 |
|
1359 static inline STRING __delete(STRING IN, __strlen_t L, __strlen_t P){ |
|
1360 STRING res; |
|
1361 __strlen_t to_copy; |
|
1362 res = __INIT_STRING; |
|
1363 |
|
1364 to_copy = P > IN.len ? IN.len : P-1; |
|
1365 memcpy(&res.body, &IN.body , to_copy); |
|
1366 P = res.len = to_copy; |
|
1367 |
|
1368 if( IN.len > P + L ){ |
|
1369 to_copy = IN.len - P - L; |
|
1370 memcpy(&res.body[res.len], &IN.body[P + L], to_copy); |
|
1371 res.len += to_copy; |
|
1372 } |
|
1373 |
|
1374 return res; |
|
1375 } |
|
1376 |
|
1377 #define __iec_(TYPENAME) \ |
|
1378 static inline STRING DELETE__STRING__STRING__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, STRING str, TYPENAME L, TYPENAME P){\ |
|
1379 TEST_EN_COND(STRING, L < 0 || P < 0)\ |
|
1380 return (STRING)__delete(str,(__strlen_t)L,(__strlen_t)P);\ |
|
1381 } |
|
1382 __ANY_INT(__iec_) |
|
1383 #undef __iec_ |
|
1384 |
|
1385 |
|
1386 /*******************/ |
|
1387 /* REPLACE */ |
|
1388 /*******************/ |
|
1389 |
|
1390 static inline STRING __replace(STRING IN1, STRING IN2, __strlen_t L, __strlen_t P){ |
|
1391 STRING res; |
|
1392 __strlen_t to_copy; |
|
1393 res = __INIT_STRING; |
|
1394 |
|
1395 to_copy = P > IN1.len ? IN1.len : P-1; |
|
1396 memcpy(&res.body, &IN1.body , to_copy); |
|
1397 P = res.len = to_copy; |
|
1398 |
|
1399 to_copy = IN2.len < L ? IN2.len : L; |
|
1400 |
|
1401 if( to_copy + res.len > STR_MAX_LEN ) |
|
1402 to_copy = STR_MAX_LEN - res.len; |
|
1403 |
|
1404 memcpy(&res.body[res.len], &IN2.body , to_copy); |
|
1405 res.len += to_copy; |
|
1406 |
|
1407 P += L; |
|
1408 if( res.len < STR_MAX_LEN && P < IN1.len) |
|
1409 { |
|
1410 to_copy = IN1.len - P; |
|
1411 memcpy(&res.body[res.len], &IN1.body[P] , to_copy); |
|
1412 res.len += to_copy; |
|
1413 } |
|
1414 |
|
1415 return res; |
|
1416 } |
|
1417 |
|
1418 #define __iec_(TYPENAME) \ |
|
1419 static inline STRING REPLACE__STRING__STRING__STRING__##TYPENAME##__##TYPENAME(EN_ENO_PARAMS, STRING str1, STRING str2, TYPENAME L, TYPENAME P){\ |
|
1420 TEST_EN_COND(STRING, L < 0 || P < 0)\ |
|
1421 return (STRING)__replace(str1,str2,(__strlen_t)L,(__strlen_t)P);\ |
|
1422 } |
|
1423 __ANY_INT(__iec_) |
|
1424 #undef __iec_ |
|
1425 |
|
1426 /****************/ |
|
1427 /* FIND */ |
|
1428 /****************/ |
|
1429 |
|
1430 static inline __strlen_t __pfind(STRING* IN1, STRING* IN2){ |
|
1431 UINT count1 = 0; /* offset of first matching char in IN1 */ |
|
1432 UINT count2 = 0; /* count of matching char */ |
|
1433 while(count1 + count2 < IN1->len && count2 < IN2->len) |
|
1434 { |
|
1435 if(IN1->body[count1 + count2] != IN2->body[count2]){ |
|
1436 count1 += count2 + 1; |
|
1437 count2 = 0; |
|
1438 } |
|
1439 else { |
|
1440 count2++; |
|
1441 } |
|
1442 } |
|
1443 return count2 == IN2->len -1 ? 0 : count1 + 1; |
|
1444 } |
|
1445 |
|
1446 #define __iec_(TYPENAME) \ |
|
1447 static inline TYPENAME FIND__##TYPENAME##__STRING__STRING(EN_ENO_PARAMS, STRING str1, STRING str2){\ |
|
1448 TEST_EN(TYPENAME)\ |
|
1449 return (TYPENAME)__pfind(&str1,&str2);\ |
|
1450 } |
|
1451 __ANY_INT(__iec_) |
|
1452 #undef __iec_ |
|
1453 |
|
1454 |
|
1455 /*********************************************/ |
|
1456 /*********************************************/ |
|
1457 /* 2.5.1.5.6 Functions of time data types */ |
|
1458 /*********************************************/ |
|
1459 /*********************************************/ |
|
1460 |
|
1461 /**************************************/ |
|
1462 /*** Table 30 ***/ |
|
1463 /*** Functions of time data types ***/ |
|
1464 /**************************************/ |
|
1465 |
|
1466 |
|
1467 static inline TIME ADD_TIME(EN_ENO_PARAMS, TIME IN1, TIME IN2){ |
|
1468 TEST_EN(TIME) |
|
1469 return __time_add(IN1, IN2); |
|
1470 } |
|
1471 |
|
1472 static inline TOD ADD_TOD_TIME(EN_ENO_PARAMS, TOD IN1, TIME IN2){ |
|
1473 TEST_EN(TOD) |
|
1474 return __time_add(IN1, IN2); |
|
1475 } |
|
1476 |
|
1477 static inline DT ADD_DT_TIME(EN_ENO_PARAMS, DT IN1, TIME IN2){ |
|
1478 TEST_EN(DT) |
|
1479 return __time_add(IN1, IN2); |
|
1480 } |
|
1481 |
|
1482 static inline TIME SUB_TIME(EN_ENO_PARAMS, TIME IN1, TIME IN2){ |
|
1483 TEST_EN(TIME) |
|
1484 return __time_sub(IN1, IN2); |
|
1485 } |
|
1486 |
|
1487 static inline TIME SUB_DATE_DATE(EN_ENO_PARAMS, DATE IN1, DATE IN2){ |
|
1488 TEST_EN(TIME) |
|
1489 return __time_sub(IN1, IN2); |
|
1490 } |
|
1491 |
|
1492 static inline TOD SUB_TOD_TIME(EN_ENO_PARAMS, TOD IN1, TIME IN2){ |
|
1493 TEST_EN(TOD) |
|
1494 return __time_sub(IN1, IN2); |
|
1495 } |
|
1496 |
|
1497 static inline TIME SUB_TOD_TOD(EN_ENO_PARAMS, TOD IN1, TOD IN2){ |
|
1498 TEST_EN(TIME) |
|
1499 return __time_sub(IN1, IN2); |
|
1500 } |
|
1501 |
|
1502 static inline DT SUB_DT_TIME(EN_ENO_PARAMS, DT IN1, TIME IN2){ |
|
1503 TEST_EN(DT) |
|
1504 return __time_sub(IN1, IN2); |
|
1505 } |
|
1506 |
|
1507 static inline TIME SUB_DT_DT(EN_ENO_PARAMS, DT IN1, DT IN2){ |
|
1508 TEST_EN(TIME) |
|
1509 return __time_sub(IN1, IN2); |
|
1510 } |
|
1511 |
|
1512 |
|
1513 /*** MULTIME ***/ |
|
1514 #define __iec_(TYPENAME)\ |
|
1515 static inline TIME MULTIME__TIME__TIME__##TYPENAME(EN_ENO_PARAMS, TIME IN1, TYPENAME IN2){\ |
|
1516 TEST_EN(TIME)\ |
|
1517 return __time_mul(IN1, (LREAL)IN2);\ |
|
1518 } |
|
1519 __ANY_NUM(__iec_) |
|
1520 #undef __iec_ |
|
1521 |
|
1522 /*** MUL ***/ |
|
1523 #define __iec_(TYPENAME)\ |
|
1524 static inline TIME MUL__TIME__TIME__##TYPENAME(EN_ENO_PARAMS, TIME IN1, TYPENAME IN2){\ |
|
1525 TEST_EN(TIME)\ |
|
1526 return __time_mul(IN1, (LREAL)IN2);\ |
|
1527 } |
|
1528 __ANY_NUM(__iec_) |
|
1529 #undef __iec_ |
|
1530 |
|
1531 /*** DIVTIME ***/ |
|
1532 #define __iec_(TYPENAME)\ |
|
1533 static inline TIME DIVTIME__TIME__TIME__##TYPENAME(EN_ENO_PARAMS, TIME IN1, TYPENAME IN2){\ |
|
1534 TEST_EN(TIME)\ |
|
1535 return __time_div(IN1, (LREAL)IN2);\ |
|
1536 } |
|
1537 __ANY_NUM(__iec_) |
|
1538 #undef __iec_ |
|
1539 |
|
1540 /*** DIV ***/ |
|
1541 #define __iec_(TYPENAME)\ |
|
1542 static inline TIME DIV__TIME__TIME__##TYPENAME(EN_ENO_PARAMS, TIME IN1, TYPENAME IN2){\ |
|
1543 TEST_EN(TIME)\ |
|
1544 return __time_div(IN1, (LREAL)IN2);\ |
|
1545 } |
|
1546 __ANY_NUM(__iec_) |
|
1547 #undef __iec_ |
|
1548 |
|
1549 /*** CONCAT_DATE_TOD ***/ |
|
1550 static inline DT CONCAT_DATE_TOD(EN_ENO_PARAMS, DATE IN1, TOD IN2){ |
|
1551 TEST_EN(DT) |
|
1552 return __time_add(IN1, IN2); |
|
1553 } |
|
1554 |
|
1555 |
|
1556 |
|
1557 /****************************************************/ |
|
1558 /****************************************************/ |
|
1559 /* 2.5.1.5.6 Functions of enumerated data types */ |
|
1560 /****************************************************/ |
|
1561 /****************************************************/ |
|
1562 |
|
1563 /********************************************/ |
|
1564 /*** Table 31 ***/ |
|
1565 /*** Functions of enumerated data types ***/ |
|
1566 /********************************************/ |
|
1567 |
|
1568 /* Do we support this? */ |
|
1569 |
|
1570 |
|
1571 |
|
1572 |
|
1573 |
|
1574 |
|
1575 |
|
1576 |
|
1577 #endif /* _IEC_STD_FUNCTIONS_H */ |