Hopefully fail to break anything in the process of syncing with trunk (r47786)
[reactos.git] / base / applications / rapps / parser.c
1 /*
2 * PROJECT: ReactOS Applications Manager
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: base/applications/rapps/parser.c
5 * PURPOSE: Parser functions
6 * PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
7 */
8
9 #include "rapps.h"
10
11 typedef LONG NTSTATUS;
12
13 typedef struct _UNICODE_STRING {
14 USHORT Length;
15 USHORT MaximumLength;
16 PWSTR Buffer;
17 } UNICODE_STRING, *PUNICODE_STRING;
18
19 void WINAPI RtlInitUnicodeString(PUNICODE_STRING,PCWSTR);
20 NTSTATUS WINAPI RtlUnicodeStringToInteger(const UNICODE_STRING*,ULONG,ULONG*);
21 BOOLEAN WINAPI RtlIsTextUnicode(LPCVOID,INT,INT*);
22
23 static const char bom_utf8[] = {0xEF,0xBB,0xBF};
24
25 typedef enum
26 {
27 ENCODING_UTF8 = 1,
28 ENCODING_UTF16LE,
29 ENCODING_UTF16BE
30 } ENCODING;
31
32 typedef struct tagSECTIONKEY
33 {
34 WCHAR *value;
35 struct tagSECTIONKEY *next;
36 WCHAR name[1];
37 } SECTIONKEY;
38
39 typedef struct tagSECTION
40 {
41 struct tagSECTIONKEY *key;
42 struct tagSECTION *next;
43 WCHAR name[1];
44 } SECTION;
45
46 typedef struct
47 {
48 BOOL changed;
49 SECTION *section;
50 WCHAR *filename;
51 ENCODING encoding;
52 } ITEMS;
53
54
55 #define N_CACHED_ITEMS 10
56 static ITEMS *ItemsArray[N_CACHED_ITEMS] = {NULL};
57 #define CurProfile (ItemsArray[0])
58 #define IS_ENTRY_COMMENT(str) ((str)[0] == ';')
59 #define ParserIsSpace(c) (iswspace(c) || c == 0x1a)
60
61
62 static
63 WCHAR*
64 memchrW(const WCHAR *ptr, WCHAR ch, size_t n)
65 {
66 const WCHAR *end;
67 for (end = ptr + n; ptr < end; ptr++)
68 if (*ptr == ch)
69 return (WCHAR *)(ULONG_PTR)ptr;
70 return NULL;
71 }
72
73 static
74 WCHAR
75 *memrchrW(const WCHAR *ptr, WCHAR ch, size_t n)
76 {
77 const WCHAR *end;
78 WCHAR *ret = NULL;
79 for (end = ptr + n; ptr < end; ptr++)
80 if (*ptr == ch)
81 ret = (WCHAR *)(ULONG_PTR)ptr;
82 return ret;
83 }
84
85 static
86 void
87 ParserCopyEntry(LPWSTR buffer, LPCWSTR value, int len, BOOL strip_quote)
88 {
89 WCHAR quote = '\0';
90
91 if (!buffer) return;
92
93 if (strip_quote && ((*value == '\'') || (*value == '\"')))
94 {
95 if (value[1] && (value[wcslen(value)-1] == *value))
96 quote = *value++;
97 }
98
99 lstrcpynW(buffer, value, len);
100 if (quote && (len >= (int)wcslen(value))) buffer[wcslen(buffer)-1] = '\0';
101 }
102
103 static
104 void
105 ParserByteSwapShortBuffer(WCHAR * buffer, int len)
106 {
107 int i;
108 USHORT * shortbuffer = buffer;
109 for (i = 0; i < len; i++)
110 shortbuffer[i] = (shortbuffer[i] >> 8) | (shortbuffer[i] << 8);
111 }
112
113 static
114 void
115 ParserWriteMarker(HANDLE hFile, ENCODING encoding)
116 {
117 DWORD dwBytesWritten;
118 WCHAR bom;
119
120 switch (encoding)
121 {
122 case ENCODING_UTF8:
123 WriteFile(hFile, bom_utf8, sizeof(bom_utf8), &dwBytesWritten, NULL);
124 break;
125
126 case ENCODING_UTF16LE:
127 bom = 0xFEFF;
128 WriteFile(hFile, &bom, sizeof(bom), &dwBytesWritten, NULL);
129 break;
130
131 case ENCODING_UTF16BE:
132 bom = 0xFFFE;
133 WriteFile(hFile, &bom, sizeof(bom), &dwBytesWritten, NULL);
134 break;
135 }
136 }
137
138 static
139 void
140 ParserWriteLine(HANDLE hFile, WCHAR * szLine, int len, ENCODING encoding)
141 {
142 char * write_buffer;
143 int write_buffer_len;
144 DWORD dwBytesWritten;
145
146 switch (encoding)
147 {
148 case ENCODING_UTF8:
149 write_buffer_len = WideCharToMultiByte(CP_UTF8, 0, szLine, len, NULL, 0, NULL, NULL);
150 write_buffer = HeapAlloc(GetProcessHeap(), 0, write_buffer_len);
151 if (!write_buffer) return;
152 len = WideCharToMultiByte(CP_UTF8, 0, szLine, len, write_buffer, write_buffer_len, NULL, NULL);
153 WriteFile(hFile, write_buffer, len, &dwBytesWritten, NULL);
154 HeapFree(GetProcessHeap(), 0, write_buffer);
155 break;
156
157 case ENCODING_UTF16LE:
158 WriteFile(hFile, szLine, len * sizeof(WCHAR), &dwBytesWritten, NULL);
159 break;
160
161 case ENCODING_UTF16BE:
162 ParserByteSwapShortBuffer(szLine, len);
163 WriteFile(hFile, szLine, len * sizeof(WCHAR), &dwBytesWritten, NULL);
164 break;
165 }
166 }
167
168 static
169 void
170 ParserSave(HANDLE hFile, const SECTION *section, ENCODING encoding)
171 {
172 SECTIONKEY *key;
173 WCHAR *buffer, *p;
174
175 ParserWriteMarker(hFile, encoding);
176
177 for ( ; section; section = section->next)
178 {
179 int len = 0;
180
181 if (section->name[0]) len += wcslen(section->name) + 4;
182
183 for (key = section->key; key; key = key->next)
184 {
185 len += wcslen(key->name) + 2;
186 if (key->value) len += wcslen(key->value) + 1;
187 }
188
189 buffer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
190 if (!buffer) return;
191
192 p = buffer;
193 if (section->name[0])
194 {
195 *p++ = '[';
196 wcscpy(p, section->name);
197 p += wcslen(p);
198 *p++ = ']';
199 *p++ = '\r';
200 *p++ = '\n';
201 }
202
203 for (key = section->key; key; key = key->next)
204 {
205 wcscpy(p, key->name);
206 p += wcslen(p);
207 if (key->value)
208 {
209 *p++ = '=';
210 wcscpy(p, key->value);
211 p += wcslen(p);
212 }
213 *p++ = '\r';
214 *p++ = '\n';
215 }
216 ParserWriteLine(hFile, buffer, len, encoding);
217 HeapFree(GetProcessHeap(), 0, buffer);
218 }
219 }
220
221 static
222 void
223 ParserFree(SECTION *section)
224 {
225 SECTION *next_section;
226 SECTIONKEY *key, *next_key;
227
228 for ( ; section; section = next_section)
229 {
230 for (key = section->key; key; key = next_key)
231 {
232 next_key = key->next;
233 HeapFree(GetProcessHeap(), 0, key->value);
234 HeapFree(GetProcessHeap(), 0, key);
235 }
236 next_section = section->next;
237 HeapFree(GetProcessHeap(), 0, section);
238 }
239 }
240
241 static
242 ENCODING
243 ParserDetectTextEncoding(const void * buffer, int * len)
244 {
245 INT flags = IS_TEXT_UNICODE_SIGNATURE |
246 IS_TEXT_UNICODE_REVERSE_SIGNATURE |
247 IS_TEXT_UNICODE_ODD_LENGTH;
248
249 if (*len >= sizeof(bom_utf8) && !memcmp(buffer, bom_utf8, sizeof(bom_utf8)))
250 {
251 *len = sizeof(bom_utf8);
252 return ENCODING_UTF8;
253 }
254
255 RtlIsTextUnicode((void *)buffer, *len, &flags);
256
257 if (flags & IS_TEXT_UNICODE_SIGNATURE)
258 {
259 *len = sizeof(WCHAR);
260 return ENCODING_UTF16LE;
261 }
262
263 if (flags & IS_TEXT_UNICODE_REVERSE_SIGNATURE)
264 {
265 *len = sizeof(WCHAR);
266 return ENCODING_UTF16BE;
267 }
268
269 *len = 0;
270
271 return ENCODING_UTF8;
272 }
273
274 static
275 SECTION
276 *ParserLoad(HANDLE hFile, ENCODING * pEncoding)
277 {
278 void *buffer_base, *pBuffer;
279 WCHAR * szFile;
280 const WCHAR *szLineStart, *szLineEnd;
281 const WCHAR *szValueStart, *szEnd, *next_line;
282 int line = 0, len;
283 SECTION *section, *first_section;
284 SECTION **next_section;
285 SECTIONKEY *key, *prev_key, **next_key;
286 DWORD dwFileSize;
287
288 dwFileSize = GetFileSize(hFile, NULL);
289 if (dwFileSize == INVALID_FILE_SIZE || dwFileSize == 0)
290 return NULL;
291
292 buffer_base = HeapAlloc(GetProcessHeap(), 0 , dwFileSize);
293 if (!buffer_base)
294 return NULL;
295
296 if (!ReadFile(hFile, buffer_base, dwFileSize, &dwFileSize, NULL))
297 {
298 HeapFree(GetProcessHeap(), 0, buffer_base);
299 return NULL;
300 }
301
302 len = dwFileSize;
303 *pEncoding = ParserDetectTextEncoding(buffer_base, &len);
304
305 pBuffer = (char *)buffer_base + len;
306 dwFileSize -= len;
307
308 switch (*pEncoding)
309 {
310 case ENCODING_UTF8:
311 len = MultiByteToWideChar(CP_UTF8, 0, pBuffer, dwFileSize, NULL, 0);
312 szFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
313 if (!szFile)
314 {
315 HeapFree(GetProcessHeap(), 0, buffer_base);
316 return NULL;
317 }
318 MultiByteToWideChar(CP_UTF8, 0, pBuffer, dwFileSize, szFile, len);
319 szEnd = szFile + len;
320 break;
321
322 case ENCODING_UTF16LE:
323 szFile = pBuffer;
324 szEnd = (WCHAR *)((char *)pBuffer + dwFileSize);
325 break;
326
327 case ENCODING_UTF16BE:
328 szFile = pBuffer;
329 szEnd = (WCHAR *)((char *)pBuffer + dwFileSize);
330 ParserByteSwapShortBuffer(szFile, dwFileSize / sizeof(WCHAR));
331 break;
332
333 default:
334 HeapFree(GetProcessHeap(), 0, buffer_base);
335 return NULL;
336 }
337
338 first_section = HeapAlloc(GetProcessHeap(), 0, sizeof(*section));
339 if (first_section == NULL)
340 {
341 if (szFile != pBuffer)
342 HeapFree(GetProcessHeap(), 0, szFile);
343 HeapFree(GetProcessHeap(), 0, buffer_base);
344 return NULL;
345 }
346
347 first_section->name[0] = 0;
348 first_section->key = NULL;
349 first_section->next = NULL;
350 next_section = &first_section->next;
351 next_key = &first_section->key;
352 prev_key = NULL;
353 next_line = szFile;
354
355 while (next_line < szEnd)
356 {
357 szLineStart = next_line;
358 next_line = memchrW(szLineStart, '\n', szEnd - szLineStart);
359 if (!next_line) next_line = memchrW(szLineStart, '\r', szEnd - szLineStart);
360 if (!next_line) next_line = szEnd;
361 else next_line++;
362 szLineEnd = next_line;
363
364 line++;
365
366 while (szLineStart < szLineEnd && ParserIsSpace(*szLineStart)) szLineStart++;
367 while ((szLineEnd > szLineStart) && ParserIsSpace(szLineEnd[-1])) szLineEnd--;
368
369 if (szLineStart >= szLineEnd)
370 continue;
371
372 if (*szLineStart == '[')
373 {
374 const WCHAR * szSectionEnd;
375 if ((szSectionEnd = memrchrW(szLineStart, ']', szLineEnd - szLineStart)))
376 {
377 szLineStart++;
378 len = (int)(szSectionEnd - szLineStart);
379 if (!(section = HeapAlloc(GetProcessHeap(), 0, sizeof(*section) + len * sizeof(WCHAR))))
380 break;
381 memcpy(section->name, szLineStart, len * sizeof(WCHAR));
382 section->name[len] = '\0';
383 section->key = NULL;
384 section->next = NULL;
385 *next_section = section;
386 next_section = &section->next;
387 next_key = &section->key;
388 prev_key = NULL;
389
390 continue;
391 }
392 }
393
394 len = szLineEnd - szLineStart;
395 if ((szValueStart = memchrW(szLineStart, '=', szLineEnd - szLineStart)) != NULL)
396 {
397 const WCHAR *szNameEnd = szValueStart;
398 while ((szNameEnd > szLineStart) && ParserIsSpace(szNameEnd[-1])) szNameEnd--;
399 len = szNameEnd - szLineStart;
400 szValueStart++;
401 while (szValueStart < szLineEnd && ParserIsSpace(*szValueStart)) szValueStart++;
402 }
403
404 if (len || !prev_key || *prev_key->name)
405 {
406 if (!(key = HeapAlloc(GetProcessHeap(), 0, sizeof(*key) + len * sizeof(WCHAR)))) break;
407 memcpy(key->name, szLineStart, len * sizeof(WCHAR));
408 key->name[len] = '\0';
409 if (szValueStart)
410 {
411 len = (int)(szLineEnd - szValueStart);
412 key->value = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
413 memcpy(key->value, szValueStart, len * sizeof(WCHAR));
414 key->value[len] = '\0';
415 }
416 else key->value = NULL;
417
418 key->next = NULL;
419 *next_key = key;
420 next_key = &key->next;
421 prev_key = key;
422 }
423 }
424
425 if (szFile != pBuffer)
426 HeapFree(GetProcessHeap(), 0, szFile);
427 HeapFree(GetProcessHeap(), 0, buffer_base);
428
429 return first_section;
430 }
431
432 static
433 SECTIONKEY
434 *ParserFind(SECTION **section, LPCWSTR section_name, LPCWSTR key_name, BOOL create, BOOL create_always)
435 {
436 LPCWSTR p;
437 int seclen, keylen;
438
439 while (ParserIsSpace(*section_name)) section_name++;
440 if (*section_name)
441 p = section_name + wcslen(section_name) - 1;
442 else
443 p = section_name;
444
445 while ((p > section_name) && ParserIsSpace(*p)) p--;
446 seclen = p - section_name + 1;
447
448 while (ParserIsSpace(*key_name)) key_name++;
449 if (*key_name)
450 p = key_name + wcslen(key_name) - 1;
451 else
452 p = key_name;
453
454 while ((p > key_name) && ParserIsSpace(*p)) p--;
455 keylen = p - key_name + 1;
456
457 while (*section)
458 {
459 if (((*section)->name[0])
460 && (!(_wcsnicmp((*section)->name, section_name, seclen)))
461 && (((*section)->name)[seclen] == '\0'))
462 {
463 SECTIONKEY **key = &(*section)->key;
464
465 while (*key)
466 {
467 if(!create_always)
468 {
469 if ((!(_wcsnicmp((*key)->name, key_name, keylen)))
470 && (((*key)->name)[keylen] == '\0'))
471 return *key;
472 }
473 key = &(*key)->next;
474 }
475 if (!create)
476 return NULL;
477 if (!(*key = HeapAlloc(GetProcessHeap(), 0, sizeof(SECTIONKEY) + wcslen(key_name) * sizeof(WCHAR))))
478 return NULL;
479 wcscpy((*key)->name, key_name);
480 (*key)->value = NULL;
481 (*key)->next = NULL;
482 return *key;
483 }
484 section = &(*section)->next;
485 }
486 if (!create) return NULL;
487 *section = HeapAlloc(GetProcessHeap(), 0, sizeof(SECTION) + wcslen(section_name) * sizeof(WCHAR));
488 if(*section == NULL) return NULL;
489 wcscpy((*section)->name, section_name);
490 (*section)->next = NULL;
491 if (!((*section)->key = HeapAlloc(GetProcessHeap(), 0,
492 sizeof(SECTIONKEY) + wcslen(key_name) * sizeof(WCHAR))))
493 {
494 HeapFree(GetProcessHeap(), 0, *section);
495 return NULL;
496 }
497 wcscpy((*section)->key->name, key_name);
498 (*section)->key->value = NULL;
499 (*section)->key->next = NULL;
500 return (*section)->key;
501 }
502
503 static
504 BOOL
505 ParserFlushFile(void)
506 {
507 HANDLE hFile = NULL;
508
509 if (!CurProfile) return FALSE;
510
511 if (!CurProfile->changed) return TRUE;
512
513 hFile = CreateFileW(CurProfile->filename, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
514 NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
515
516 if (hFile == INVALID_HANDLE_VALUE) return FALSE;
517
518 ParserSave(hFile, CurProfile->section, CurProfile->encoding);
519
520 CloseHandle(hFile);
521 CurProfile->changed = FALSE;
522 return TRUE;
523 }
524
525 static
526 void
527 ParserReleaseFile(void)
528 {
529 ParserFlushFile();
530 ParserFree(CurProfile->section);
531 HeapFree(GetProcessHeap(), 0, CurProfile->filename);
532 CurProfile->changed = FALSE;
533 CurProfile->section = NULL;
534 CurProfile->filename = NULL;
535 CurProfile->encoding = ENCODING_UTF8;
536 }
537
538 static
539 BOOL
540 ParserOpen(LPCWSTR filename, BOOL write_access)
541 {
542 WCHAR szDir[MAX_PATH];
543 WCHAR buffer[MAX_PATH];
544 HANDLE hFile = INVALID_HANDLE_VALUE;
545 int i, j;
546 ITEMS *tempProfile;
547 static const WCHAR wszSeparator[] = L"\\rapps\\";
548
549 if (!CurProfile)
550 for (i = 0; i < N_CACHED_ITEMS; i++)
551 {
552 ItemsArray[i] = HeapAlloc(GetProcessHeap(), 0, sizeof(ITEMS));
553 if (ItemsArray[i] == NULL) break;
554 ItemsArray[i]->changed = FALSE;
555 ItemsArray[i]->section = NULL;
556 ItemsArray[i]->filename = NULL;
557 ItemsArray[i]->encoding = ENCODING_UTF8;
558 }
559
560 GetCurrentDirectoryW(MAX_PATH, szDir);
561
562 wcscpy(buffer, szDir);
563 wcscat(buffer, wszSeparator);
564 wcscat(buffer, filename);
565
566 hFile = CreateFileW(buffer, GENERIC_READ | (write_access ? GENERIC_WRITE : 0),
567 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
568 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
569
570 if ((hFile == INVALID_HANDLE_VALUE) && (GetLastError() != ERROR_FILE_NOT_FOUND))
571 {
572 return FALSE;
573 }
574
575 for (i = 0; i < N_CACHED_ITEMS; i++)
576 {
577 if ((ItemsArray[i]->filename && !wcscmp(buffer, ItemsArray[i]->filename)))
578 {
579 if (i)
580 {
581 ParserFlushFile();
582 tempProfile = ItemsArray[i];
583 for (j = i; j > 0; j--)
584 ItemsArray[j] = ItemsArray[j - 1];
585 CurProfile = tempProfile;
586 }
587 if (hFile != INVALID_HANDLE_VALUE)
588 {
589 CloseHandle(hFile);
590 }
591
592 return TRUE;
593 }
594 }
595
596 ParserFlushFile();
597
598 if (i == N_CACHED_ITEMS)
599 {
600 tempProfile = ItemsArray[N_CACHED_ITEMS - 1];
601 for (i = N_CACHED_ITEMS - 1; i > 0; i--)
602 ItemsArray[i] = ItemsArray[i - 1];
603 CurProfile = tempProfile;
604 }
605
606 if (CurProfile->filename) ParserReleaseFile();
607
608 CurProfile->filename = HeapAlloc(GetProcessHeap(), 0, (wcslen(buffer) + 1) * sizeof(WCHAR));
609 if (CurProfile->filename == NULL)
610 return FALSE;
611
612 wcscpy(CurProfile->filename, buffer);
613
614 if (hFile != INVALID_HANDLE_VALUE)
615 {
616 CurProfile->section = ParserLoad(hFile, &CurProfile->encoding);
617 CloseHandle(hFile);
618 }
619 return TRUE;
620 }
621
622 static
623 INT
624 ParserGetSection(SECTION *section, LPCWSTR section_name, LPWSTR buffer, UINT len, BOOL return_values)
625 {
626 SECTIONKEY *key;
627
628 if (!buffer)
629 return 0;
630
631 while (section)
632 {
633 if (section->name[0] && !_wcsicmp(section->name, section_name))
634 {
635 UINT oldlen = len;
636 for (key = section->key; key; key = key->next)
637 {
638 if (len <= 2) break;
639 if (!*key->name) continue; /* Skip empty lines */
640 if (IS_ENTRY_COMMENT(key->name)) continue; /* Skip comments */
641 if (!return_values && !key->value) continue; /* Skip lines w.o. '=' */
642
643 ParserCopyEntry(buffer, key->name, len - 1, 0);
644 len -= wcslen(buffer) + 1;
645 buffer += wcslen(buffer) + 1;
646
647 if (len < 2) break;
648 if (return_values && key->value)
649 {
650 buffer[-1] = '=';
651 ParserCopyEntry(buffer, key->value, len - 1, 0);
652 len -= wcslen(buffer) + 1;
653 buffer += wcslen(buffer) + 1;
654 }
655 }
656 *buffer = '\0';
657 if (len <= 1)
658 {
659 buffer[-1] = '\0';
660 return oldlen - 2;
661 }
662 return oldlen - len;
663 }
664 section = section->next;
665 }
666 buffer[0] = buffer[1] = '\0';
667 return 0;
668 }
669
670 static
671 INT
672 ParserInternalGetString(LPCWSTR section, LPCWSTR key_name, LPWSTR buffer, UINT len)
673 {
674 SECTIONKEY *key = NULL;
675 static const WCHAR empty_strW[] = { 0 };
676
677 if (!buffer || !len) return 0;
678
679 if (key_name)
680 {
681 if (!key_name[0])
682 {
683 ParserCopyEntry(buffer, empty_strW, len, TRUE);
684 return wcslen(buffer);
685 }
686 key = ParserFind(&CurProfile->section, section, key_name, FALSE, FALSE);
687 ParserCopyEntry(buffer, (key && key->value) ? key->value : empty_strW,
688 len, TRUE);
689 return wcslen(buffer);
690 }
691
692 if (section && section[0])
693 {
694 INT ret = ParserGetSection(CurProfile->section, section, buffer, len, FALSE);
695 if (!buffer[0])
696 {
697 ParserCopyEntry(buffer, empty_strW, len, TRUE);
698 ret = wcslen(buffer);
699 }
700 return ret;
701 }
702
703 buffer[0] = '\0';
704 return 0;
705 }
706
707 INT
708 ParserGetString(LPCWSTR Section, LPCWSTR ValueName, LPWSTR Buffer, UINT Len, LPCWSTR FileName)
709 {
710 if (Section == NULL) return 0;
711
712 if (ParserOpen(FileName, FALSE))
713 return ParserInternalGetString(Section, ValueName, Buffer, Len);
714
715 return 0;
716 }
717
718 UINT
719 ParserGetInt(LPCWSTR Section, LPCWSTR ValueName, LPCWSTR FileName)
720 {
721 WCHAR Buffer[30];
722 UNICODE_STRING BufferW;
723 ULONG Result;
724
725 if (!ParserGetString(Section,
726 ValueName,
727 Buffer,
728 sizeof(Buffer) / sizeof(WCHAR),
729 FileName))
730 return -1;
731
732 if (!Buffer[0]) return -1;
733
734 RtlInitUnicodeString(&BufferW, Buffer);
735 RtlUnicodeStringToInteger(&BufferW, 0, &Result);
736 return Result;
737 }