Open Core Interface - MLPI
MLPI-MotionLogicProgrammingInterface(mlpiCore)  1.26.2
mlpiParameterHelper.h
Go to the documentation of this file.
1 #ifndef __MLPIPARAMETERHELPER_H__
2 #define __MLPIPARAMETERHELPER_H__
3 
4 // -----------------------------------------------------------------------
5 // MLPI - <mlpiParameterHelper.h>
6 // -----------------------------------------------------------------------
7 // Copyright (c) 2013 Bosch Rexroth. All rights reserved.
8 // Redistribution and use in source and binary forms of this MLPI software
9 // (SW) provided to you, with or without modification, are permitted
10 // without prior approval provided that the following conditions are met:
11 //
12 // 1. Redistributions of source code of SW must retain the above copyright
13 // notice, this list of conditions and the following disclaimer.
14 //
15 // 2. Redistributions in binary form of SW must reproduce the above copyright
16 // notice, this list of conditions and the following disclaimer in the
17 // documentation and/or other materials provided with the distribution.
18 //
19 // 3. User recognizes and acknowledges that it acquires no right,
20 // title or interest in or to any of the names or trademarks used in
21 // connection with the SW ("names") by virtue of this License and waives
22 // any right to or interest in the names. User recognizes and acknowledges
23 // that names of companies or names or products of companies displayed
24 // in the documentation of SW to indicate the interoperability of products
25 // with the SW are the names of their respective owners. The use of such
26 // names in the documentation of SW does not imply any sponsorship,
27 // approval, or endorsement by such companies of this product.
28 //
29 // 4. Modified code versions, i.e. any addition to or deletion from
30 // the substance or structure of the original code of the SW running
31 // the MLPI must be plainly marked as such and must not be misrepresented
32 // as being original SW.
33 //
34 // 5. The SW may only be used in connection with a Bosch Rexroth product.
35 //
36 // THIS INFORMATION IS PROVIDED BY BOSCH REXROTH CORPORATION "AS IS"
37 // AND WITHOUT WARRANTY OF ANY KIND, EXPRESSED OR IMPLIED, INCLUDING
38 // (BUT NOTLIMITED TO) ANY IMPLIED WARRANTIES OF MERCHANTABILITY,
39 // FITNESS FOR ANY PARTICULAR PURPOSE, OR NON-INFRINGEMENT. WHILE THE
40 // INFORMATION PROVIDED IS BELIEVED TO BE ACCURATE, IT MAY INCLUDE
41 // ERRORS OR INACCURACIES.
42 // SUBJECT TO COMPULSORY STATUTORY PROVISIONS OF THE GERMAN LAW AS
43 // THE APPLICABLE LAW FOR THIS LICENSE BOSCH REXROTH CORPORATION WILL
44 // NOT BE LIABLE FOR ANY DAMAGES OF ANY KIND ARISING FROM THE USE OF
45 // THE SOFTWARE DISTRIBUTED HEREUNDER, INCLUDING BUT NOT LIMITED TO
46 // DIRECT, INDIRECT, INCIDENTAL, PUNITIVE, AND CONSEQUENTIAL DAMAGES.
47 // -----------------------------------------------------------------------
48 //
58 //
59 // -----------------------------------------------------------------------
60 
61 
62 
63 
77 
78 
79 
80 // -----------------------------------------------------------------------
81 // GLOBAL INCLUDES
82 // -----------------------------------------------------------------------
83 #include <stdlib.h>
84 #include <stdio.h>
85 #include <time.h>
86 
87 #include "mlpiGlobal.h"
88 #include "wchar16.h"
89 
90 #include "mlpiParameterLib.h"
91 
92 // -----------------------------------------------------------------------
93 // GLOBAL CONSTANTS
94 // -----------------------------------------------------------------------
95 #define MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE (128)
96 
97 const CHAR MLPI_VALUE_SEPARATOR_UTF8 = ' ';
98 const WCHAR16 MLPI_VALUE_SEPARATOR_UTF16 = (WCHAR16) MLPI_VALUE_SEPARATOR_UTF8;
99 const WCHAR16 MLPI_BOOLEAN_VALUE_TRUE[] = { 'T', 'R', 'U', 'E', '\0' };
100 const WCHAR16 MLPI_BOOLEAN_VALUE_FALSE[] = { 'F', 'A', 'L', 'S', 'E', '\0' };
101 const ULONG MLPI_SIZEOF_BOOLEAN_VALUE_TRUE = sizeof(MLPI_BOOLEAN_VALUE_TRUE);
102 const ULONG MLPI_SIZEOF_BOOLEAN_VALUE_FALSE = sizeof(MLPI_BOOLEAN_VALUE_FALSE);
103 
104 
105 #define PARAM_MAX_NUMBER_PARAMETER (4096)
106 #define PARAM_LIST_ALL_C MLPI_SIDN_C(110)
107 #define PARAM_LIST_ALL_A MLPI_SIDN_A(10)
108 #define PARAM_LIST_ALL_K MLPI_SIDN_K(10)
109 #define PARAM_LIST_ALL_O MLPI_SIDN_O(10)
110 #define PARAM_LIST_ALL_M MLPI_SIDN_M(10)
111 #define PARAM_LIST_ALL_N MLPI_SIDN_N(10)
112 #define PARAM_LIST_ALL_SP MLPI_SIDN_S(17)
113 
114 
115 // Sercos formated attribute
116 // +-------------+-----+---+---+---+---+----+----+----+----+----+----+
117 // | | List| | D| F| | SLL| ULL| SL| UL| SS| US|
118 // +-------------+-----+---+---+---+---+----+----+----+----+----+----+
119 // 31 14 13 11 10 9 6 5 4 3 2 1 0
120 
121 
122 #define PARAM_ATTR_DATA_TYPE ( 0x00700000 ) // data type and display format mask (Bit 20-22)
123 #define PARAM_ATTR_DATA_TYPE_BINARY ( 0x00000000 )
124 #define PARAM_ATTR_DATA_TYPE_UINT_DEC ( 0x00100000 )
125 #define PARAM_ATTR_DATA_TYPE_INT_DEC ( 0x00200000 )
126 #define PARAM_ATTR_DATA_TYPE_UINT_HEX ( 0x00300000 )
127 #define PARAM_ATTR_DATA_TYPE_TEXT ( 0x00400000 )
128 #define PARAM_ATTR_DATA_TYPE_UINT_IDN ( 0x00500000 )
129 #define PARAM_ATTR_DATA_TYPE_FLOAT ( 0x00600000 )
130 #define PARAM_ATTR_DATA_TYPE_MLC_IDN ( 0x00700000 )
131 
132 #define PARAM_ATTR_DATA_LENGTH ( 0x00070000 ) // data length mask (Bit 16-18)
133 #define PARAM_ATTR_DATA_LENGTH_1BYTE ( 0x00000000 )
134 #define PARAM_ATTR_DATA_LENGTH_2BYTE ( 0x00010000 )
135 #define PARAM_ATTR_DATA_LENGTH_4BYTE ( 0x00020000 )
136 #define PARAM_ATTR_DATA_LENGTH_8BYTE ( 0x00030000 )
137 #define PARAM_ATTR_DATA_LENGTH_1BYTE_VAR ( 0x00040000 )
138 #define PARAM_ATTR_DATA_LENGTH_2BYTE_VAR ( 0x00050000 )
139 #define PARAM_ATTR_DATA_LENGTH_4BYTE_VAR ( 0x00060000 )
140 #define PARAM_ATTR_DATA_LENGTH_8BYTE_VAR ( 0x00070000 )
141 #define PARAM_ATTR_DATA_LENGTH_LIST ( 0x00040000 )
142 #define PARAM_ATTR_DATA_LENGTH_NO_LIST ( 0x00030000 )
143 
144 #define PARAM_ATTR_FUNCTION ( 0x00080000 ) // function mask (Bit 19)
145 #define PARAM_ATTR_FUNCTION_PARAMETER ( 0x00000000 ) // parameter
146 #define PARAM_ATTR_FUNCTION_COMMAND ( 0x00080000 ) // command
147 
148 #define PARAM_ATTR_DECIMAL_POINT ( 0x0F000000 ) // decimal point mask (Bit 24-27)
149 #define PARAM_ATTR_DECIMAL_POINT_00PLACES ( 0x00000000 )
150 #define PARAM_ATTR_DECIMAL_POINT_01PLACES ( 0x01000000 )
151 #define PARAM_ATTR_DECIMAL_POINT_02PLACES ( 0x02000000 )
152 #define PARAM_ATTR_DECIMAL_POINT_03PLACES ( 0x03000000 )
153 #define PARAM_ATTR_DECIMAL_POINT_04PLACES ( 0x04000000 )
154 #define PARAM_ATTR_DECIMAL_POINT_05PLACES ( 0x05000000 )
155 #define PARAM_ATTR_DECIMAL_POINT_06PLACES ( 0x06000000 )
156 #define PARAM_ATTR_DECIMAL_POINT_07PLACES ( 0x07000000 )
157 #define PARAM_ATTR_DECIMAL_POINT_08PLACES ( 0x08000000 )
158 #define PARAM_ATTR_DECIMAL_POINT_09PLACES ( 0x09000000 )
159 #define PARAM_ATTR_DECIMAL_POINT_10PLACES ( 0x0A000000 )
160 #define PARAM_ATTR_DECIMAL_POINT_11PLACES ( 0x0B000000 )
161 #define PARAM_ATTR_DECIMAL_POINT_12PLACES ( 0x0C000000 )
162 #define PARAM_ATTR_DECIMAL_POINT_13PLACES ( 0x0D000000 )
163 #define PARAM_ATTR_DECIMAL_POINT_14PLACES ( 0x0E000000 )
164 #define PARAM_ATTR_DECIMAL_POINT_15PLACES ( 0x0F000000 )
165 
166 #define PARAM_ATTR_WRITE_PROTECTION ( 0x70000000 ) // write protection mask (Bit 28-30)
167 #define PARAM_ATTR_WRITE_PROTECTION_NONE ( 0x00000000 ) // write protected none, writeable P0..P4
168 #define PARAM_ATTR_WRITE_PROTECTION_P0_P1_P2 ( 0x10000000 ) // write protected in P0..P2, writeable P3..P4
169 #define PARAM_ATTR_WRITE_PROTECTION_P3 ( 0x20000000 ) // write protected in P3, writeable P0..2, P4 (do not use, use NONE instead!)
170 #define PARAM_ATTR_WRITE_PROTECTION_P0_P1_P2_P3 ( 0x30000000 ) // write protected in P0..P3, writeable P4 (do not use, use P0_P1_P2 instead!)
171 #define PARAM_ATTR_WRITE_PROTECTION_P4 ( 0x40000000 ) // write protected in P4, writeable P0..P3 (do not use, use P3_P4 instead!)
172 #define PARAM_ATTR_WRITE_PROTECTION_P0_P1_P2_P4 ( 0x50000000 ) // write protected in P0..P2, P4, writeable P3 (do not use, use READ_ONLY instead!)
173 #define PARAM_ATTR_WRITE_PROTECTION_P3_P4 ( 0x60000000 ) // write protected in P3..P4, writeable P0..P2
174 #define PARAM_ATTR_WRITE_PROTECTION_READ_ONLY ( 0x70000000 ) // write protected in P0..P4, writeable none
175 
176 #define PARAM_MAX_IDN_STRING_LENGTH ( 24 )
177 #define PARAM_SERCOS_TIME_STRING_LENGTH ( 31 )
178 
179 typedef enum ParamWriteProtection
180 {
181  PARAM_WRITE_PROTECTION_NONE = 0,
182  PARAM_WRITE_PROTECTION_P0_P1_P2 = 1,
183  PARAM_WRITE_PROTECTION_P3 = 2,
184  PARAM_WRITE_PROTECTION_P0_P1_P2_P3 = 3,
185  PARAM_WRITE_PROTECTION_P4 = 4,
186  PARAM_WRITE_PROTECTION_P0_P1_P2_P4 = 5,
187  PARAM_WRITE_PROTECTION_P3_P4 = 6,
188  PARAM_WRITE_PROTECTION_READ_ONLY = 7
189 }ParamWriteProtection;
190 
191 // -----------------------------------------------------------------------
192 // GLOBAL MACROS
193 // -----------------------------------------------------------------------
194 #define PARAM_ATTR_IS_TYPE_CHAR(a) \
195  ( ( (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_INT_DEC) ) && \
196  (((a) & PARAM_ATTR_DATA_LENGTH_NO_LIST) == PARAM_ATTR_DATA_LENGTH_1BYTE) )
197 
198 #define PARAM_ATTR_IS_TYPE_UCHAR(a) \
199  ( ( (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_UINT_DEC) || \
200  (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_UINT_HEX) || \
201  (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_BINARY) ) && \
202  (((a) & PARAM_ATTR_DATA_LENGTH_NO_LIST) == PARAM_ATTR_DATA_LENGTH_1BYTE) )
203 
204 #define PARAM_ATTR_IS_TYPE_SHORT(a) \
205  ( ( (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_INT_DEC) ) && \
206  (((a) & PARAM_ATTR_DATA_LENGTH_NO_LIST) == PARAM_ATTR_DATA_LENGTH_2BYTE) )
207 
208 #define PARAM_ATTR_IS_TYPE_USHORT(a) \
209  ( ( (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_UINT_DEC) || \
210  (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_UINT_HEX) || \
211  (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_UINT_IDN) || \
212  (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_BINARY) ) && \
213  (((a) & PARAM_ATTR_DATA_LENGTH_NO_LIST) == PARAM_ATTR_DATA_LENGTH_2BYTE) )
214 
215 #define PARAM_ATTR_IS_TYPE_LONG(a) \
216  ( ( (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_INT_DEC) ) && \
217  (((a) & PARAM_ATTR_DATA_LENGTH_NO_LIST) == PARAM_ATTR_DATA_LENGTH_4BYTE) )
218 
219 #define PARAM_ATTR_IS_TYPE_ULONG(a) \
220  ( ( (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_UINT_DEC) || \
221  (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_UINT_HEX) || \
222  (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_UINT_IDN) || \
223  (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_MLC_IDN) || \
224  (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_BINARY) ) && \
225  (((a) & PARAM_ATTR_DATA_LENGTH_NO_LIST) == PARAM_ATTR_DATA_LENGTH_4BYTE) )
226 
227 #define PARAM_ATTR_IS_TYPE_LLONG(a) \
228  ( ( (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_INT_DEC) ) && \
229  (((a) & PARAM_ATTR_DATA_LENGTH_NO_LIST) == PARAM_ATTR_DATA_LENGTH_8BYTE) )
230 
231 #define PARAM_ATTR_IS_TYPE_ULLONG(a) \
232  ( ( (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_UINT_DEC) || \
233  (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_UINT_HEX) || \
234  (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_MLC_IDN) || \
235  (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_BINARY) ) && \
236  (((a) & PARAM_ATTR_DATA_LENGTH_NO_LIST) == PARAM_ATTR_DATA_LENGTH_8BYTE) )
237 
238 #define PARAM_ATTR_IS_TYPE_FLOAT(a) \
239  ( ( (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_FLOAT) ) && \
240  (((a) & PARAM_ATTR_DATA_LENGTH_NO_LIST) == PARAM_ATTR_DATA_LENGTH_4BYTE) )
241 
242 #define PARAM_ATTR_IS_TYPE_DOUBLE(a) \
243  ( ( (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_FLOAT) ) && \
244  (((a) & PARAM_ATTR_DATA_LENGTH_NO_LIST) == PARAM_ATTR_DATA_LENGTH_8BYTE) )
245 
246 #define PARAM_ATTR_IS_TYPE_STRING(a) \
247  ( ( (((a) & PARAM_ATTR_DATA_TYPE) == PARAM_ATTR_DATA_TYPE_TEXT) ) && \
248  (((a) & PARAM_ATTR_DATA_LENGTH) == PARAM_ATTR_DATA_LENGTH_1BYTE_VAR) )
249 
250 #define PARAM_ATTR_IS_FIXED_LENGTH(a) \
251  ( (((a) & PARAM_ATTR_DATA_LENGTH) == PARAM_ATTR_DATA_LENGTH_1BYTE) || \
252  (((a) & PARAM_ATTR_DATA_LENGTH) == PARAM_ATTR_DATA_LENGTH_2BYTE) || \
253  (((a) & PARAM_ATTR_DATA_LENGTH) == PARAM_ATTR_DATA_LENGTH_4BYTE) || \
254  (((a) & PARAM_ATTR_DATA_LENGTH) == PARAM_ATTR_DATA_LENGTH_8BYTE) )
255 
256 #define PARAM_ATTR_IS_VARIABLE_LENGTH(a) ( !PARAM_ATTR_IS_FIXED_LENGTH(a) )
257 
258 
259 
260 // -----------------------------------------------------------------------
261 // GLOBAL FUNCTIONS
262 // -----------------------------------------------------------------------
263 inline MLPIRESULT utilParameterCheckAttributeSigned(ULONG attribute, ULONG errorCode)
264 {
265  MLPIRESULT mlpiResult = MLPI_S_OK;
266  switch(attribute & PARAM_ATTR_DATA_TYPE)
267  {
268  case PARAM_ATTR_DATA_TYPE_INT_DEC: mlpiResult = MLPI_S_OK; break;
269  default: mlpiResult = errorCode; break;
270  }
271  return mlpiResult;
272 }
273 
274 inline MLPIRESULT utilParameterCheckAttributeUnsigned(ULONG attribute, ULONG errorCode)
275 {
276  MLPIRESULT mlpiResult = MLPI_S_OK;
277  switch(attribute & PARAM_ATTR_DATA_TYPE)
278  {
279  case PARAM_ATTR_DATA_TYPE_BINARY: mlpiResult = MLPI_S_OK; break;
280  case PARAM_ATTR_DATA_TYPE_UINT_DEC: mlpiResult = MLPI_S_OK; break;
281  case PARAM_ATTR_DATA_TYPE_UINT_HEX: mlpiResult = MLPI_S_OK; break;
282  case PARAM_ATTR_DATA_TYPE_UINT_IDN: mlpiResult = MLPI_S_OK; break;
283  case PARAM_ATTR_DATA_TYPE_MLC_IDN: mlpiResult = MLPI_S_OK; break;
284  default: mlpiResult = errorCode; break;
285  }
286  return mlpiResult;
287 }
288 
289 inline MLPIRESULT utilParameterCheckAttributeFloat(ULONG attribute, ULONG errorCode)
290 {
291  MLPIRESULT mlpiResult = MLPI_S_OK;
292  switch(attribute & PARAM_ATTR_DATA_TYPE)
293  {
294  case PARAM_ATTR_DATA_TYPE_FLOAT: mlpiResult = MLPI_S_OK; break;
295  default: mlpiResult = errorCode; break;
296  }
297  return mlpiResult;
298 }
299 
300 inline MLPIRESULT utilParameterCheckAttributeText(ULONG attribute, ULONG errorCode)
301 {
302  MLPIRESULT mlpiResult = MLPI_S_OK;
303  switch(attribute & PARAM_ATTR_DATA_TYPE)
304  {
305  case PARAM_ATTR_DATA_TYPE_TEXT: mlpiResult = MLPI_S_OK; break;
306  default: mlpiResult = errorCode; break;
307  }
308  return mlpiResult;
309 }
310 
400 inline MlpiType utilParameterGetDataTypeFromAttribute(const ULONG attribute)
401 {
402  MlpiType type = MLPI_TYPE_INVALID;
403 
404  if (PARAM_ATTR_IS_VARIABLE_LENGTH(attribute))
405  {
406  if (PARAM_ATTR_IS_TYPE_UCHAR(attribute))
407  type = MLPI_TYPE_UCHAR_ARRAY;
408  if (PARAM_ATTR_IS_TYPE_USHORT(attribute))
409  type = MLPI_TYPE_USHORT_ARRAY;
410  if (PARAM_ATTR_IS_TYPE_SHORT(attribute))
411  type = MLPI_TYPE_SHORT_ARRAY;
412  if (PARAM_ATTR_IS_TYPE_ULONG(attribute))
413  type = MLPI_TYPE_ULONG_ARRAY;
414  if (PARAM_ATTR_IS_TYPE_LONG(attribute))
415  type = MLPI_TYPE_LONG_ARRAY;
416  if (PARAM_ATTR_IS_TYPE_ULLONG(attribute))
417  type = MLPI_TYPE_ULLONG_ARRAY;
418  if (PARAM_ATTR_IS_TYPE_LLONG(attribute))
419  type = MLPI_TYPE_LLONG_ARRAY;
420  if (PARAM_ATTR_IS_TYPE_FLOAT(attribute))
421  type = MLPI_TYPE_FLOAT_ARRAY;
422  if (PARAM_ATTR_IS_TYPE_DOUBLE(attribute))
423  type = MLPI_TYPE_DOUBLE_ARRAY;
424  if (PARAM_ATTR_IS_TYPE_STRING(attribute))
425  type = MLPI_TYPE_CHAR_UTF16;
426  }
427  else
428  {
429  if (PARAM_ATTR_IS_TYPE_UCHAR(attribute))
430  type = MLPI_TYPE_UCHAR;
431  if (PARAM_ATTR_IS_TYPE_CHAR(attribute))
432  type = MLPI_TYPE_CHAR;
433  if (PARAM_ATTR_IS_TYPE_USHORT(attribute))
434  type = MLPI_TYPE_USHORT;
435  if (PARAM_ATTR_IS_TYPE_SHORT(attribute))
436  type = MLPI_TYPE_SHORT;
437  if (PARAM_ATTR_IS_TYPE_ULONG(attribute))
438  type = MLPI_TYPE_ULONG;
439  if (PARAM_ATTR_IS_TYPE_LONG(attribute))
440  type = MLPI_TYPE_LONG;
441  if (PARAM_ATTR_IS_TYPE_ULLONG(attribute))
442  type = MLPI_TYPE_ULLONG;
443  if (PARAM_ATTR_IS_TYPE_LLONG(attribute))
444  type = MLPI_TYPE_LLONG;
445  if (PARAM_ATTR_IS_TYPE_FLOAT(attribute))
446  type = MLPI_TYPE_FLOAT;
447  if (PARAM_ATTR_IS_TYPE_DOUBLE(attribute))
448  type = MLPI_TYPE_DOUBLE;
449  if (PARAM_ATTR_IS_TYPE_STRING(attribute))
450  type = MLPI_TYPE_CHAR_UTF16;
451  }
452  return type;
453 }
454 
455 #define PARAM_ADD_ELEMENT_TO_SIDN(sidn, element) ( (ULLONG)( \
456  ((ULLONG)sidn) | \
457  ((ULLONG)(element & (SZ_PSP_ELEMENT-1)) << 40) ))
458 
463 inline BOOL8 utilParameterGetProcedureCmdFromAttribute(const ULONG attribute)
464 {
465  BOOL8 cmd = false;
466  switch (attribute & PARAM_ATTR_FUNCTION)
467  {
468  case PARAM_ATTR_FUNCTION_PARAMETER: cmd = false; break;
469  case PARAM_ATTR_FUNCTION_COMMAND: cmd = true; break;
470  }
471  return cmd;
472 }
473 
478 inline SHORT utilParameterGetDecimalPointFromAttribute(const ULONG attribute)
479 {
480  SHORT decimalPoint = 0;
481  switch (attribute & PARAM_ATTR_DECIMAL_POINT)
482  {
483  case PARAM_ATTR_DECIMAL_POINT_00PLACES: decimalPoint = 0; break;
484  case PARAM_ATTR_DECIMAL_POINT_01PLACES: decimalPoint = 1; break;
485  case PARAM_ATTR_DECIMAL_POINT_02PLACES: decimalPoint = 2; break;
486  case PARAM_ATTR_DECIMAL_POINT_03PLACES: decimalPoint = 3; break;
487  case PARAM_ATTR_DECIMAL_POINT_04PLACES: decimalPoint = 4; break;
488  case PARAM_ATTR_DECIMAL_POINT_05PLACES: decimalPoint = 5; break;
489  case PARAM_ATTR_DECIMAL_POINT_06PLACES: decimalPoint = 6; break;
490  case PARAM_ATTR_DECIMAL_POINT_07PLACES: decimalPoint = 7; break;
491  case PARAM_ATTR_DECIMAL_POINT_08PLACES: decimalPoint = 8; break;
492  case PARAM_ATTR_DECIMAL_POINT_09PLACES: decimalPoint = 9; break;
493  case PARAM_ATTR_DECIMAL_POINT_10PLACES: decimalPoint = 10; break;
494  case PARAM_ATTR_DECIMAL_POINT_11PLACES: decimalPoint = 11; break;
495  case PARAM_ATTR_DECIMAL_POINT_12PLACES: decimalPoint = 12; break;
496  case PARAM_ATTR_DECIMAL_POINT_13PLACES: decimalPoint = 13; break;
497  case PARAM_ATTR_DECIMAL_POINT_14PLACES: decimalPoint = 14; break;
498  case PARAM_ATTR_DECIMAL_POINT_15PLACES: decimalPoint = 15; break;
499  }
500  return decimalPoint;
501 }
502 
507 inline ParamWriteProtection utilParameterGetWriteProtectionFromAttribute(const ULONG attribute)
508 {
509  ParamWriteProtection writeProtection = (ParamWriteProtection)PARAM_ATTR_WRITE_PROTECTION_READ_ONLY;
510  switch (attribute & PARAM_ATTR_WRITE_PROTECTION)
511  {
512  case PARAM_ATTR_WRITE_PROTECTION_NONE: writeProtection = PARAM_WRITE_PROTECTION_NONE; break;
513  case PARAM_ATTR_WRITE_PROTECTION_P0_P1_P2: writeProtection = PARAM_WRITE_PROTECTION_P0_P1_P2; break;
514  case PARAM_ATTR_WRITE_PROTECTION_P3: writeProtection = PARAM_WRITE_PROTECTION_P3; break;
515  case PARAM_ATTR_WRITE_PROTECTION_P0_P1_P2_P3: writeProtection = PARAM_WRITE_PROTECTION_P0_P1_P2_P3; break;
516  case PARAM_ATTR_WRITE_PROTECTION_P4: writeProtection = PARAM_WRITE_PROTECTION_P4; break;
517  case PARAM_ATTR_WRITE_PROTECTION_P0_P1_P2_P4: writeProtection = PARAM_WRITE_PROTECTION_P0_P1_P2_P4; break;
518  case PARAM_ATTR_WRITE_PROTECTION_P3_P4: writeProtection = PARAM_WRITE_PROTECTION_P3_P4; break;
519  case PARAM_ATTR_WRITE_PROTECTION_READ_ONLY: writeProtection = PARAM_WRITE_PROTECTION_READ_ONLY; break;
520  }
521  return writeProtection;
522 }
523 
524 // -----------------------------------------------------------------------
525 // GLOBAL EXPORTS
526 // -----------------------------------------------------------------------
527 
528 
529 
542 inline MLPIRESULT utilParameterParseIdn(const WCHAR16 *idn, ULONG *address, ULLONG *type, ULLONG *set, ULLONG *block, ULLONG *si, ULLONG *se, WCHAR16 **idnNxt=NULL)
543 {
544  ULONG _address=0;
545  ULLONG _type=0, _set=0, _block=0, _si=0, _se=0;
546  ULONG i=0;
547 
548  // parse index/address if available
549  if (wcschr16(&idn[i], L':')!=NULL)
550  {
551  while( !(((idn[i]>='0') && (idn[i]<='9')) || (idn[i]==L':')) )
552  i++;
553 
554  _address = wtoi16(&idn[i]);
555 
556  while( !(idn[i]==L':') )
557  i++;
558 
559  i++;
560  }
561 
562  // parse type, this information is always necessary
563  switch (idn[i])
564  {
565  case 'A':
566  case 'a':
567  _type = MLPI_SIDN_TYPE_AXIS;
568  break;
569  case 'C':
570  case 'c':
571  _type = MLPI_SIDN_TYPE_CONTROL;
572  break;
573  case 'K':
574  case 'k':
575  _type = MLPI_SIDN_TYPE_KINEMATIC;
576  break;
577  case 'M':
578  case 'm':
579  _type = MLPI_SIDN_TYPE_PROBE;
580  break;
581  case 'N':
582  case 'n':
583  _type = MLPI_SIDN_TYPE_POSLIMSWITCH;
584  break;
585  case 'O':
586  case 'o':
587  _type = MLPI_SIDN_TYPE_OSCILLOSCOPE;
588  break;
589  case 'P':
590  case 'p':
591  _type = MLPI_SIDN_TYPE_DRIVE_P;
592  break;
593  case 'S':
594  case 's':
595  _type = MLPI_SIDN_TYPE_DRIVE_S;
596  break;
597  default:
598  return MLPI_E_INVALIDARG;
599  }
600  i++;
601 
602  // parse block for special case, when only a caracter and number is given
603  if ( (wcslen16(&idn[i])>=1) && (idn[i+0]!='-') && (idn[i+0]>='0') && (idn[i+0]<='9') )
604  {
605  _block = wtoi16(&idn[i+0]);
606  i++;
607  while( (idn[i]>='0') && (idn[i]<='9') )
608  i++;
609  }
610 
611  // parse set, this info is optional
612  if ( (wcslen16(&idn[i])>=3) && (idn[i+0]=='-') && (idn[i+1]>='0') && (idn[i+1]<='7') && (idn[i+2]=='-') )
613  {
614  _set = idn[i+1] - '0';
615  i+=2;
616  }
617 
618  // parse block, this info is optional
619  if ( (wcslen16(&idn[i])>=2) && (idn[i+0]=='-') && (idn[i+1]>='0') && (idn[i+1]<='9') )
620  {
621  _block = wtoi16(&idn[i+1]);
622  i++;
623  while( (idn[i]>='0') && (idn[i]<='9') )
624  i++;
625  }
626 
627  // parse si, this info is optional
628  if ( (wcslen16(&idn[i])>=2) && (idn[i+0]=='.') && (idn[i+1]>='0') && (idn[i+1]<='9') )
629  {
630  _si = wtoi16(&idn[i+1]);
631  i++;
632  while( (idn[i]>='0') && (idn[i]<='9') )
633  i++;
634  }
635 
636  // parse se, this info is optional
637  if ( (wcslen16(&idn[i])>=2) && (idn[i+0]=='.') && (idn[i+1]>='0') && (idn[i+1]<='9') )
638  {
639  _se = wtoi16(&idn[i+1]);
640  i++;
641  while( (idn[i]>='0') && (idn[i]<='9') )
642  i++;
643  }
644 
645  // return the values
646  if (type)
647  *type = _type;
648  if (set)
649  *set = _set;
650  if (block)
651  *block = _block;
652  if (si)
653  *si = _si;
654  if (se)
655  *se = _se;
656  if (address)
657  *address = _address;
658 
659  // Remove separator spaces
660  while(idn[i]==MLPI_VALUE_SEPARATOR_UTF16)
661  i++;
662 
663  if (idnNxt)
664  *idnNxt = const_cast<WCHAR16*>(&idn[i]);
665 
666  return MLPI_S_OK;
667 }
668 
669 
684 inline MLPIRESULT utilParameterParseIdn(const WCHAR16 *idnString, ULLONG *idnValue, ULONG *address = NULL)
685 {
686  ULLONG _type=0, _set=0, _block=0, _si=0, _se=0;
687  ULONG _address=0;
688 
689  // parse the string
690  MLPIRESULT result = utilParameterParseIdn(idnString, &_address, &_type, &_set, &_block, &_si, &_se, NULL);
691 
692  // build the IDN
693  if (idnValue)
694  *idnValue = MLPI_SIDN(_type, _set, _block, _si, _se);
695 
696  // address in not part of the IDN
697  if (address)
698  *address = _address;
699 
700  return result;
701 }
702 
703 
712 inline MLPIRESULT utilParameterSplitSidn(const ULLONG sidn, ULLONG* idn, ULONG* address)
713 {
714  ULLONG _idn = 0;
715  ULONG _address = 0;
716  const ULLONG _mask = MLPI_SIDN_TYPE_MASK |
717  ((ULLONG)(MLPI_SIDN_BLOCK_MASK)) << 0 |
718  ((ULLONG)(MLPI_SIDN_SET_MASK)) << 12 |
719  ((ULLONG)(MLPI_SIDN_SE_MASK)) << 16 |
720  ((ULLONG)(MLPI_SIDN_SI_MASK)) << 24 ;
721 
722  _idn = sidn & _mask;
723  _address = (ULONG) ((sidn & (~_mask)) >> 56);
724 
725  if(address)
726  *address = _address;
727 
728  if(idn)
729  *idn = _idn;
730 
731  return MLPI_S_OK;
732 }
733 
734 
749 inline MLPIRESULT utilParameterSplitSidn(const ULLONG sidn, ULONG *address, ULONG *type, ULONG *block, ULONG *spFlag, ULONG *set, ULONG *si, ULONG *se)
750 {
751  typedef struct
752  {
753  ULONG block : 12;
754  ULONG set : 3;
755  ULONG flag : 1;
756  ULONG se : 8;
757  ULONG si : 8;
758  ULONG type : 8;
759  ULONG reserved : 16;
760  ULONG address : 8;
761  }R_SIDN;
762 
763  R_SIDN *_sidn = (R_SIDN*) &sidn;
764 
765  if(address)
766  *address = _sidn->address;
767  if(type)
768  *type = _sidn->type;
769  if(block)
770  *block = _sidn->block;
771  if(spFlag)
772  *spFlag = _sidn->flag;
773  if(set)
774  *set = _sidn->set;
775  if(si)
776  *si = _sidn->si;
777  if(se)
778  *se = _sidn->se;
779 
780  return MLPI_S_OK;
781 }
782 
783 
796 inline WCHAR16* utilParameterParseIdn(const ULLONG address, WCHAR16 *idnString, const ULONG numElements )
797 {
798  WCHAR16 _idn[PARAM_MAX_IDN_STRING_LENGTH] = {L'0'};
799  CHAR _helper[PARAM_MAX_IDN_STRING_LENGTH] = {'0'};
800  ULONG _address=0, _type=0, _block=0, _spFlag=0, _set=0, _si=0, _se=0, i=0;
801  utilParameterSplitSidn(address, &_address, &_type, &_block, &_spFlag, &_set, &_si, &_se);
802 
803  switch(_type)
804  {
805  case (ULONG)MLPI_SIDN_TYPE_DRIVE_S:
806  {
807  if(_spFlag)
808  wcscpy16(_idn, L"P");
809  else
810  wcscpy16(_idn, L"S");
811  break;
812  }
813  case (ULONG)(MLPI_SIDN_TYPE_AXIS>>32):
814  {
815  wcscpy16(_idn, L"A");
816  break;
817  }
818  case (ULONG)(MLPI_SIDN_TYPE_CONTROL>>32):
819  {
820  wcscpy16(_idn, L"C");
821  break;
822  }
823  case (ULONG)(MLPI_SIDN_TYPE_KINEMATIC>>32):
824  {
825  wcscpy16(_idn, L"K");
826  break;
827  }
828  case (ULONG)(MLPI_SIDN_TYPE_PROBE>>32):
829  {
830  wcscpy16(_idn, L"M");
831  break;
832  }
833  case (ULONG)(MLPI_SIDN_TYPE_POSLIMSWITCH>>32):
834  {
835  wcscpy16(_idn, L"N");
836  break;
837  }
838  case (ULONG)(MLPI_SIDN_TYPE_OSCILLOSCOPE>>32):
839  {
840  wcscpy16(_idn, L"O");
841  break;
842  }
843  default:
844  wcscpy16(_idn, L"?");
845  break;
846  }
847  i++;
848  wcscat16(_idn,L"-");
849  i++;
850  sprintf(_helper, "%01u", (UCHAR)((_set>0x7)?0:_set));
851  i += (ULONG) mbstowcs16(&_idn[i], _helper, strlen(_helper));
852  memset(_helper, 0, PARAM_MAX_IDN_STRING_LENGTH);
853  wcscat16(_idn,L"-");
854  i++;
855  sprintf(_helper, "%04u", (USHORT)((_block>0xFFF)?0:_block));
856  i += (ULONG) mbstowcs16(&_idn[i], _helper, strlen(_helper));
857  memset(_helper, 0, PARAM_MAX_IDN_STRING_LENGTH);
858  if(_si)
859  {
860  wcscat16(_idn,L".");
861  i++;
862  sprintf(_helper, "%03u", (UCHAR)((_si>0xFF)?0:_si));
863  i += (ULONG) mbstowcs16(&_idn[i], _helper, strlen(_helper));
864  memset(_helper, 0, PARAM_MAX_IDN_STRING_LENGTH);
865  if(_se)
866  {
867  wcscat16(_idn,L".");
868  i++;
869  sprintf(_helper, "%03u", (UCHAR)((_se>0xFF)?0:_se));
870  i += (ULONG) mbstowcs16(&_idn[i], _helper, strlen(_helper));
871  memset(_helper, 0, PARAM_MAX_IDN_STRING_LENGTH);
872  }
873  }
874 
875  if(numElements >= wcslen16(_idn))
876  {
877  wcscpy16(idnString, _idn);
878  }
879 
880  return idnString;
881 }
882 
883 
901 inline MLPIRESULT utilParameterParseSercosTimeToString(const ULLONG timeStamp, CHAR *time, const ULONG numElements, ULONG *numElementsRet=NULL)
902 {
903  MLPIRESULT mlpiResult=MLPI_S_OK;
904 
905  ULONG len = 0;
906  ULONG seconds = (ULONG) (timeStamp >> 32);
907  ULONG nanoseconds = (ULONG) (timeStamp);
908 
909  if(time==NULL) {
910  len = 0;
911  mlpiResult = MLPI_E_INVALIDARG;
912  }
913  else if(numElements<PARAM_SERCOS_TIME_STRING_LENGTH) {
914  len = 1;
915  *time = '\0';
916  mlpiResult = MLPI_E_BUFFERTOOSHORT;
917  }
918  else
919  {
920  // MAX: 2106-02-07T06:28:15.999999999Z == 0xFFFFFFFF, subtract one second because of return value '-1' of mktime() in case of error
921  if (seconds==0xFFFFFFFF)
922  seconds = 0xFFFFFFFE;
923 
924  if(nanoseconds>999999999) {
925  nanoseconds = 999999999;
926  mlpiResult = MLPI_E_LIMIT_MAX;
927  }
928 #if defined(TARGET_OS_WINCE32)
929 #pragma message ("not supported on TARGET_OS_WINCE32")
930  mlpiResult = MLPI_E_UNIMPLEMENTED;
931 #elif defined(TARGET_OS_WINNT)
932  tm timeBuffer;
933  memset(&timeBuffer, 0, sizeof(timeBuffer));
934 
935  gmtime_s(&timeBuffer, (time_t*) &seconds);
936 
937  len = (ULONG) strftime(time, numElements, "%Y-%m-%dT%H:%M:%S", &timeBuffer);
938  len += sprintf(time+len, ".%09uZ", nanoseconds);
939  len++;
940 #else
941  tm timeBuffer;
942  memset(&timeBuffer, 0, sizeof(timeBuffer));
943 
944  gmtime_r((time_t*) &seconds, &timeBuffer);
945 
946  len = (ULONG) strftime(time, numElements, "%Y-%m-%dT%H:%M:%S", &timeBuffer);
947  len += sprintf(time+len, ".%09luZ", nanoseconds);
948  len++;
949 #endif
950  }
951 
952  if(numElementsRet != NULL)
953  *numElementsRet = len;
954 
955  return mlpiResult;
956 }
957 
958 
976 inline MLPIRESULT utilParameterParseSercosTimeToString(const ULLONG timeStamp, WCHAR16 *time, const ULONG numElements, ULONG *numElementsRet=NULL )
977 {
978  MLPIRESULT mlpiResult = MLPI_S_OK;
979 
980  ULONG len = 0;
981  CHAR localTime[PARAM_SERCOS_TIME_STRING_LENGTH] = "";
982 
983  mlpiResult = utilParameterParseSercosTimeToString(timeStamp, localTime, PARAM_SERCOS_TIME_STRING_LENGTH, &len);
984 
985  len = (ULONG) mbstowcs16(time, localTime, len);
986 
987  if(numElementsRet != NULL)
988  *numElementsRet = len;
989 
990  return mlpiResult;
991 }
992 
993 
1012 inline MLPIRESULT utilParameterParseStringToSercosTime(const CHAR *time, const CHAR separator, ULLONG *timeStamp, CHAR **timeNext=NULL)
1013 {
1014  MLPIRESULT mlpiResult = MLPI_S_OK;
1015 
1016  ULONG year = 0;
1017  ULONG month = 0;
1018  ULONG day = 0;
1019  ULONG hour = 0;
1020  ULONG minute = 0;
1021  ULONG seconds = 0;
1022  ULONG nanoseconds = 0;
1023 
1024  if(time==NULL)
1025  mlpiResult = MLPI_E_INVALIDARG;
1026  else if (timeStamp==NULL)
1027  mlpiResult = MLPI_E_INVALIDARG;
1028  else
1029  {
1030  CHAR localDataUtf8[PARAM_SERCOS_TIME_STRING_LENGTH];
1031  CHAR *localDataUtf8Tmp = localDataUtf8;
1032  ULONG numElements = 0;
1033 
1034  // convert single sercos time string UTF16 to UTF8
1035  while( (*time!='\0') && (*time!=separator) ) {
1036  if( numElements<(PARAM_SERCOS_TIME_STRING_LENGTH-1) )
1037  localDataUtf8Tmp[numElements++] = (CHAR) *time++;
1038  else {
1039  mlpiResult = MLPI_E_INVALIDARG;
1040  break;
1041  }
1042  }
1043 
1044  if(MLPI_SUCCEEDED(mlpiResult))
1045  {
1046  if(timeNext!=NULL)
1047  {
1048  // Remove separator spaces
1049  while(*time==MLPI_VALUE_SEPARATOR_UTF8)
1050  time++;
1051 
1052  *timeNext = const_cast<CHAR*>(time);
1053  }
1054 
1055  // clear remaining buffer
1056  while(numElements<PARAM_SERCOS_TIME_STRING_LENGTH)
1057  localDataUtf8Tmp[numElements++] = '\0';
1058  localDataUtf8Tmp = localDataUtf8;
1059 
1060  //
1061  // check characters, valid strings are...
1062  //
1063  // YYYY-mm-ddTHH:MM:SS.uuuuuuuuuZ
1064  // 1970-01-01T00:00:00.000000000Z
1065  // ...
1066  // 1970-01-01T00:00:00.00000Z
1067  // ...
1068  // 1970-01-01T00:00:00.0Z
1069  // 1970-01-01T00:00:00Z
1070  //
1071  // check string parts: 4 digits for years
1072  for(ULONG i=0; i<4; i++, localDataUtf8Tmp++)
1073  if( (*localDataUtf8Tmp<'0') || (*localDataUtf8Tmp>'9') )
1074  mlpiResult = MLPI_E_INVALIDARG;
1075 
1076  // check string parts: 1 digit for year - month separator
1077  if(*localDataUtf8Tmp++!='-')
1078  mlpiResult = MLPI_E_INVALIDARG;
1079 
1080  // check string parts: 2 digits for months
1081  for(ULONG i=0; i<2; i++, localDataUtf8Tmp++)
1082  if( (*localDataUtf8Tmp<'0') || (*localDataUtf8Tmp>'9') )
1083  mlpiResult = MLPI_E_INVALIDARG;
1084 
1085  // check string parts: 1 digit for month - day separator
1086  if(*localDataUtf8Tmp++!='-')
1087  mlpiResult = MLPI_E_INVALIDARG;
1088 
1089  // check string parts: 2 digits for days
1090  for(ULONG i=0; i<2; i++, localDataUtf8Tmp++)
1091  if( (*localDataUtf8Tmp<'0') || (*localDataUtf8Tmp>'9') )
1092  mlpiResult = MLPI_E_INVALIDARG;
1093 
1094  // check string parts: 1 digit for day - hour separator
1095  if(*localDataUtf8Tmp++!='T')
1096  mlpiResult = MLPI_E_INVALIDARG;
1097 
1098  // check string parts: 2 digits for hours
1099  for(ULONG i=0; i<2; i++, localDataUtf8Tmp++)
1100  if( (*localDataUtf8Tmp<'0') || (*localDataUtf8Tmp>'9') )
1101  mlpiResult = MLPI_E_INVALIDARG;
1102 
1103  // check string parts: 1 digit for hour - minute separator
1104  if(*localDataUtf8Tmp++!=':')
1105  mlpiResult = MLPI_E_INVALIDARG;
1106 
1107  // check string parts: 2 digits for minutes
1108  for(ULONG i=0; i<2; i++, localDataUtf8Tmp++)
1109  if( (*localDataUtf8Tmp<'0') || (*localDataUtf8Tmp>'9') )
1110  mlpiResult = MLPI_E_INVALIDARG;
1111 
1112  // check string parts: 1 digit for minute - second separator
1113  if(*localDataUtf8Tmp++!=':')
1114  mlpiResult = MLPI_E_INVALIDARG;
1115 
1116  // check string parts: 2 digits for seconds
1117  for(ULONG i=0; i<2; i++, localDataUtf8Tmp++)
1118  if( (*localDataUtf8Tmp<'0') || (*localDataUtf8Tmp>'9') )
1119  mlpiResult = MLPI_E_INVALIDARG;
1120 
1121  // check string parts: max. 9 digits for nanoseconds
1122  if(*localDataUtf8Tmp++=='.') {
1123  if( (*localDataUtf8Tmp<'0') || (*localDataUtf8Tmp>'9') )
1124  mlpiResult = MLPI_E_INVALIDARG;
1125  else {
1126  localDataUtf8Tmp++;
1127  for(ULONG i=0; i<9; i++, localDataUtf8Tmp++) {
1128  if( (*localDataUtf8Tmp<'0') || (*localDataUtf8Tmp>'9') ) {
1129  if ( (*localDataUtf8Tmp++!='Z') || (*localDataUtf8Tmp!='\0') )
1130  {
1131  mlpiResult = MLPI_E_INVALIDARG;
1132  }
1133  break;
1134  }
1135  }
1136  }
1137  }
1138  else if ( (*localDataUtf8Tmp++!='Z') || (*localDataUtf8Tmp!='\0') )
1139  mlpiResult = MLPI_E_INVALIDARG;
1140  else
1141  mlpiResult = MLPI_E_INVALIDARG;
1142  }
1143 
1144  // convert string to values and check values
1145  if(MLPI_SUCCEEDED(mlpiResult))
1146  {
1147  // MIN: 1970-01-01T00:00:00.000000000Z
1148  // MAX: 2106-02-07T06:28:15.999999999Z, subtract one second because of return value '-1' of mktime() in case of error
1149 
1150  year = strtoul(&localDataUtf8[0], NULL, 10);
1151  month = strtoul(&localDataUtf8[5], NULL, 10);
1152  day = strtoul(&localDataUtf8[8], NULL, 10);
1153  hour = strtoul(&localDataUtf8[11], NULL, 10);
1154  minute = strtoul(&localDataUtf8[14], NULL, 10);
1155  seconds = strtoul(&localDataUtf8[17], NULL, 10);
1156  nanoseconds = strtoul(&localDataUtf8[20], NULL, 10);
1157 
1158  if( (year<1970) || (year>2106) ) mlpiResult = MLPI_E_INVALIDARG;
1159  if( (month<1) || (month>12) ) mlpiResult = MLPI_E_INVALIDARG;
1160  if( (day<1) || (day>31) ) mlpiResult = MLPI_E_INVALIDARG;
1161  if( (hour>23) ) mlpiResult = MLPI_E_INVALIDARG;
1162  if( (minute>59) ) mlpiResult = MLPI_E_INVALIDARG;
1163  if( (seconds>59) ) mlpiResult = MLPI_E_INVALIDARG;
1164  if( (nanoseconds>999999999) ) mlpiResult = MLPI_E_INVALIDARG;
1165  if( (year==2106) && (month>2) ) mlpiResult = MLPI_E_INVALIDARG;
1166  if( (year==2106) && (month==2) && (day>7) ) mlpiResult = MLPI_E_INVALIDARG;
1167  if( (year==2106) && (month==2) && (day==7) && (hour>6) ) mlpiResult = MLPI_E_INVALIDARG;
1168  if( (year==2106) && (month==2) && (day==7) && (hour==6) && (minute>28) ) mlpiResult = MLPI_E_INVALIDARG;
1169  if( (year==2106) && (month==2) && (day==7) && (hour==6) && (minute==28) && (seconds>15) ) mlpiResult = MLPI_E_INVALIDARG;
1170  if( (year==2106) && (month==2) && (day==7) && (hour==6) && (minute==28) && (seconds==15) ) seconds = 14;
1171  }
1172 
1173  if(MLPI_SUCCEEDED(mlpiResult))
1174  {
1175  time_t timeSeconds=0;
1176  tm timeBuffer;
1177  memset(&timeBuffer, 0, sizeof(timeBuffer));
1178 
1179  timeBuffer.tm_year = year - 1970 + 70;
1180  timeBuffer.tm_mon = month - 1;
1181  timeBuffer.tm_mday = day;
1182  timeBuffer.tm_hour = hour;
1183  timeBuffer.tm_min = minute;
1184  timeBuffer.tm_sec = seconds;
1185 
1186 
1187 #if defined(TARGET_OS_WINCE32)
1188 #pragma message ("not supported on TARGET_OS_WINCE32")
1189  mlpiResult = MLPI_E_UNIMPLEMENTED;
1190 #else
1191  // time correction for time zone differences
1192  time_t rawtime;
1193  struct tm * timeinfo;
1194  LLONG CorrectSeconds = 0;
1195 
1196  rawtime = 23 * 60 * 60; // 23 hours in seconds, hours from 0 to 23
1197  timeinfo = localtime (&rawtime);
1198 
1199  if(timeinfo->tm_mday == 1)
1200  {
1201  // negative time zone difference or 0 from UTC
1202  CorrectSeconds =(timeinfo->tm_hour - 23) * 60 * 60;
1203  }
1204  else
1205  {
1206  //positive time zone difference from UTC
1207  CorrectSeconds = timeinfo->tm_hour * 60 * 60 + 60 * 60;
1208  }
1209 
1210  if( (timeSeconds = mktime( &timeBuffer )) != ((time_t)-1) )
1211  {
1212  *timeStamp = ((((ULLONG) timeSeconds) + CorrectSeconds)<<32 ) | ((ULLONG) nanoseconds);
1213  }
1214  else
1215  *timeStamp = 0;
1216 #endif
1217  }
1218  }
1219 
1220  return mlpiResult;
1221 }
1222 
1223 
1242 inline MLPIRESULT utilParameterParseStringToSercosTime(const WCHAR16 *time, const WCHAR16 separator, ULLONG *timeStamp, WCHAR16 **timeNext=NULL)
1243 {
1244  MLPIRESULT mlpiResult = MLPI_S_OK;
1245 
1246  if(time==NULL)
1247  mlpiResult = MLPI_E_INVALIDARG;
1248  else if (timeStamp==NULL)
1249  mlpiResult = MLPI_E_INVALIDARG;
1250  else
1251  {
1252  CHAR localDataUtf8[PARAM_SERCOS_TIME_STRING_LENGTH];
1253  CHAR *localDataUtf8Tmp = localDataUtf8;
1254  ULONG numElements = 0;
1255 
1256  // convert single sercos time string UTF16 to UTF8
1257  while( (*time!='\0') && (*time!=separator) ) {
1258  if( numElements<(PARAM_SERCOS_TIME_STRING_LENGTH-1) )
1259  localDataUtf8Tmp[numElements++] = (CHAR) *time++;
1260  else
1261  {
1262  mlpiResult = MLPI_E_INVALIDARG;
1263  break;
1264  }
1265  }
1266 
1267  if(MLPI_SUCCEEDED(mlpiResult))
1268  {
1269  if(timeNext!=NULL)
1270  *timeNext = const_cast<WCHAR16*>(time);
1271 
1272  // clear remaining buffer
1273  while(numElements<PARAM_SERCOS_TIME_STRING_LENGTH)
1274  localDataUtf8Tmp[numElements++] = '\0';
1275  localDataUtf8Tmp = localDataUtf8;
1276 
1277  mlpiResult = utilParameterParseStringToSercosTime(localDataUtf8,(CHAR)separator, timeStamp, (CHAR**)timeNext);
1278 
1279  }
1280  }
1281 
1282  return mlpiResult;
1283 }
1284 
1289 class MlpiReadEverythingDataAccess
1290 {
1291 
1292 #define DATA_STATUS_OP_DATA_INVALID (0x0100)
1293 #define DATA_IS_INVALID(index) ((index > _numElements) || _argInvalid)
1294 #define DATA_IS_VALID(index) ((index <= _numElements) && !_argInvalid)
1295 #define VALID_ELEMENT_ACCESS(name, bit) bool name(const ULONG index) const {return (DATA_IS_VALID(index) && (_readEverything[index].validElements & (1<<bit))) ? true : false;}
1296 
1297 public:
1298  MlpiReadEverythingDataAccess(const MlpiReadEverything* const readEverything, const ULONG numElements, const UCHAR* const data, const ULONG dataSize)
1299  : _readEverything(readEverything)
1300  , _data(data)
1301  , _numElements(numElements)
1302  , _dataSize(dataSize)
1303  , _argInvalid(( (NULL == readEverything) || (NULL == data) || (0 == numElements) || (0 == dataSize) ) ? true : false)
1304  {
1305  };
1306 
1307  ~MlpiReadEverythingDataAccess(){};
1308 
1309  VALID_ELEMENT_ACCESS(isValid_DataStatus , 0);
1310  VALID_ELEMENT_ACCESS(isValid_Name , 1);
1311  VALID_ELEMENT_ACCESS(isValid_Attribute , 2);
1312  VALID_ELEMENT_ACCESS(isValid_Unit , 3);
1313  VALID_ELEMENT_ACCESS(isValid_MinimumValue, 4);
1314  VALID_ELEMENT_ACCESS(isValid_MaximumValue, 5);
1315  VALID_ELEMENT_ACCESS(isValid_Data , 6);
1316 
1317  const WCHAR16* getName(const ULONG index) const {
1318  return isValid_Name(index) ? reinterpret_cast<const WCHAR16*>(_data + _readEverything[index].nameOffset) : L"";
1319  }
1320 
1321  const WCHAR16* getUnit(const ULONG index) const {
1322  return isValid_Unit(index) ? reinterpret_cast<const WCHAR16*>(_data + _readEverything[index].unitOffset) : L"";
1323  }
1324 
1325  const UCHAR* getData(const ULONG index) const {
1326  return isValid_Data(index) ? (_data + _readEverything[index].dataOffset) : 0;
1327  }
1328 
1329  template<class T>
1330  const T* getData(const ULONG index) const {
1331  return isValid_Data(index) ? reinterpret_cast<const T*>(_data + _readEverything[index].dataOffset) : 0;
1332  }
1333 
1334  ULONG getNumDataElements(const ULONG index) const {
1335  return isValid_Data(index) ? (_readEverything[index].dataLength ? (_readEverything[index].dataSize / _readEverything[index].dataLength) : 0) : 0;
1336  }
1337 
1338  const UCHAR* getMinimumValue(const ULONG index) const {
1339  return isValid_MinimumValue(index) ? (_data + _readEverything[index].minOffset) : 0;
1340  }
1341 
1342  template<class T>
1343  const T* getMinimumValue(const ULONG index) const {
1344  return isValid_MinimumValue(index) ? reinterpret_cast<const T*>(_data + _readEverything[index].minOffset) : 0;
1345  }
1346 
1347  const UCHAR* getMaximumValue(const ULONG index) const {
1348  return isValid_MaximumValue(index) ? (_data + _readEverything[index].maxOffset) : 0;
1349  }
1350 
1351  template<class T>
1352  const T* getMaximumValue(const ULONG index) const {
1353  return isValid_MaximumValue(index) ? reinterpret_cast<const T*>(_data + _readEverything[index].maxOffset) : 0;
1354  }
1355 
1356  ULONG getAttribute(const ULONG index) const {
1357  return isValid_Attribute(index) ? (_readEverything[index].attribute) : 0;
1358  }
1359 
1360  ULONG getValidElements(const ULONG index) const {
1361  return (_readEverything[index].validElements);
1362  }
1363 
1364  ULONG getDataStatus(const ULONG index) const {
1365  return isValid_DataStatus(index) ? _readEverything[index].dataStatus : DATA_STATUS_OP_DATA_INVALID;
1366  }
1367 
1368  MlpiParameterCommandStatus getCommandStatus(const ULONG index) const {
1369  ULONG status = getDataStatus(index);
1370  return ((status & DATA_STATUS_OP_DATA_INVALID) ? MLPI_PARAMETER_COMMAND_STATUS_INVALID : ((MlpiParameterCommandStatus) status));
1371  }
1372 
1373  BOOL8 isDataStatusValid(const ULONG index) const {
1374  return ((getDataStatus(index) & DATA_STATUS_OP_DATA_INVALID) ? FALSE : TRUE);
1375  }
1376 
1377  MlpiType getDataType(const ULONG index) const {
1378  if( DATA_IS_INVALID(index) )
1379  return MLPI_TYPE_INVALID;
1380  return utilParameterGetDataTypeFromAttribute(_readEverything[index].attribute);
1381  }
1382 
1383  MLPIRESULT getReturnValue(const ULONG index) const {
1384  if( DATA_IS_INVALID(index) )
1385  return 0;
1386  return (_readEverything[index].result);
1387  }
1388 
1389 private:
1390  const MlpiReadEverything* const _readEverything;
1391  const UCHAR* const _data;
1392  const ULONG _numElements;
1393  const ULONG _dataSize;
1394  const bool _argInvalid;
1395 };
1396 
1397 
1398 template <typename T>
1399 inline MLPIRESULT mlpiConvertBooleanDataToUtf16( T data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet )
1400 {
1401  MLPIRESULT mlpiResult = MLPI_S_OK;
1402 
1403  if(dataUtf16==NULL) {
1404  mlpiResult = MLPI_E_INVALIDARG;
1405  }
1406  else
1407  {
1408  ULONG numElementsLocal = sizeof(WCHAR16)*numElements;
1409  ULONG numElementsRetLocal = 0;
1410 
1411  // Convert data to utf16
1412  if (data!=0) {
1413  numElementsRetLocal = MLPI_SIZEOF_BOOLEAN_VALUE_TRUE;
1414  memcpy(dataUtf16, MLPI_BOOLEAN_VALUE_TRUE, numElementsLocal<numElementsRetLocal?numElementsLocal:numElementsRetLocal);
1415  }
1416  else {
1417  numElementsRetLocal = MLPI_SIZEOF_BOOLEAN_VALUE_FALSE;
1418  memcpy(dataUtf16, MLPI_BOOLEAN_VALUE_FALSE, numElementsLocal<numElementsRetLocal?numElementsLocal:numElementsRetLocal);
1419  }
1420 
1421  // Set length
1422  if(numElementsRet != NULL)
1423  *numElementsRet = numElementsRetLocal/sizeof(WCHAR16);
1424 
1425  if(numElements != 0)
1426  dataUtf16[numElements-1] = 0;
1427  if(numElementsLocal < numElementsRetLocal)
1428  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1429  }
1430  return mlpiResult;
1431 }
1432 
1433 
1434 template <typename T>
1435 inline MLPIRESULT mlpiConvertBinaryDataToUtf16( T data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet )
1436 {
1437  MLPIRESULT mlpiResult = MLPI_S_OK;
1438 
1439  if(dataUtf16==NULL) {
1440  mlpiResult = MLPI_E_INVALIDARG;
1441  }
1442  else
1443  {
1444  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
1445  CHAR dataUtf8[dataBuffLen];
1446  ULONG dataBuffCnt = 0;
1447 
1448  // Convert data to utf8
1449  dataBuffCnt = sprintf(&dataUtf8[dataBuffCnt], "0b");
1450  for(LONG j=(sizeof(data)*8)-1; j>=0 ; j--) {
1451  dataBuffCnt += sprintf(&dataUtf8[dataBuffCnt], "%01u", (USHORT) ((data>>j) & 1));
1452  if (((j%4)==0) && j!=0)
1453  dataBuffCnt += sprintf(&dataUtf8[dataBuffCnt], ".");
1454  }
1455 
1456  // Set length
1457  if(numElementsRet != NULL)
1458  *numElementsRet = dataBuffCnt+1;
1459 
1460  // convert utf8 to utf16
1461  mbstowcs16(dataUtf16, dataUtf8, numElements);
1462  if(numElements != 0)
1463  dataUtf16[numElements-1] = 0;
1464  if( dataBuffCnt >= numElements )
1465  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1466  }
1467  return mlpiResult;
1468 }
1469 template <> inline MLPIRESULT mlpiConvertBinaryDataToUtf16( FLOAT data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1470 template <> inline MLPIRESULT mlpiConvertBinaryDataToUtf16( DOUBLE data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1471 
1472 
1473 // Helper for mlpiConvertUintDecDataToUtf16 to prevent warnings
1474 template <typename T>
1475 inline ULONG mlpiConvertUintDecDataToUtf16ConvertLine( char* dst, T data ) { return sprintf(dst, "%llu", data); }
1476 template <> inline ULONG mlpiConvertUintDecDataToUtf16ConvertLine( char* dst, ULLONG data ) { return sprintf(dst, "%llu", data); }
1477 template <> inline ULONG mlpiConvertUintDecDataToUtf16ConvertLine( char* dst, ULONG data ) { return sprintf(dst, "%lu", data); }
1478 template <> inline ULONG mlpiConvertUintDecDataToUtf16ConvertLine( char* dst, USHORT data ) { return sprintf(dst, "%hu", data); }
1479 template <> inline ULONG mlpiConvertUintDecDataToUtf16ConvertLine( char* dst, UCHAR data ) { return sprintf(dst, "%hhu", data); }
1480 // Implementation mlpiConvertUintDecDataToUtf16
1481 template <typename T>
1482 inline MLPIRESULT mlpiConvertUintDecDataToUtf16( T data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet )
1483 {
1484  MLPIRESULT mlpiResult = MLPI_S_OK;
1485 
1486  if(dataUtf16==NULL) {
1487  mlpiResult = MLPI_E_INVALIDARG;
1488  }
1489  else
1490  {
1491  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
1492  CHAR dataUtf8[dataBuffLen] = "";
1493  ULONG dataBuffCnt = 0;
1494 
1495  // Convert data to utf8
1496  dataBuffCnt = mlpiConvertUintDecDataToUtf16ConvertLine(dataUtf8, data);
1497 
1498  // Set length
1499  if(numElementsRet != NULL)
1500  *numElementsRet = dataBuffCnt+1;
1501 
1502  // convert utf8 to utf16
1503  mbstowcs16(dataUtf16, dataUtf8, numElements);
1504  if(numElements != 0)
1505  dataUtf16[numElements-1] = 0;
1506  if( dataBuffCnt >= numElements )
1507  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1508  }
1509  return mlpiResult;
1510 }
1511 template <> inline MLPIRESULT mlpiConvertUintDecDataToUtf16( FLOAT data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1512 template <> inline MLPIRESULT mlpiConvertUintDecDataToUtf16( DOUBLE data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1513 
1514 
1515 // Helper for mlpiConvertIntDecDataToUtf16 to prevent warnings
1516 template <typename T>
1517 inline ULONG mlpiConvertIntDecDataToUtf16ConvertLine( char* dst, T data ) { return sprintf(dst, "%lld", data); }
1518 template <> inline ULONG mlpiConvertIntDecDataToUtf16ConvertLine( char* dst, LLONG data ) { return sprintf(dst, "%lld", data); }
1519 template <> inline ULONG mlpiConvertIntDecDataToUtf16ConvertLine( char* dst, LONG data ) { return sprintf(dst, "%ld", data); }
1520 template <> inline ULONG mlpiConvertIntDecDataToUtf16ConvertLine( char* dst, SHORT data ) { return sprintf(dst, "%hd", data); }
1521 template <> inline ULONG mlpiConvertIntDecDataToUtf16ConvertLine( char* dst, CHAR data ) { return sprintf(dst, "%hhd", data); }
1522 // Implementation mlpiConvertIntDecDataToUtf16
1523 template <typename T>
1524 inline MLPIRESULT mlpiConvertIntDecDataToUtf16( T data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet )
1525 {
1526  MLPIRESULT mlpiResult = MLPI_S_OK;
1527 
1528  if(dataUtf16==NULL) {
1529  mlpiResult = MLPI_E_INVALIDARG;
1530  }
1531  else
1532  {
1533  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
1534  CHAR dataUtf8[dataBuffLen] = "";
1535  ULONG dataBuffCnt = 0;
1536 
1537  // Convert data to utf8
1538  dataBuffCnt = mlpiConvertIntDecDataToUtf16ConvertLine(dataUtf8, data);
1539 
1540  // Set length
1541  if(numElementsRet != NULL)
1542  *numElementsRet = dataBuffCnt+1;
1543 
1544  // convert utf8 to utf16
1545  mbstowcs16(dataUtf16, dataUtf8, numElements);
1546  if(numElements != 0)
1547  dataUtf16[numElements-1] = 0;
1548  if( dataBuffCnt >= numElements )
1549  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1550  }
1551  return mlpiResult;
1552 }
1553 template <> inline MLPIRESULT mlpiConvertIntDecDataToUtf16( FLOAT data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1554 template <> inline MLPIRESULT mlpiConvertIntDecDataToUtf16( DOUBLE data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1555 
1556 
1557 // Helper for mlpiConvertUintHexDataToUtf16 to prevent warnings
1558 template <typename T>
1559 inline ULONG mlpiConvertUintHexDataToUtf16ConvertLine( char* dst, T data ) { return sprintf(dst, "0x%08X%08X", ((ULONG)(((ULLONG)data)>>32)), ((ULONG)(data))); }
1560 template <> inline ULONG mlpiConvertUintHexDataToUtf16ConvertLine( char* dst, ULLONG data ) { return sprintf(dst, "0x%08lX%08lX", ((ULONG)(((ULLONG)data)>>32)), ((ULONG)(data))); }
1561 template <> inline ULONG mlpiConvertUintHexDataToUtf16ConvertLine( char* dst, ULONG data ) { return sprintf(dst, "0x%08lX", data); }
1562 template <> inline ULONG mlpiConvertUintHexDataToUtf16ConvertLine( char* dst, USHORT data ) { return sprintf(dst, "0x%04X", data); }
1563 template <> inline ULONG mlpiConvertUintHexDataToUtf16ConvertLine( char* dst, UCHAR data ) { return sprintf(dst, "0x%02X", data); }
1564 // Implementation mlpiConvertUintHexDataToUtf16
1565 template <typename T>
1566 inline MLPIRESULT mlpiConvertUintHexDataToUtf16( T data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet )
1567 {
1568  MLPIRESULT mlpiResult = MLPI_S_OK;
1569 
1570  if(dataUtf16==NULL) {
1571  mlpiResult = MLPI_E_INVALIDARG;
1572  }
1573  else
1574  {
1575  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
1576  CHAR dataUtf8[dataBuffLen] = "";
1577  ULONG dataBuffCnt = 0;
1578 
1579  // Convert data to utf8
1580  dataBuffCnt = mlpiConvertUintHexDataToUtf16ConvertLine(dataUtf8, data);
1581 
1582  // Set length
1583  if(numElementsRet != NULL)
1584  *numElementsRet = dataBuffCnt+1;
1585 
1586  // convert utf8 to utf16
1587  mbstowcs16(dataUtf16, dataUtf8, numElements);
1588  if(numElements != 0)
1589  dataUtf16[numElements-1] = 0;
1590  if( dataBuffCnt >= numElements )
1591  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1592  }
1593  return mlpiResult;
1594 }
1595 template <> inline MLPIRESULT mlpiConvertUintHexDataToUtf16( FLOAT data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1596 template <> inline MLPIRESULT mlpiConvertUintHexDataToUtf16( DOUBLE data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1597 
1598 
1599 template <typename T>
1600 inline MLPIRESULT mlpiConvertUintIdnDataToUtf16( T data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet )
1601 {
1602  MLPIRESULT mlpiResult = MLPI_S_OK;
1603 
1604  if(dataUtf16==NULL) {
1605  mlpiResult = MLPI_E_INVALIDARG;
1606  }
1607  else
1608  {
1609  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
1610  CHAR dataUtf8[dataBuffLen] = "";
1611  ULONG dataBuffCnt = 0;
1612 
1613  // Convert data to utf8
1614  switch(sizeof(T))
1615  {
1616  default:
1617  case sizeof(ULLONG): dataBuffCnt = sprintf(dataUtf8, "0x%08X%08X", (static_cast<int>(((ULLONG)data)>>32)), (static_cast<int>(data))); break; /* No rules for this case so use default */
1618  case sizeof(UCHAR): dataBuffCnt = sprintf(dataUtf8, "0x%02X", static_cast<int>(data)); break; /* No rules for this case so use default */
1619  case sizeof(USHORT):
1620  {
1621  if (data & 0x8000)
1622  dataBuffCnt = sprintf(dataUtf8, "P-%01u-%04u", MLPI_SIDN_SET(data), MLPI_SIDN_BLOCK(data));
1623  else
1624  dataBuffCnt = sprintf(dataUtf8, "S-%01u-%04u", MLPI_SIDN_SET(data), MLPI_SIDN_BLOCK(data));
1625  break;
1626  }
1627  case sizeof(ULONG):
1628  {
1629  if (data & 0x00008000)
1630  dataBuffCnt = sprintf(dataUtf8, "P-%01u-%04u.%01u.%01u", MLPI_SIDN_SET(data), MLPI_SIDN_BLOCK(data), MLPI_SIDN_SI(data), MLPI_SIDN_SE(data));
1631  else
1632  dataBuffCnt = sprintf(dataUtf8, "S-%01u-%04u.%01u.%01u", MLPI_SIDN_SET(data), MLPI_SIDN_BLOCK(data), MLPI_SIDN_SI(data), MLPI_SIDN_SE(data));
1633  break;
1634  }
1635  }
1636 
1637  // Set length
1638  if(numElementsRet != NULL)
1639  *numElementsRet = dataBuffCnt+1;
1640 
1641  // convert utf8 to utf16
1642  mbstowcs16(dataUtf16, dataUtf8, numElements);
1643  if(numElements != 0)
1644  dataUtf16[numElements-1] = 0;
1645  if( dataBuffCnt >= numElements )
1646  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1647  }
1648  return mlpiResult;
1649 }
1650 template <> inline MLPIRESULT mlpiConvertUintIdnDataToUtf16( FLOAT data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1651 template <> inline MLPIRESULT mlpiConvertUintIdnDataToUtf16( DOUBLE data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1652 
1653 
1654 // Helper for mlpiConvertMlcIdnDataToUtf16 to prevent warnings
1655 template <typename T>
1656 inline ULONG mlpiConvertMlcIdnDataToUtf16ConvertLine( char* dst, T data ) { return sprintf(dst, "0x%08X%08X", ((ULONG)(((ULLONG)data)>>32)), ((ULONG)(data))); }
1657 template <> inline ULONG mlpiConvertMlcIdnDataToUtf16ConvertLine( char* dst, UCHAR data ) { return sprintf(dst, "0x%02X", data); }
1658 template <> inline ULONG mlpiConvertMlcIdnDataToUtf16ConvertLine( char* dst, USHORT data ) { return sprintf(dst, "0x%04X", data); }
1659 template <> inline ULONG mlpiConvertMlcIdnDataToUtf16ConvertLine( char* dst, ULONG data ) { return sprintf(dst, "0x%08lX", data); }
1660 template <> inline ULONG mlpiConvertMlcIdnDataToUtf16ConvertLine( char* dst, ULLONG data )
1661 {
1662  switch(data & MLPI_SIDN_TYPE_MASK)
1663  {
1664  default: return sprintf(dst, "0x%08lX%08lX", ((ULONG)(((ULLONG)data)>>32)), ((ULONG)(data)));
1665  case MLPI_SIDN_TYPE_DRIVE_S: return sprintf(dst, "A%03u:S-%01u-%04u.%01u.%01u", MLPI_SIDN_INST(data), MLPI_SIDN_SET(data), MLPI_SIDN_BLOCK(data), MLPI_SIDN_SI(data), MLPI_SIDN_SE(data));
1666  case MLPI_SIDN_TYPE_DRIVE_P: return sprintf(dst, "A%03u:P-%01u-%04u.%01u.%01u", MLPI_SIDN_INST(data), MLPI_SIDN_SET(data), MLPI_SIDN_BLOCK(data), MLPI_SIDN_SI(data), MLPI_SIDN_SE(data));
1667  case MLPI_SIDN_TYPE_AXIS: return sprintf(dst, "A%03u:A-%01u-%04u.%01u.%01u", MLPI_SIDN_INST(data), MLPI_SIDN_SET(data), MLPI_SIDN_BLOCK(data), MLPI_SIDN_SI(data), MLPI_SIDN_SE(data));
1668  case MLPI_SIDN_TYPE_CONTROL: return sprintf(dst, "C%03u:C-%01u-%04u.%01u.%01u", MLPI_SIDN_INST(data), MLPI_SIDN_SET(data), MLPI_SIDN_BLOCK(data), MLPI_SIDN_SI(data), MLPI_SIDN_SE(data));
1669  case MLPI_SIDN_TYPE_KINEMATIC: return sprintf(dst, "K%03u:K-%01u-%04u.%01u.%01u", MLPI_SIDN_INST(data), MLPI_SIDN_SET(data), MLPI_SIDN_BLOCK(data), MLPI_SIDN_SI(data), MLPI_SIDN_SE(data));
1670  case MLPI_SIDN_TYPE_PROBE: return sprintf(dst, "M%03u:M-%01u-%04u.%01u.%01u", MLPI_SIDN_INST(data), MLPI_SIDN_SET(data), MLPI_SIDN_BLOCK(data), MLPI_SIDN_SI(data), MLPI_SIDN_SE(data));
1671  case MLPI_SIDN_TYPE_POSLIMSWITCH: return sprintf(dst, "N%03u:N-%01u-%04u.%01u.%01u", MLPI_SIDN_INST(data), MLPI_SIDN_SET(data), MLPI_SIDN_BLOCK(data), MLPI_SIDN_SI(data), MLPI_SIDN_SE(data));
1672  case MLPI_SIDN_TYPE_OSCILLOSCOPE: return sprintf(dst, "O%03u:O-%01u-%04u.%01u.%01u", MLPI_SIDN_INST(data), MLPI_SIDN_SET(data), MLPI_SIDN_BLOCK(data), MLPI_SIDN_SI(data), MLPI_SIDN_SE(data));
1673  }
1674 }
1675 // Implementation mlpiConvertMlcIdnDataToUtf16
1676 template <typename T>
1677 inline MLPIRESULT mlpiConvertMlcIdnDataToUtf16( T data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet )
1678 {
1679  MLPIRESULT mlpiResult = MLPI_S_OK;
1680 
1681  if(dataUtf16==NULL) {
1682  mlpiResult = MLPI_E_INVALIDARG;
1683  }
1684  else
1685  {
1686  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
1687  CHAR dataUtf8[dataBuffLen] = "";
1688  ULONG dataBuffCnt = 0;
1689 
1690  // Convert data to utf8
1691  dataBuffCnt = mlpiConvertMlcIdnDataToUtf16ConvertLine(dataUtf8, data);
1692 
1693  // Set length
1694  if(numElementsRet != NULL)
1695  *numElementsRet = dataBuffCnt+1;
1696 
1697  // convert utf8 to utf16
1698  mbstowcs16(dataUtf16, dataUtf8, numElements);
1699  if(numElements != 0)
1700  dataUtf16[numElements-1] = 0;
1701  if( dataBuffCnt >= numElements )
1702  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1703  }
1704  return mlpiResult;
1705 }
1706 template <> inline MLPIRESULT mlpiConvertMlcIdnDataToUtf16( FLOAT data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1707 template <> inline MLPIRESULT mlpiConvertMlcIdnDataToUtf16( DOUBLE data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1708 
1709 
1710 template <typename T>
1711 inline MLPIRESULT mlpiConvertFloatDataToUtf16( T data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet )
1712 {
1713  MLPIRESULT mlpiResult = MLPI_S_OK;
1714 
1715  if(dataUtf16==NULL) {
1716  mlpiResult = MLPI_E_INVALIDARG;
1717  }
1718  else
1719  {
1720  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
1721  CHAR dataUtf8[dataBuffLen] = "";
1722  ULONG dataBuffCnt = 0;
1723 
1724  // Convert data to utf8
1725  switch(sizeof(T))
1726  {
1727  default: dataBuffCnt = sprintf(dataUtf8, "0x%08X%08X", (static_cast<int>(((ULLONG)data)>>32)), (static_cast<int>(data))); /* No rules for this case so use default */
1728  case sizeof(DOUBLE): dataBuffCnt = sprintf(dataUtf8, "%lf", data); break;
1729  case sizeof(FLOAT): dataBuffCnt = sprintf(dataUtf8, "%f", data); break;
1730  }
1731 
1732  // Set length
1733  if(numElementsRet)
1734  *numElementsRet = dataBuffCnt+1;
1735 
1736  // convert utf8 to utf16
1737  mbstowcs16(dataUtf16, dataUtf8, numElements);
1738  if(numElements != 0)
1739  dataUtf16[numElements-1] = 0;
1740  if( dataBuffCnt >= numElements )
1741  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1742  }
1743  return mlpiResult;
1744 }
1745 
1746 
1747 // Helper for mlpiConvertSercosTimeDataToUtf16 to prevent warnings
1748 template <typename T>
1749 inline ULONG mlpiConvertSercosTimeDataToUtf16ConvertLine( char* dst, T data ) { return sprintf(dst, "0x%08X%08X", ((ULONG)(((ULLONG)data)>>32)), ((ULONG)(data))); }
1750 template <> inline ULONG mlpiConvertSercosTimeDataToUtf16ConvertLine( char* dst, UCHAR data ) { return sprintf(dst, "0x%02X", data); }
1751 template <> inline ULONG mlpiConvertSercosTimeDataToUtf16ConvertLine( char* dst, USHORT data ) { return sprintf(dst, "0x%04X", data); }
1752 template <> inline ULONG mlpiConvertSercosTimeDataToUtf16ConvertLine( char* dst, ULONG data ) { return sprintf(dst, "0x%08lX", data); }
1753 template <> inline ULONG mlpiConvertSercosTimeDataToUtf16ConvertLine( char* dst, ULLONG data )
1754 {
1755  ULONG dataBuffCnt = 0;
1756  utilParameterParseSercosTimeToString(data, dst, MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE, &dataBuffCnt);
1757  if(dataBuffCnt!=0) dataBuffCnt--;
1758  return dataBuffCnt;
1759 }
1760 // Implementation mlpiConvertSercosTimeDataToUtf16
1761 template <typename T>
1762 inline MLPIRESULT mlpiConvertSercosTimeDataToUtf16( T data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet )
1763 {
1764  MLPIRESULT mlpiResult = MLPI_S_OK;
1765 
1766  if(dataUtf16==NULL) {
1767  mlpiResult = MLPI_E_INVALIDARG;
1768  }
1769  else
1770  {
1771  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
1772  CHAR dataUtf8[dataBuffLen] = "";
1773  ULONG dataBuffCnt = 0;
1774 
1775  // Convert data to utf8
1776  dataBuffCnt = mlpiConvertSercosTimeDataToUtf16ConvertLine(dataUtf8, data);
1777 
1778  // Set length
1779  if(numElementsRet)
1780  *numElementsRet = dataBuffCnt+1;
1781 
1782  // convert utf8 to utf16
1783  mbstowcs16(dataUtf16, dataUtf8, numElements);
1784  if(numElements != 0)
1785  dataUtf16[numElements-1] = 0;
1786  if( dataBuffCnt >= numElements )
1787  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1788  }
1789  return mlpiResult;
1790 }
1791 template <> inline MLPIRESULT mlpiConvertSercosTimeDataToUtf16( FLOAT data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1792 template <> inline MLPIRESULT mlpiConvertSercosTimeDataToUtf16( DOUBLE data, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet ) { return MLPI_E_INVALIDSIGNATURE; }
1793 
1794 inline MLPIRESULT mlpiConvertTimeDataToUtf16(ULONG dataValue, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet)
1795 {
1796  MLPIRESULT mlpiResult = MLPI_S_OK;
1797 
1798  if(dataUtf16==NULL) {
1799  mlpiResult = MLPI_E_INVALIDARG;
1800  }
1801  else
1802  {
1803  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
1804  CHAR dataUtf8[dataBuffLen] = "";
1805  ULONG dataBuffCnt = 0;
1806 
1807  // Convert data to utf8
1808  ULONG timeMs = dataValue % 1000; dataValue /= 1000;
1809  ULONG timeS = dataValue % 60; dataValue /= 60;
1810  ULONG timeM = dataValue % 60; dataValue /= 60;
1811  ULONG timeH = dataValue % 24; dataValue /= 24;
1812  ULONG timeD = dataValue;
1813 
1814  if(timeD) dataBuffCnt += sprintf(&dataUtf8[dataBuffCnt], "%lud", timeD);
1815  if(timeH) dataBuffCnt += sprintf(&dataUtf8[dataBuffCnt], "%luh", timeH);
1816  if(timeM) dataBuffCnt += sprintf(&dataUtf8[dataBuffCnt], "%lum", timeM);
1817  if(timeS) dataBuffCnt += sprintf(&dataUtf8[dataBuffCnt], "%lus", timeS);
1818  if(timeMs) dataBuffCnt += sprintf(&dataUtf8[dataBuffCnt], "%lums", timeMs);
1819 
1820  // Set length
1821  if(numElementsRet)
1822  *numElementsRet = dataBuffCnt+1;
1823 
1824  // convert utf8 to utf16
1825  mbstowcs16(dataUtf16, dataUtf8, numElements);
1826  if(numElements != 0)
1827  dataUtf16[numElements-1] = 0;
1828  if( dataBuffCnt >= numElements )
1829  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1830  }
1831  return mlpiResult;
1832 }
1833 
1834 inline MLPIRESULT mlpiConvertDateDataToUtf16(ULONG dataValue, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet)
1835 {
1836  MLPIRESULT mlpiResult = MLPI_S_OK;
1837 
1838  if(dataUtf16==NULL) {
1839  mlpiResult = MLPI_E_INVALIDARG;
1840  }
1841  else
1842  {
1843  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
1844  CHAR dataUtf8[dataBuffLen] = "";
1845  ULONG dataBuffCnt = 0;
1846 
1847 #if defined(TARGET_OS_WINCE32)
1848 #pragma message ("not supported on TARGET_OS_WINCE32")
1849  mlpiResult = MLPI_E_UNIMPLEMENTED;
1850 #elif defined(TARGET_OS_WINNT)
1851  tm timeBuffer;
1852  memset(&timeBuffer, 0, sizeof(timeBuffer));
1853 
1854  gmtime_s(&timeBuffer, (time_t*) &dataValue);
1855 
1856  dataBuffCnt = (ULONG) strftime(dataUtf8, numElements, "%Y-%m-%d", &timeBuffer);
1857 #else
1858  tm timeBuffer;
1859  memset(&timeBuffer, 0, sizeof(timeBuffer));
1860 
1861  gmtime_r((time_t*) &dataValue, &timeBuffer);
1862 
1863  dataBuffCnt = (ULONG) strftime(dataUtf8, numElements, "%Y-%m-%d", &timeBuffer);
1864 #endif
1865 
1866  // Set length
1867  if(numElementsRet)
1868  *numElementsRet = dataBuffCnt+1;
1869 
1870  // convert utf8 to utf16
1871  mbstowcs16(dataUtf16, dataUtf8, numElements);
1872  if(numElements != 0)
1873  dataUtf16[numElements-1] = 0;
1874  if( dataBuffCnt >= numElements )
1875  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1876  }
1877  return mlpiResult;
1878 }
1879 
1880 inline MLPIRESULT mlpiConvertDateAndTimeDataToUtf16(ULONG dataValue, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet)
1881 {
1882  MLPIRESULT mlpiResult = MLPI_S_OK;
1883 
1884  if(dataUtf16==NULL) {
1885  mlpiResult = MLPI_E_INVALIDARG;
1886  }
1887  else
1888  {
1889  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
1890  CHAR dataUtf8[dataBuffLen] = "";
1891  ULONG dataBuffCnt = 0;
1892 
1893 #if defined(TARGET_OS_WINCE32)
1894 #pragma message ("not supported on TARGET_OS_WINCE32")
1895  mlpiResult = MLPI_E_UNIMPLEMENTED;
1896 #elif defined(TARGET_OS_WINNT)
1897  tm timeBuffer;
1898  memset(&timeBuffer, 0, sizeof(timeBuffer));
1899 
1900  gmtime_s(&timeBuffer, (time_t*) &dataValue);
1901 
1902  dataBuffCnt = (ULONG) strftime(dataUtf8, numElements, "%Y-%m-%d-%H:%M:%S", &timeBuffer);
1903 #else
1904  tm timeBuffer;
1905  memset(&timeBuffer, 0, sizeof(timeBuffer));
1906 
1907  gmtime_r((time_t*) &dataValue, &timeBuffer);
1908 
1909  dataBuffCnt = (ULONG) strftime(dataUtf8, numElements, "%Y-%m-%d-%H:%M:%S", &timeBuffer);
1910 #endif
1911 
1912  // Set length
1913  if(numElementsRet)
1914  *numElementsRet = dataBuffCnt+1;
1915 
1916  // convert utf8 to utf16
1917  mbstowcs16(dataUtf16, dataUtf8, numElements);
1918  if(numElements != 0)
1919  dataUtf16[numElements-1] = 0;
1920  if( dataBuffCnt >= numElements )
1921  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1922  }
1923  return mlpiResult;
1924 }
1925 
1926 inline MLPIRESULT mlpiConvertTimeOfDayDataToUtf16(ULONG dataValue, WCHAR16* dataUtf16, const ULONG numElements, ULONG *numElementsRet)
1927 {
1928  MLPIRESULT mlpiResult = MLPI_S_OK;
1929 
1930  if(dataUtf16==NULL) {
1931  mlpiResult = MLPI_E_INVALIDARG;
1932  }
1933  else
1934  {
1935  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
1936  CHAR dataUtf8[dataBuffLen] = "";
1937  ULONG dataBuffCnt = 0;
1938 
1939  // Convert data to utf8
1940  ULONG timeMs = dataValue % 1000; dataValue /= 1000;
1941  ULONG timeS = dataValue % 60; dataValue /= 60;
1942  ULONG timeM = dataValue % 60; dataValue /= 60;
1943  ULONG timeH = dataValue % 24; dataValue /= 24;
1944 
1945  dataBuffCnt = sprintf(dataUtf8, "%02lu:%02lu:%02lu", timeH, timeM, timeS);
1946  if(timeMs) dataBuffCnt += sprintf(&dataUtf8[dataBuffCnt], ".%lu", timeMs);
1947 
1948  // Set length
1949  if(numElementsRet)
1950  *numElementsRet = dataBuffCnt+1;
1951 
1952  // convert utf8 to utf16
1953  mbstowcs16(dataUtf16, dataUtf8, numElements);
1954  if(numElements != 0)
1955  dataUtf16[numElements-1] = 0;
1956  if( dataBuffCnt >= numElements )
1957  mlpiResult = MLPI_E_BUFFERTOOSHORT;
1958  }
1959  return mlpiResult;
1960 }
1961 
1962 
1963 template <typename T>
1964 inline MLPIRESULT mlpiConvertUtf16ToBooleanData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, T *data )
1965 {
1966  MLPIRESULT mlpiResult = MLPI_S_OK;
1967 
1968  if(dataUtf16==NULL) {
1969  mlpiResult = MLPI_E_INVALIDARG;
1970  }
1971  else if(data==NULL) {
1972  mlpiResult = MLPI_E_INVALIDARG;
1973  }
1974  else
1975  {
1976  const ULONG dataBuffLenTemp1 = MLPI_SIZEOF_BOOLEAN_VALUE_TRUE>MLPI_SIZEOF_BOOLEAN_VALUE_FALSE?MLPI_SIZEOF_BOOLEAN_VALUE_TRUE:MLPI_SIZEOF_BOOLEAN_VALUE_FALSE;
1977  const ULONG dataBuffLen = (MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE<dataBuffLenTemp1?MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE:dataBuffLenTemp1) / sizeof(WCHAR16);
1978  WCHAR16 dataUtf16Local[dataBuffLen];
1979 
1980  // Remove leading spaces
1981  while(*dataUtf16==MLPI_VALUE_SEPARATOR_UTF16)
1982  dataUtf16++;
1983 
1984  memcpy(dataUtf16Local, dataUtf16, dataBuffLen*sizeof(WCHAR16));
1985  dataUtf16Local[dataBuffLen-1] = 0;
1986 
1987  for(ULONG idx=0; idx<dataBuffLen; idx++, dataUtf16++) {
1988  if(!dataUtf16Local[idx]) break;
1989  if(dataUtf16Local[idx]==MLPI_VALUE_SEPARATOR_UTF16) {
1990  dataUtf16Local[idx--] = 0;
1991  }
1992  }
1993 
1994  if (wcscmp16_(MLPI_BOOLEAN_VALUE_TRUE, dataUtf16Local)==0)
1995  *data = 1;
1996  else if (wcscmp16_(MLPI_BOOLEAN_VALUE_FALSE, dataUtf16Local)==0)
1997  *data = 0;
1998  else
1999  mlpiResult = MLPI_E_NOTSUPPORTED;
2000 
2001  // Remove separator spaces
2002  while(*dataUtf16==MLPI_VALUE_SEPARATOR_UTF16)
2003  dataUtf16++;
2004 
2005  if(dataUtf16Next!=NULL)
2006  *dataUtf16Next = const_cast<WCHAR16*>(dataUtf16);
2007  }
2008  return mlpiResult;
2009 }
2010 
2011 template <typename T>
2012 inline MLPIRESULT mlpiConvertUtf16ToUdecData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, T *data )
2013 {
2014  MLPIRESULT mlpiResult = MLPI_S_OK;
2015 
2016  if(dataUtf16==NULL) {
2017  mlpiResult = MLPI_E_INVALIDARG;
2018  }
2019  else if(data==NULL) {
2020  mlpiResult = MLPI_E_INVALIDARG;
2021  }
2022  else
2023  {
2024  T data_ = 0;
2025 
2026  // Remove leading spaces
2027  while(*dataUtf16==MLPI_VALUE_SEPARATOR_UTF16)
2028  dataUtf16++;
2029 
2030  // Remove leading zeros
2031  while( (*dataUtf16=='0') || (*dataUtf16=='+') )
2032  dataUtf16++;
2033 
2034  if(*dataUtf16!=0)
2035  {
2036  switch(*dataUtf16)
2037  {
2038  case 'b':
2039  case 'B':
2040  {
2041  // hide 'b', accept only hex characters, but ignore separators '.'
2042  for(dataUtf16++; (*dataUtf16!=0) && (*dataUtf16!=MLPI_VALUE_SEPARATOR_UTF16); dataUtf16++)
2043  {
2044  if(*dataUtf16=='.')
2045  continue;
2046  if( (*dataUtf16=='0') || (*dataUtf16=='1') )
2047  data_ = (data_ << 1) | (*dataUtf16=='1');
2048  else {
2049  mlpiResult = MLPI_E_INVALIDARG;
2050  break;
2051  }
2052  }
2053  break;
2054  }
2055  case 'x':
2056  case 'X':
2057  {
2058  // hide 'x', accept only hex characters, but ignore separators '.'
2059  for(dataUtf16++; (*dataUtf16!=0) && (*dataUtf16!=MLPI_VALUE_SEPARATOR_UTF16); dataUtf16++)
2060  {
2061  if(*dataUtf16=='.')
2062  continue;
2063  if( (*dataUtf16>='0') && (*dataUtf16<='9') )
2064  data_ = data_*16 + (*dataUtf16-'0');
2065  else if ( (*dataUtf16>='a') && (*dataUtf16<='f') )
2066  data_ = data_*16 + (*dataUtf16-'a'+10);
2067  else if ( (*dataUtf16>='A') && (*dataUtf16<='F') )
2068  data_ = data_*16 + (*dataUtf16-'A'+10);
2069  else {
2070  mlpiResult = MLPI_E_INVALIDARG;
2071  break;
2072  }
2073  }
2074  break;
2075  }
2076  case 'o':
2077  case 'O':
2078  {
2079  // hide 'o', accept only octal characters, but ignore separators '.'
2080  for(dataUtf16++; (*dataUtf16!=0) && (*dataUtf16!=MLPI_VALUE_SEPARATOR_UTF16); dataUtf16++)
2081  {
2082  if(*dataUtf16=='.')
2083  continue;
2084  if( (*dataUtf16>='0') && (*dataUtf16<='7') )
2085  data_ = data_*8 + (*dataUtf16-'0');
2086  else {
2087  mlpiResult = MLPI_E_INVALIDARG;
2088  break;
2089  }
2090  }
2091  break;
2092  }
2093  default:
2094  {
2095  // accept only decimal characters, but set special error code if decimal place separator '.' occurs
2096  for( ; (*dataUtf16!=0) && (*dataUtf16!=MLPI_VALUE_SEPARATOR_UTF16); dataUtf16++)
2097  {
2098  if(*dataUtf16=='.') {
2099  mlpiResult = MLPI_E_NOTSUPPORTED;
2100  break;
2101  }
2102  if( (*dataUtf16>='0') && (*dataUtf16<='9') )
2103  data_ = data_*10 + (*dataUtf16-'0');
2104  else {
2105  mlpiResult = MLPI_E_INVALIDARG;
2106  break;
2107  }
2108  }
2109  break;
2110  }
2111  }
2112  }
2113 
2114  if(MLPI_SUCCEEDED(mlpiResult))
2115  *data = data_;
2116 
2117  // Remove separator spaces
2118  while(*dataUtf16==MLPI_VALUE_SEPARATOR_UTF16)
2119  dataUtf16++;
2120 
2121  if(dataUtf16Next!=NULL)
2122  *dataUtf16Next = const_cast<WCHAR16*>(dataUtf16);
2123  }
2124  return mlpiResult;
2125 }
2126 template <> inline MLPIRESULT mlpiConvertUtf16ToUdecData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, FLOAT *data ) { return MLPI_E_INVALIDSIGNATURE; }
2127 template <> inline MLPIRESULT mlpiConvertUtf16ToUdecData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, DOUBLE *data ) { return MLPI_E_INVALIDSIGNATURE; }
2128 
2129 
2130 template <typename T>
2131 inline MLPIRESULT mlpiConvertUtf16ToDecData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, T *data )
2132 {
2133  MLPIRESULT mlpiResult = MLPI_S_OK;
2134 
2135  if(dataUtf16==NULL) {
2136  mlpiResult = MLPI_E_INVALIDARG;
2137  }
2138  else if(data==NULL) {
2139  mlpiResult = MLPI_E_INVALIDARG;
2140  }
2141  else
2142  {
2143  BOOL8 signFlag = FALSE;
2144  T data_ = 0;
2145 
2146  // Remove leading spaces
2147  while(*dataUtf16==MLPI_VALUE_SEPARATOR_UTF16)
2148  dataUtf16++;
2149 
2150  // Remove leading zeros
2151  while( (*dataUtf16=='0') || (*dataUtf16=='+') )
2152  dataUtf16++;
2153 
2154  // recognize sign
2155  if(*dataUtf16=='-') {
2156  signFlag = TRUE;
2157  dataUtf16++;
2158  }
2159 
2160  // accept only decimal characters, but set special error code if decimal place separator '.' occurs
2161  for( ; (*dataUtf16!=0) && (*dataUtf16!=MLPI_VALUE_SEPARATOR_UTF16); dataUtf16++)
2162  {
2163  if(*dataUtf16=='.') {
2164  mlpiResult = MLPI_E_NOTSUPPORTED;
2165  break;
2166  }
2167  if( (*dataUtf16>='0') && (*dataUtf16<='9') )
2168  data_ = data_*10 + (*dataUtf16-'0');
2169  else {
2170  mlpiResult = MLPI_E_INVALIDARG;
2171  break;
2172  }
2173  }
2174 
2175  if(MLPI_SUCCEEDED(mlpiResult))
2176  {
2177  if(signFlag==TRUE)
2178  *data = -data_;
2179  else
2180  *data = data_;
2181  }
2182 
2183  // Remove separator spaces
2184  while(*dataUtf16==MLPI_VALUE_SEPARATOR_UTF16)
2185  dataUtf16++;
2186 
2187  if(dataUtf16Next!=NULL)
2188  *dataUtf16Next = const_cast<WCHAR16*>(dataUtf16);
2189  }
2190  return mlpiResult;
2191 }
2192 template <> inline MLPIRESULT mlpiConvertUtf16ToDecData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, FLOAT *data ) { return MLPI_E_INVALIDSIGNATURE; }
2193 template <> inline MLPIRESULT mlpiConvertUtf16ToDecData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, DOUBLE *data ) { return MLPI_E_INVALIDSIGNATURE; }
2194 template <> inline MLPIRESULT mlpiConvertUtf16ToDecData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, ULLONG *data ) { return MLPI_E_INVALIDSIGNATURE; }
2195 template <> inline MLPIRESULT mlpiConvertUtf16ToDecData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, ULONG *data ) { return MLPI_E_INVALIDSIGNATURE; }
2196 template <> inline MLPIRESULT mlpiConvertUtf16ToDecData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, USHORT *data ) { return MLPI_E_INVALIDSIGNATURE; }
2197 template <> inline MLPIRESULT mlpiConvertUtf16ToDecData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, UCHAR *data ) { return MLPI_E_INVALIDSIGNATURE; }
2198 
2199 
2200 template <typename T>
2201 inline MLPIRESULT mlpiConvertUtf16ToFloatData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, T *data )
2202 {
2203  MLPIRESULT mlpiResult = MLPI_S_OK;
2204 
2205  if(dataUtf16==NULL) {
2206  mlpiResult = MLPI_E_INVALIDARG;
2207  }
2208  else if(data==NULL) {
2209  mlpiResult = MLPI_E_INVALIDARG;
2210  }
2211  else
2212  {
2213  const ULONG dataBuffLen = MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE;
2214  CHAR dataUtf8[dataBuffLen] = "";
2215  CHAR* dataUtf8End = NULL;
2216 
2217  // Remove leading spaces
2218  while(*dataUtf16==MLPI_VALUE_SEPARATOR_UTF16)
2219  dataUtf16++;
2220 
2221  wcstombs16(dataUtf8, dataUtf16, MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE);
2222  dataUtf8[MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE-1] = 0;
2223 
2224  DOUBLE data_ = strtod(dataUtf8, &dataUtf8End);
2225 
2226  if(dataUtf8End==&dataUtf8[MLPI_CONVERT_VALUE_TO_WCHAR16_BUFFER_STACK_SIZE-1]) {
2227  // Insufficient stack buffer size
2228  mlpiResult = MLPI_E_SYSTEMERROR;
2229  }
2230  else
2231  {
2232  if( (*dataUtf8End==0) || (*dataUtf8End==MLPI_VALUE_SEPARATOR_UTF8) )
2233  {
2234  switch(sizeof(T))
2235  {
2236  default: mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2237  case sizeof(UCHAR): mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2238  case sizeof(USHORT): mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2239  case sizeof(FLOAT): *data = (T) data_; break;
2240  case sizeof(DOUBLE): *data = (T) data_; break;
2241  }
2242 
2243  if(MLPI_SUCCEEDED(mlpiResult))
2244  {
2245  // Remove separator spaces
2246  while(*dataUtf8End==MLPI_VALUE_SEPARATOR_UTF8)
2247  dataUtf8End++;
2248  if(dataUtf16Next!=NULL)
2249  *dataUtf16Next = const_cast<WCHAR16*>(&dataUtf16[dataUtf8End-dataUtf8]);
2250  }
2251  }
2252  else {
2253  mlpiResult = MLPI_E_INVALIDARG;
2254  }
2255  }
2256  }
2257  return mlpiResult;
2258 }
2259 
2260 
2261 template <typename T>
2262 inline MLPIRESULT mlpiConvertUtf16ToUintIdnData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, T *data )
2263 {
2264  MLPIRESULT mlpiResult = MLPI_S_OK;
2265 
2266  if(dataUtf16==NULL) {
2267  mlpiResult = MLPI_E_INVALIDARG;
2268  }
2269  else if(data==NULL) {
2270  mlpiResult = MLPI_E_INVALIDARG;
2271  }
2272  else
2273  {
2274  ULONG address = 0;
2275  ULLONG type = 0, set = 0, block = 0, si = 0, se = 0;
2276 
2277  // Remove leading spaces
2278  while(*dataUtf16==MLPI_VALUE_SEPARATOR_UTF16)
2279  dataUtf16++;
2280 
2281  mlpiResult = utilParameterParseIdn(dataUtf16, &address, &type, &set, &block, &si, &se, dataUtf16Next);
2282  if(MLPI_SUCCEEDED(mlpiResult))
2283  {
2284  if( (address!=0) || ((type!=MLPI_SIDN_TYPE_DRIVE_S)&&(type!=MLPI_SIDN_TYPE_DRIVE_P)) )
2285  mlpiResult = MLPI_E_INVALIDARG;
2286  else
2287  {
2288  switch(sizeof(T))
2289  {
2290  default: mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2291  case sizeof(UCHAR): mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2292  case sizeof(USHORT): ((si!=0)||(se!=0)) ? mlpiResult = MLPI_E_INVALIDARG : *data = (T) MLPI_SIDN(type, set, block, si, se); break;
2293  case sizeof(ULONG): *data = (T) MLPI_SIDN(type, set, block, si, se); break;
2294  case sizeof(ULLONG): mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2295  }
2296  }
2297  }
2298  }
2299  return mlpiResult;
2300 }
2301 template <> inline MLPIRESULT mlpiConvertUtf16ToUintIdnData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, FLOAT *data ) { return MLPI_E_INVALIDSIGNATURE; }
2302 template <> inline MLPIRESULT mlpiConvertUtf16ToUintIdnData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, DOUBLE *data ) { return MLPI_E_INVALIDSIGNATURE; }
2303 
2304 
2305 template <typename T>
2306 inline MLPIRESULT mlpiConvertUtf16ToMlcIdnData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, T *data )
2307 {
2308  MLPIRESULT mlpiResult = MLPI_S_OK;
2309 
2310  if(dataUtf16==NULL) {
2311  mlpiResult = MLPI_E_INVALIDARG;
2312  }
2313  else if(data==NULL) {
2314  mlpiResult = MLPI_E_INVALIDARG;
2315  }
2316  else
2317  {
2318  ULONG address = 0;
2319  ULLONG type = 0, set = 0, block = 0, si = 0, se = 0;
2320 
2321  // Remove leading spaces
2322  while(*dataUtf16==MLPI_VALUE_SEPARATOR_UTF16)
2323  dataUtf16++;
2324 
2325  mlpiResult = utilParameterParseIdn(dataUtf16, &address, &type, &set, &block, &si, &se, dataUtf16Next);
2326  if(MLPI_SUCCEEDED(mlpiResult))
2327  {
2328  if(address>0xFF) {
2329  mlpiResult = MLPI_E_INVALIDARG;
2330  }
2331  else
2332  {
2333  switch(sizeof(T))
2334  {
2335  default: mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2336  case sizeof(UCHAR): mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2337  case sizeof(USHORT): mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2338  case sizeof(ULONG): mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2339  case sizeof(ULLONG): *data = (T) (((T) MLPI_SIDN(type, set, block, si, se)) | (((ULLONG) address) << 56)); break;
2340  }
2341  }
2342  }
2343  }
2344  return mlpiResult;
2345 }
2346 template <> inline MLPIRESULT mlpiConvertUtf16ToMlcIdnData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, FLOAT *data ) { return MLPI_E_INVALIDSIGNATURE; }
2347 template <> inline MLPIRESULT mlpiConvertUtf16ToMlcIdnData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, DOUBLE *data ) { return MLPI_E_INVALIDSIGNATURE; }
2348 
2349 
2350 template <typename T>
2351 inline MLPIRESULT mlpiConvertUtf16ToSercosTimeData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, T *data )
2352 {
2353  MLPIRESULT mlpiResult = MLPI_S_OK;
2354 
2355  if(dataUtf16==NULL) {
2356  mlpiResult = MLPI_E_INVALIDARG;
2357  }
2358  else if(data==NULL) {
2359  mlpiResult = MLPI_E_INVALIDARG;
2360  }
2361  else
2362  {
2363  // Remove leading spaces
2364  while(*dataUtf16==MLPI_VALUE_SEPARATOR_UTF16)
2365  dataUtf16++;
2366 
2367  switch(sizeof(T))
2368  {
2369  default: mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2370  case sizeof(UCHAR): mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2371  case sizeof(USHORT): mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2372  case sizeof(ULONG): mlpiResult = MLPI_E_INVALIDSIGNATURE; break;
2373  case sizeof(ULLONG):
2374  {
2375  ULLONG data_=0;
2376  mlpiResult = utilParameterParseStringToSercosTime(dataUtf16, MLPI_VALUE_SEPARATOR_UTF16, &data_, dataUtf16Next);
2377  if(MLPI_SUCCEEDED(mlpiResult))
2378  *data = (T) (data_);
2379  else
2380  mlpiResult = MLPI_E_INVALIDARG;
2381  break;
2382  }
2383  }
2384  }
2385  return mlpiResult;
2386 }
2387 template <> inline MLPIRESULT mlpiConvertUtf16ToSercosTimeData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, FLOAT *data ) { return MLPI_E_INVALIDSIGNATURE; }
2388 template <> inline MLPIRESULT mlpiConvertUtf16ToSercosTimeData( const WCHAR16* dataUtf16, WCHAR16** dataUtf16Next, DOUBLE *data ) { return MLPI_E_INVALIDSIGNATURE; }
2389 
2390 #endif /* __MLPIPARAMETERHELPER_H__ */
MLPI_SIDN_TYPE_POSLIMSWITCH
#define MLPI_SIDN_TYPE_POSLIMSWITCH
This definition represents the valid type of an N parameter ident.
Definition: mlpiParameterLib.h:458
MLPI_TYPE_LLONG
8 byte signed integer
Definition: mlpiGlobal.h:227
MLPI_S_OK
#define MLPI_S_OK
Return code "everything okay".
Definition: mlpiGlobal.h:363
UCHAR
unsigned char UCHAR
1 byte unsigned integer
Definition: mlpiGlobal.h:160
MLPI_TYPE_CHAR_UTF16
string with 2 bytes per character
Definition: mlpiGlobal.h:247
MLPI_TYPE_INVALID
invalid or not supported type
Definition: mlpiGlobal.h:219
MLPI_SIDN_SI_MASK
#define MLPI_SIDN_SI_MASK
This definition masks the element SI of a parameter ident.
Definition: mlpiParameterLib.h:479
MLPI_TYPE_LONG_ARRAY
4 byte signed integer array
Definition: mlpiGlobal.h:236
ULLONG
unsigned long long ULLONG
8 byte unsigned integer
Definition: mlpiGlobal.h:171
LONG
int LONG
4 byte signed integer
Definition: mlpiGlobal.h:164
MLPI_TYPE_SHORT
2 byte signed integer
Definition: mlpiGlobal.h:223
MLPI_SIDN_SI
#define MLPI_SIDN_SI(sidn)
This macro splits an EIDN SI like <TYPE-SET-BLOCK>.<SI>.<SE>
Definition: mlpiParameterLib.h:617
wcstombs16
size_t wcstombs16(char *dst, const WCHAR16 *src, size_t len)
Function translates WCHAR16 characters from the sequence pointed by src to the multibyte equivalent s...
Definition: wchar16.h:449
CHAR
char CHAR
1 byte signed integer
Definition: mlpiGlobal.h:159
utilParameterParseStringToSercosTime
MLPIRESULT utilParameterParseStringToSercosTime(const CHAR *time, const CHAR separator, ULLONG *timeStamp, CHAR **timeNext=NULL)
This function parse a sercos time string (CHAR) and returns a 64-bit sercos time value. Structure of sercos time Bit 63-32: seconds since 1970-01-01, 00:00:00 Nit 31-00: nanoseconds up to 999.999.999.
Definition: mlpiParameterHelper.h:1012
BOOL8
signed char BOOL8
1 byte boolean
Definition: mlpiGlobal.h:158
MlpiParameterCommandStatus
MlpiParameterCommandStatus
This enumeration defines the status of a command execution using mlpiParameterReadCommandStatus.
Definition: mlpiParameterLib.h:675
MLPI_SIDN_SET
#define MLPI_SIDN_SET(sidn)
This macro splits an EIDN set like <TYPE-SET-BLOCK>.<SI>.<SE>
Definition: mlpiParameterLib.h:607
USHORT
unsigned short USHORT
2 byte unsigned integer
Definition: mlpiGlobal.h:162
MLPI_TYPE_FLOAT
4 byte floating point
Definition: mlpiGlobal.h:229
MLPI_TYPE_USHORT_ARRAY
2 byte unsigned integer array
Definition: mlpiGlobal.h:235
mbstowcs16
size_t mbstowcs16(WCHAR16 *dst, const char *src, size_t len)
Function converts a sequence of multibyte characters to a corresponding sequence of WCHAR16 character...
Definition: wchar16.h:473
utilParameterParseIdn
MLPIRESULT utilParameterParseIdn(const WCHAR16 *idn, ULONG *address, ULLONG *type, ULLONG *set, ULLONG *block, ULLONG *si, ULLONG *se, WCHAR16 **idnNxt=NULL)
This function parses a Sercos IDN string and returns its properties. These can be used to build a bin...
Definition: mlpiParameterHelper.h:542
MLPI_SIDN_SE
#define MLPI_SIDN_SE(sidn)
This macro splits an EIDN SE like <TYPE-SET-BLOCK>.<SI>.<SE>
Definition: mlpiParameterLib.h:622
MLPI_SIDN_TYPE_DRIVE_S
#define MLPI_SIDN_TYPE_DRIVE_S
This definition represents the valid type of an S parameter ident.
Definition: mlpiParameterLib.h:440
MLPI_SIDN_BLOCK_MASK
#define MLPI_SIDN_BLOCK_MASK
This definition masks the element block of a parameter ident.
Definition: mlpiParameterLib.h:473
MLPI_E_INVALIDARG
#define MLPI_E_INVALIDARG
Invalid argument given to method.
Definition: mlpiGlobal.h:366
SHORT
short SHORT
2 byte signed integer
Definition: mlpiGlobal.h:161
MLPI_TYPE_ULLONG
8 byte unsigned integer
Definition: mlpiGlobal.h:228
utilParameterGetWriteProtectionFromAttribute
ParamWriteProtection utilParameterGetWriteProtectionFromAttribute(const ULONG attribute)
This Function extracts the write protection of a parameter in certain states which is coded in Sercos...
Definition: mlpiParameterHelper.h:507
MLPI_SIDN_INST
#define MLPI_SIDN_INST(sidn)
This macro splits an EIDN address like <INSTANCE>:<TYPE-SET-BLOCK>.<SI>.<SE>
Definition: mlpiParameterLib.h:597
MLPI_SIDN_SET_MASK
#define MLPI_SIDN_SET_MASK
This definition masks the element set of a parameter ident.
Definition: mlpiParameterLib.h:470
MlpiReadEverythingDataAccess
This class helps to access the data read via the &#39;mlpiParameterReadEverything&#39; function.
Definition: mlpiParameterHelper.h:1289
utilParameterGetProcedureCmdFromAttribute
BOOL8 utilParameterGetProcedureCmdFromAttribute(const ULONG attribute)
This Function extracts the &#39;procedure command&#39; property which is coded in Sercos attribute.
Definition: mlpiParameterHelper.h:463
MLPI_E_INVALIDSIGNATURE
#define MLPI_E_INVALIDSIGNATURE
Invalid signature.
Definition: mlpiGlobal.h:374
WCHAR16
wchar_t WCHAR16
UTF16 string.
Definition: mlpiGlobal.h:193
ULONG
unsigned int ULONG
4 byte unsigned integer
Definition: mlpiGlobal.h:165
MLPI_TYPE_LLONG_ARRAY
8 byte signed integer array
Definition: mlpiGlobal.h:238
MLPI_SUCCEEDED
#define MLPI_SUCCEEDED(hr)
Returns true if given error code was successful.
Definition: mlpiGlobal.h:406
MLPI_TYPE_FLOAT_ARRAY
4 byte floating point array
Definition: mlpiGlobal.h:240
MLPI_E_NOTSUPPORTED
#define MLPI_E_NOTSUPPORTED
The given function is not supported yet.
Definition: mlpiGlobal.h:365
MLPI_SIDN_TYPE_AXIS
#define MLPI_SIDN_TYPE_AXIS
This definition represents the valid type of an A parameter ident.
Definition: mlpiParameterLib.h:446
MLPI_TYPE_DOUBLE_ARRAY
8 byte floating point array
Definition: mlpiGlobal.h:241
MLPI_SIDN_TYPE_PROBE
#define MLPI_SIDN_TYPE_PROBE
This definition represents the valid type of an M parameter ident.
Definition: mlpiParameterLib.h:455
MLPI_TYPE_UCHAR
1 byte unsigned integer
Definition: mlpiGlobal.h:222
MLPI_SIDN_TYPE_OSCILLOSCOPE
#define MLPI_SIDN_TYPE_OSCILLOSCOPE
This definition represents the valid type of an O parameter ident.
Definition: mlpiParameterLib.h:461
MLPI_SIDN_TYPE_DRIVE_P
#define MLPI_SIDN_TYPE_DRIVE_P
This definition represents the valid type of a P parameter ident.
Definition: mlpiParameterLib.h:443
MLPI_E_UNIMPLEMENTED
#define MLPI_E_UNIMPLEMENTED
The given function is not implemented on this specific device.
Definition: mlpiGlobal.h:378
MLPI_SIDN_SE_MASK
#define MLPI_SIDN_SE_MASK
This definition masks the element SE of a parameter ident.
Definition: mlpiParameterLib.h:476
MLPI_TYPE_ULONG_ARRAY
4 byte unsigned integer array
Definition: mlpiGlobal.h:237
MLPI_PARAMETER_COMMAND_STATUS_INVALID
Error, command status invalid.
Definition: mlpiParameterLib.h:683
utilParameterParseSercosTimeToString
MLPIRESULT utilParameterParseSercosTimeToString(const ULLONG timeStamp, CHAR *time, const ULONG numElements, ULONG *numElementsRet=NULL)
This function parse a 64-bit sercos time value and returns a sercos time string (CHAR). Structure of sercos time Bit 63-32: seconds since 1970-01-01, 00:00:00 Nit 31-00: nanoseconds up to 999.999.999.
Definition: mlpiParameterHelper.h:901
wcschr16
WCHAR16 * wcschr16(const WCHAR16 *src, WCHAR16 character)
Function searches a WCHAR16 character in a WCHAR16 string.
Definition: wchar16.h:133
MLPI_TYPE_DOUBLE
8 byte floating point
Definition: mlpiGlobal.h:230
MLPI_E_LIMIT_MAX
#define MLPI_E_LIMIT_MAX
The maximum of a limitation is exceeded.
Definition: mlpiGlobal.h:380
MLPI_TYPE_CHAR
1 byte signed integer
Definition: mlpiGlobal.h:221
MLPI_SIDN_TYPE_CONTROL
#define MLPI_SIDN_TYPE_CONTROL
This definition represents the valid type of a C parameter ident.
Definition: mlpiParameterLib.h:449
MlpiReadEverything
struct MlpiReadEverything MlpiReadEverything
This structure defines the information returned using mlpiParameterReadEverything.
wtoi16
int wtoi16(const WCHAR16 *src)
Function converts a WCHAR16 string to integer.
Definition: wchar16.h:432
MlpiType
MlpiType
This enumeration defines the basic types of as used by the MLPI.
Definition: mlpiGlobal.h:217
MLPI_TYPE_USHORT
2 byte unsigned integer
Definition: mlpiGlobal.h:224
MLPI_E_BUFFERTOOSHORT
#define MLPI_E_BUFFERTOOSHORT
Given buffer is too short.
Definition: mlpiGlobal.h:373
MLPI_TYPE_SHORT_ARRAY
2 byte signed integer array
Definition: mlpiGlobal.h:234
utilParameterGetDataTypeFromAttribute
MlpiType utilParameterGetDataTypeFromAttribute(const ULONG attribute)
This Function extracts the data type which is coded in Sercos attribute and translates it the an MLPI...
Definition: mlpiParameterHelper.h:400
MLPI_TYPE_ULONG
4 byte unsigned integer
Definition: mlpiGlobal.h:226
LLONG
long long LLONG
8 byte signed integer
Definition: mlpiGlobal.h:170
wcscat16
WCHAR16 * wcscat16(WCHAR16 *dst, const WCHAR16 *src)
Function appends a WCHAR16 string to another.
Definition: wchar16.h:246
FLOAT
float FLOAT
4 byte floating point
Definition: mlpiGlobal.h:172
utilParameterGetDecimalPointFromAttribute
SHORT utilParameterGetDecimalPointFromAttribute(const ULONG attribute)
This Function extracts the places after decimal point which is coded in Sercos attribute.
Definition: mlpiParameterHelper.h:478
MLPI_SIDN_BLOCK
#define MLPI_SIDN_BLOCK(sidn)
This macro splits an EIDN block like <TYPE-SET-BLOCK>.<SI>.<SE>
Definition: mlpiParameterLib.h:612
DOUBLE
double DOUBLE
8 byte floating point
Definition: mlpiGlobal.h:177
MLPI_E_SYSTEMERROR
#define MLPI_E_SYSTEMERROR
System error during execution.
Definition: mlpiGlobal.h:372
MLPI_TYPE_ULLONG_ARRAY
8 byte unsigned integer array
Definition: mlpiGlobal.h:239
wcscpy16
WCHAR16 * wcscpy16(WCHAR16 *dst, const WCHAR16 *src)
Function copies a WCHAR16 string.
Definition: wchar16.h:210
PARAM_SERCOS_TIME_STRING_LENGTH
#define PARAM_SERCOS_TIME_STRING_LENGTH
Maximum length of sercos time string.
Definition: mlpiParameterHelper.h:177
MLPI_SIDN_TYPE_MASK
#define MLPI_SIDN_TYPE_MASK
This definition masks the element type of a parameter ident.
Definition: mlpiParameterLib.h:467
MLPI_SIDN_TYPE_KINEMATIC
#define MLPI_SIDN_TYPE_KINEMATIC
This definition represents the valid type of a K parameter ident.
Definition: mlpiParameterLib.h:452
utilParameterSplitSidn
MLPIRESULT utilParameterSplitSidn(const ULLONG sidn, ULLONG *idn, ULONG *address)
Some SIDNs contain the address field in the upper byte of the reserved space. Use this function to cu...
Definition: mlpiParameterHelper.h:712
MLPI_SIDN
#define MLPI_SIDN(type, set, block, si, se)
This macro creates the 64-bit value of an EIDN like <TYPE-SET-BLOCK>.<SI>.<SE> using all elements of ...
Definition: mlpiParameterLib.h:539
MLPIRESULT
int MLPIRESULT
common MLPI-API return value
Definition: mlpiGlobal.h:198
wcslen16
size_t wcslen16(const WCHAR16 *src)
Definition: wchar16.h:115
MLPI_TYPE_UCHAR_ARRAY
1 byte unsigned integer array
Definition: mlpiGlobal.h:233
PARAM_MAX_IDN_STRING_LENGTH
#define PARAM_MAX_IDN_STRING_LENGTH
Maximum length of parameter ident string.
Definition: mlpiParameterHelper.h:176
MLPI_TYPE_LONG
4 byte signed integer
Definition: mlpiGlobal.h:225