?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 9e645869891abdc47a8701768b7a401b196a1e38
[wine/hacks.git] / dlls / d3dxof / d3dxof.c
blob7c9777107eb5e7c1b7c8602ac8b52f7182dc0af1
1 /*
2 * Implementation of DirectX File Interfaces
3 *
4 * Copyright 2004, 2008 Christian Costa
5 *
6 * This file contains the (internal) driver registration functions,
7 * driver enumeration APIs and DirectDraw creation functions.
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "config.h"
25 #include "wine/debug.h"
26
27 #define COBJMACROS
28
29 #include "winbase.h"
30 #include "wingdi.h"
31
32 #include "d3dxof_private.h"
33 #include "dxfile.h"
34
35 #include <stdio.h>
36
37 WINE_DEFAULT_DEBUG_CHANNEL(d3dxof);
38
39 #define MAKEFOUR(a,b,c,d) ((DWORD)a + ((DWORD)b << 8) + ((DWORD)c << 16) + ((DWORD)d << 24))
40 #define XOFFILE_FORMAT_MAGIC MAKEFOUR('x','o','f',' ')
41 #define XOFFILE_FORMAT_VERSION_302 MAKEFOUR('0','3','0','2')
42 #define XOFFILE_FORMAT_VERSION_303 MAKEFOUR('0','3','0','3')
43 #define XOFFILE_FORMAT_BINARY MAKEFOUR('b','i','n',' ')
44 #define XOFFILE_FORMAT_TEXT MAKEFOUR('t','x','t',' ')
45 #define XOFFILE_FORMAT_COMPRESSED MAKEFOUR('c','m','p',' ')
46 #define XOFFILE_FORMAT_FLOAT_BITS_32 MAKEFOUR('0','0','3','2')
47 #define XOFFILE_FORMAT_FLOAT_BITS_64 MAKEFOUR('0','0','6','4')
48
49 #define TOKEN_NAME 1
50 #define TOKEN_STRING 2
51 #define TOKEN_INTEGER 3
52 #define TOKEN_GUID 5
53 #define TOKEN_INTEGER_LIST 6
54 #define TOKEN_FLOAT_LIST 7
55 #define TOKEN_OBRACE 10
56 #define TOKEN_CBRACE 11
57 #define TOKEN_OPAREN 12
58 #define TOKEN_CPAREN 13
59 #define TOKEN_OBRACKET 14
60 #define TOKEN_CBRACKET 15
61 #define TOKEN_OANGLE 16
62 #define TOKEN_CANGLE 17
63 #define TOKEN_DOT 18
64 #define TOKEN_COMMA 19
65 #define TOKEN_SEMICOLON 20
66 #define TOKEN_TEMPLATE 31
67 #define TOKEN_WORD 40
68 #define TOKEN_DWORD 41
69 #define TOKEN_FLOAT 42
70 #define TOKEN_DOUBLE 43
71 #define TOKEN_CHAR 44
72 #define TOKEN_UCHAR 45
73 #define TOKEN_SWORD 46
74 #define TOKEN_SDWORD 47
75 #define TOKEN_VOID 48
76 #define TOKEN_LPSTR 49
77 #define TOKEN_UNICODE 50
78 #define TOKEN_CSTRING 51
79 #define TOKEN_ARRAY 52
80
81 #define CLSIDFMT "<%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X>"
82
83 #define MAX_INPUT_SIZE 2000000
84 #define MAX_DATA_SIZE 200000
85
86 static const struct IDirectXFileVtbl IDirectXFile_Vtbl;
87 static const struct IDirectXFileBinaryVtbl IDirectXFileBinary_Vtbl;
88 static const struct IDirectXFileDataVtbl IDirectXFileData_Vtbl;
89 static const struct IDirectXFileDataReferenceVtbl IDirectXFileDataReference_Vtbl;
90 static const struct IDirectXFileEnumObjectVtbl IDirectXFileEnumObject_Vtbl;
91 static const struct IDirectXFileObjectVtbl IDirectXFileObject_Vtbl;
92 static const struct IDirectXFileSaveObjectVtbl IDirectXFileSaveObject_Vtbl;
93
94 static BOOL parse_object_parts(parse_buffer * buf, BOOL allow_optional);
95 static BOOL parse_object(parse_buffer * buf);
96 static const char* get_primitive_string(WORD token);
97 static WORD check_TOKEN(parse_buffer * buf);
98 static BOOL parse_template(parse_buffer * buf);
99
100 static void dump_template(xtemplate* templates_array, xtemplate* ptemplate)
101 {
102 int j, k;
103 GUID* clsid;
104
105 clsid = &ptemplate->class_id;
106
107 DPRINTF("template %s\n", ptemplate->name);
108 DPRINTF("{\n");
109 DPRINTF(CLSIDFMT "\n", clsid->Data1, clsid->Data2, clsid->Data3, clsid->Data4[0],
110 clsid->Data4[1], clsid->Data4[2], clsid->Data4[3], clsid->Data4[4], clsid->Data4[5], clsid->Data4[6], clsid->Data4[7]);
111 for (j = 0; j < ptemplate->nb_members; j++)
112 {
113 if (ptemplate->members[j].nb_dims)
114 DPRINTF("array ");
115 if (ptemplate->members[j].type == TOKEN_NAME)
116 DPRINTF("%s ", templates_array[ptemplate->members[j].idx_template].name);
117 else
118 DPRINTF("%s ", get_primitive_string(ptemplate->members[j].type));
119 DPRINTF("%s", ptemplate->members[j].name);
120 for (k = 0; k < ptemplate->members[j].nb_dims; k++)
121 {
122 if (ptemplate->members[j].dim_fixed[k])
123 DPRINTF("[%d]", ptemplate->members[j].dim_value[k]);
124 else
125 DPRINTF("[%s]", ptemplate->members[ptemplate->members[j].dim_value[k]].name);
126 }
127 DPRINTF(";\n");
128 }
129 if (ptemplate->open)
130 DPRINTF("[...]\n");
131 else if (ptemplate->nb_childs)
132 {
133 DPRINTF("[%s", ptemplate->childs[0]);
134 for (j = 1; j < ptemplate->nb_childs; j++)
135 DPRINTF(",%s", ptemplate->childs[j]);
136 DPRINTF("]\n");
137 }
138 DPRINTF("}\n");
139 }
140
141 HRESULT IDirectXFileImpl_Create(IUnknown* pUnkOuter, LPVOID* ppObj)
142 {
143 IDirectXFileImpl* object;
144
145 TRACE("(%p,%p)\n", pUnkOuter, ppObj);
146
147 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileImpl));
148
149 object->lpVtbl.lpVtbl = &IDirectXFile_Vtbl;
150 object->ref = 1;
151
152 *ppObj = object;
153
154 return S_OK;
155 }
156
157 /*** IUnknown methods ***/
158 static HRESULT WINAPI IDirectXFileImpl_QueryInterface(IDirectXFile* iface, REFIID riid, void** ppvObject)
159 {
160 IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
161
162 TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
163
164 if (IsEqualGUID(riid, &IID_IUnknown)
165 || IsEqualGUID(riid, &IID_IDirectXFile))
166 {
167 IClassFactory_AddRef(iface);
168 *ppvObject = This;
169 return S_OK;
170 }
171
172 ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
173 return E_NOINTERFACE;
174 }
175
176 static ULONG WINAPI IDirectXFileImpl_AddRef(IDirectXFile* iface)
177 {
178 IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
179 ULONG ref = InterlockedIncrement(&This->ref);
180
181 TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
182
183 return ref;
184 }
185
186 static ULONG WINAPI IDirectXFileImpl_Release(IDirectXFile* iface)
187 {
188 IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
189 ULONG ref = InterlockedDecrement(&This->ref);
190
191 TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
192
193 if (!ref)
194 HeapFree(GetProcessHeap(), 0, This);
195
196 return ref;
197 }
198
199 /*** IDirectXFile methods ***/
200 static HRESULT WINAPI IDirectXFileImpl_CreateEnumObject(IDirectXFile* iface, LPVOID pvSource, DXFILELOADOPTIONS dwLoadOptions, LPDIRECTXFILEENUMOBJECT* ppEnumObj)
201 {
202 IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
203 IDirectXFileEnumObjectImpl* object;
204 HRESULT hr;
205 DWORD header[4];
206 DWORD size;
207 HANDLE hFile = INVALID_HANDLE_VALUE;
208 LPDXFILELOADMEMORY lpdxflm = NULL;
209
210 TRACE("(%p/%p)->(%p,%x,%p)\n", This, iface, pvSource, dwLoadOptions, ppEnumObj);
211
212 if (!ppEnumObj)
213 return DXFILEERR_BADVALUE;
214
215 if (dwLoadOptions == DXFILELOAD_FROMFILE)
216 {
217 TRACE("Open source file '%s'\n", (char*)pvSource);
218
219 hFile = CreateFileA((char*)pvSource, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
220 if (hFile == INVALID_HANDLE_VALUE)
221 {
222 TRACE("File '%s' not found\n", (char*)pvSource);
223 return DXFILEERR_FILENOTFOUND;
224 }
225
226 if (!ReadFile(hFile, header, 16, &size, NULL))
227 {
228 hr = DXFILEERR_BADVALUE;
229 goto error;
230 }
231
232 if (size < 16)
233 {
234 hr = DXFILEERR_BADFILETYPE;
235 goto error;
236 }
237 }
238 else if (dwLoadOptions == DXFILELOAD_FROMMEMORY)
239 {
240 lpdxflm = (LPDXFILELOADMEMORY)pvSource;
241
242 TRACE("Source in memory at %p with size %d\n", lpdxflm->lpMemory, lpdxflm->dSize);
243
244 memcpy(header, (char*)lpdxflm->lpMemory, 16);
245 }
246 else
247 {
248 FIXME("Source type %d is not handled yet\n", dwLoadOptions);
249 hr = DXFILEERR_NOTDONEYET;
250 goto error;
251 }
252
253 if (TRACE_ON(d3dxof))
254 {
255 char string[17];
256 memcpy(string, header, 16);
257 string[16] = 0;
258 TRACE("header = '%s'\n", string);
259 }
260
261 if (header[0] != XOFFILE_FORMAT_MAGIC)
262 {
263 hr = DXFILEERR_BADFILETYPE;
264 goto error;
265 }
266
267 if ((header[1] != XOFFILE_FORMAT_VERSION_302) && (header[1] != XOFFILE_FORMAT_VERSION_303))
268 {
269 hr = DXFILEERR_BADFILEVERSION;
270 goto error;
271 }
272
273 if ((header[2] != XOFFILE_FORMAT_BINARY) && (header[2] != XOFFILE_FORMAT_TEXT) && (header[2] != XOFFILE_FORMAT_COMPRESSED))
274 {
275 hr = DXFILEERR_BADFILETYPE;
276 goto error;
277 }
278
279 if (header[2] == XOFFILE_FORMAT_COMPRESSED)
280 {
281 FIXME("Compressed formats not supported yet\n");
282 hr = DXFILEERR_BADVALUE;
283 goto error;
284 }
285
286 if ((header[3] != XOFFILE_FORMAT_FLOAT_BITS_32) && (header[3] != XOFFILE_FORMAT_FLOAT_BITS_64))
287 {
288 hr = DXFILEERR_BADFILEFLOATSIZE;
289 goto error;
290 }
291
292 TRACE("Header is correct\n");
293
294 hr = IDirectXFileEnumObjectImpl_Create(&object);
295 if (FAILED(hr))
296 goto error;
297
298 object->source = dwLoadOptions;
299 object->hFile = hFile;
300 object->pDirectXFile = This;
301 object->buf.pdxf = This;
302 object->buf.txt = (header[2] == XOFFILE_FORMAT_TEXT);
303 object->buf.token_present = FALSE;
304 object->buf.cur_subobject = 0;
305
306 if (dwLoadOptions == DXFILELOAD_FROMFILE)
307 {
308 object->buf.buffer = HeapAlloc(GetProcessHeap(), 0, MAX_INPUT_SIZE+1);
309 if (!object->buf.buffer)
310 {
311 WARN("Out of memory\n");
312 hr = DXFILEERR_BADALLOC;
313 goto error;
314 }
315
316 ReadFile(hFile, object->buf.buffer, MAX_INPUT_SIZE+1, &object->buf.rem_bytes, NULL);
317 if (object->buf.rem_bytes > MAX_INPUT_SIZE)
318 {
319 FIXME("File size > %d not supported yet\n", MAX_INPUT_SIZE);
320 HeapFree(GetProcessHeap(), 0, object->buf.buffer);
321 hr = DXFILEERR_PARSEERROR;
322 goto error;
323 }
324 }
325 else
326 {
327 object->buf.buffer = ((LPBYTE)lpdxflm->lpMemory) + 16;
328 object->buf.rem_bytes = lpdxflm->dSize;
329 }
330
331 TRACE("Read %d bytes\n", object->buf.rem_bytes);
332
333 *ppEnumObj = (LPDIRECTXFILEENUMOBJECT)object;
334
335 while (object->buf.rem_bytes && (check_TOKEN(&object->buf) == TOKEN_TEMPLATE))
336 {
337 if (!parse_template(&object->buf))
338 {
339 TRACE("Template is not correct\n");
340 hr = DXFILEERR_BADVALUE;
341 goto error;
342 }
343 else
344 {
345 TRACE("Template successfully parsed:\n");
346 if (TRACE_ON(d3dxof))
347 dump_template(This->xtemplates, &This->xtemplates[This->nb_xtemplates - 1]);
348 }
349 }
350
351 if (TRACE_ON(d3dxof))
352 {
353 int i;
354 TRACE("Registered templates (%d):\n", This->nb_xtemplates);
355 for (i = 0; i < This->nb_xtemplates; i++)
356 DPRINTF("%s - %s\n", This->xtemplates[i].name, debugstr_guid(&This->xtemplates[i].class_id));
357 }
358
359 return DXFILE_OK;
360
361 error:
362 if (hFile != INVALID_HANDLE_VALUE)
363 CloseHandle(hFile);
364 *ppEnumObj = NULL;
365
366 return hr;
367 }
368
369 static HRESULT WINAPI IDirectXFileImpl_CreateSaveObject(IDirectXFile* iface, LPCSTR szFileName, DXFILEFORMAT dwFileFormat, LPDIRECTXFILESAVEOBJECT* ppSaveObj)
370 {
371 IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
372
373 FIXME("(%p/%p)->(%s,%x,%p) stub!\n", This, iface, szFileName, dwFileFormat, ppSaveObj);
374
375 return DXFILEERR_BADVALUE;
376 }
377
378 static BOOL read_bytes(parse_buffer * buf, LPVOID data, DWORD size)
379 {
380 if (buf->rem_bytes < size)
381 return FALSE;
382 memcpy(data, buf->buffer, size);
383 buf->buffer += size;
384 buf->rem_bytes -= size;
385 return TRUE;
386 }
387
388 static void dump_TOKEN(WORD token)
389 {
390 #define DUMP_TOKEN(t) case t: TRACE(#t "\n"); break
391 switch(token)
392 {
393 DUMP_TOKEN(TOKEN_NAME);
394 DUMP_TOKEN(TOKEN_STRING);
395 DUMP_TOKEN(TOKEN_INTEGER);
396 DUMP_TOKEN(TOKEN_GUID);
397 DUMP_TOKEN(TOKEN_INTEGER_LIST);
398 DUMP_TOKEN(TOKEN_FLOAT_LIST);
399 DUMP_TOKEN(TOKEN_OBRACE);
400 DUMP_TOKEN(TOKEN_CBRACE);
401 DUMP_TOKEN(TOKEN_OPAREN);
402 DUMP_TOKEN(TOKEN_CPAREN);
403 DUMP_TOKEN(TOKEN_OBRACKET);
404 DUMP_TOKEN(TOKEN_CBRACKET);
405 DUMP_TOKEN(TOKEN_OANGLE);
406 DUMP_TOKEN(TOKEN_CANGLE);
407 DUMP_TOKEN(TOKEN_DOT);
408 DUMP_TOKEN(TOKEN_COMMA);
409 DUMP_TOKEN(TOKEN_SEMICOLON);
410 DUMP_TOKEN(TOKEN_TEMPLATE);
411 DUMP_TOKEN(TOKEN_WORD);
412 DUMP_TOKEN(TOKEN_DWORD);
413 DUMP_TOKEN(TOKEN_FLOAT);
414 DUMP_TOKEN(TOKEN_DOUBLE);
415 DUMP_TOKEN(TOKEN_CHAR);
416 DUMP_TOKEN(TOKEN_UCHAR);
417 DUMP_TOKEN(TOKEN_SWORD);
418 DUMP_TOKEN(TOKEN_SDWORD);
419 DUMP_TOKEN(TOKEN_VOID);
420 DUMP_TOKEN(TOKEN_LPSTR);
421 DUMP_TOKEN(TOKEN_UNICODE);
422 DUMP_TOKEN(TOKEN_CSTRING);
423 DUMP_TOKEN(TOKEN_ARRAY);
424 default:
425 if (0)
426 TRACE("Unknown token %d\n", token);
427 break;
428 }
429 #undef DUMP_TOKEN
430 }
431
432 static BOOL is_space(char c)
433 {
434 switch (c)
435 {
436 case 0x00:
437 case 0x0D:
438 case 0x0A:
439 case ' ':
440 case '\t':
441 return TRUE;
442 }
443 return FALSE;
444 }
445
446 static BOOL is_operator(char c)
447 {
448 switch(c)
449 {
450 case '{':
451 case '}':
452 case '[':
453 case ']':
454 case '(':
455 case ')':
456 case '<':
457 case '>':
458 case ',':
459 case ';':
460 return TRUE;
461 }
462 return FALSE;
463 }
464
465 static inline BOOL is_separator(char c)
466 {
467 return is_space(c) || is_operator(c);
468 }
469
470 static WORD get_operator_token(char c)
471 {
472 switch(c)
473 {
474 case '{':
475 return TOKEN_OBRACE;
476 case '}':
477 return TOKEN_CBRACE;
478 case '[':
479 return TOKEN_OBRACKET;
480 case ']':
481 return TOKEN_CBRACKET;
482 case '(':
483 return TOKEN_OPAREN;
484 case ')':
485 return TOKEN_CPAREN;
486 case '<':
487 return TOKEN_OANGLE;
488 case '>':
489 return TOKEN_CANGLE;
490 case ',':
491 return TOKEN_COMMA;
492 case ';':
493 return TOKEN_SEMICOLON;
494 }
495 return 0;
496 }
497
498 static BOOL is_keyword(parse_buffer* buf, const char* keyword)
499 {
500 DWORD len = strlen(keyword);
501 if (!strncmp((char*)buf->buffer, keyword,len) && is_separator(*(buf->buffer+len)))
502 {
503 buf->buffer += len;
504 buf->rem_bytes -= len;
505 return TRUE;
506 }
507 return FALSE;
508 }
509
510 static WORD get_keyword_token(parse_buffer* buf)
511 {
512 if (is_keyword(buf, "template"))
513 return TOKEN_TEMPLATE;
514 if (is_keyword(buf, "WORD"))
515 return TOKEN_WORD;
516 if (is_keyword(buf, "DWORD"))
517 return TOKEN_DWORD;
518 if (is_keyword(buf, "FLOAT"))
519 return TOKEN_FLOAT;
520 if (is_keyword(buf, "DOUBLE"))
521 return TOKEN_DOUBLE;
522 if (is_keyword(buf, "CHAR"))
523 return TOKEN_CHAR;
524 if (is_keyword(buf, "UCHAR"))
525 return TOKEN_UCHAR;
526 if (is_keyword(buf, "SWORD"))
527 return TOKEN_SWORD;
528 if (is_keyword(buf, "SDWORD"))
529 return TOKEN_SDWORD;
530 if (is_keyword(buf, "VOID"))
531 return TOKEN_VOID;
532 if (is_keyword(buf, "STRING"))
533 return TOKEN_LPSTR;
534 if (is_keyword(buf, "UNICODE"))
535 return TOKEN_UNICODE;
536 if (is_keyword(buf, "CSTRING"))
537 return TOKEN_CSTRING;
538 if (is_keyword(buf, "array"))
539 return TOKEN_ARRAY;
540
541 return 0;
542 }
543
544 static BOOL is_guid(parse_buffer* buf)
545 {
546 char tmp[50];
547 DWORD pos = 1;
548 GUID class_id;
549 DWORD tab[10];
550 int ret;
551
552 if (*buf->buffer != '<')
553 return FALSE;
554 tmp[0] = '<';
555 while (*(buf->buffer+pos) != '>')
556 {
557 tmp[pos] = *(buf->buffer+pos);
558 pos++;
559 }
560 tmp[pos++] = '>';
561 tmp[pos] = 0;
562 if (pos != 38 /* <+36+> */)
563 {
564 TRACE("Wrong guid %s (%d)\n", tmp, pos);
565 return FALSE;
566 }
567 buf->buffer += pos;
568 buf->rem_bytes -= pos;
569
570 ret = sscanf(tmp, CLSIDFMT, &class_id.Data1, tab, tab+1, tab+2, tab+3, tab+4, tab+5, tab+6, tab+7, tab+8, tab+9);
571 if (ret != 11)
572 {
573 TRACE("Wrong guid %s (%d)\n", tmp, pos);
574 return FALSE;
575 }
576 TRACE("Found guid %s (%d)\n", tmp, pos);
577
578 class_id.Data2 = tab[0];
579 class_id.Data3 = tab[1];
580 class_id.Data4[0] = tab[2];
581 class_id.Data4[1] = tab[3];
582 class_id.Data4[2] = tab[4];
583 class_id.Data4[3] = tab[5];
584 class_id.Data4[4] = tab[6];
585 class_id.Data4[5] = tab[7];
586 class_id.Data4[6] = tab[8];
587 class_id.Data4[7] = tab[9];
588
589 *(GUID*)buf->value = class_id;
590
591 return TRUE;
592 }
593
594 static BOOL is_name(parse_buffer* buf)
595 {
596 char tmp[50];
597 DWORD pos = 0;
598 char c;
599 BOOL error = 0;
600 while (!is_separator(c = *(buf->buffer+pos)))
601 {
602 if (!(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) || ((c >= '0') && (c <= '9')) || (c == '_') || (c == '-')))
603 error = 1;
604 tmp[pos++] = c;
605 }
606 tmp[pos] = 0;
607
608 if (error)
609 {
610 TRACE("Wrong name %s\n", tmp);
611 return FALSE;
612 }
613
614 buf->buffer += pos;
615 buf->rem_bytes -= pos;
616
617 TRACE("Found name %s\n", tmp);
618 strcpy((char*)buf->value, tmp);
619
620 return TRUE;
621 }
622
623 static BOOL is_float(parse_buffer* buf)
624 {
625 char tmp[50];
626 DWORD pos = 0;
627 char c;
628 float decimal;
629 BOOL dot = 0;
630
631 while (!is_separator(c = *(buf->buffer+pos)))
632 {
633 if (!((!pos && (c == '-')) || ((c >= '0') && (c <= '9')) || (!dot && (c == '.'))))
634 return FALSE;
635 if (c == '.')
636 dot = TRUE;
637 tmp[pos++] = c;
638 }
639 tmp[pos] = 0;
640
641 buf->buffer += pos;
642 buf->rem_bytes -= pos;
643
644 sscanf(tmp, "%f", &decimal);
645
646 TRACE("Found float %s - %f\n", tmp, decimal);
647
648 *(float*)buf->value = decimal;
649
650 return TRUE;
651 }
652
653 static BOOL is_integer(parse_buffer* buf)
654 {
655 char tmp[50];
656 DWORD pos = 0;
657 char c;
658 DWORD integer;
659
660 while (!is_separator(c = *(buf->buffer+pos)))
661 {
662 if (!((c >= '0') && (c <= '9')))
663 return FALSE;
664 tmp[pos++] = c;
665 }
666 tmp[pos] = 0;
667
668 buf->buffer += pos;
669 buf->rem_bytes -= pos;
670
671 sscanf(tmp, "%d", &integer);
672
673 TRACE("Found integer %s - %d\n", tmp, integer);
674
675 *(DWORD*)buf->value = integer;
676
677 return TRUE;
678 }
679
680 static BOOL is_string(parse_buffer* buf)
681 {
682 char tmp[32];
683 DWORD pos = 0;
684 char c;
685 BOOL ok = 0;
686
687 if (*buf->buffer != '"')
688 return FALSE;
689
690 while (!is_separator(c = *(buf->buffer+pos+1)) && (pos < 31))
691 {
692 if (c == '"')
693 {
694 ok = 1;
695 break;
696 }
697 tmp[pos++] = c;
698 }
699 tmp[pos] = 0;
700
701 if (!ok)
702 {
703 TRACE("Wrong string %s\n", tmp);
704 return FALSE;
705 }
706
707 buf->buffer += pos + 2;
708 buf->rem_bytes -= pos + 2;
709
710 TRACE("Found string %s\n", tmp);
711 strcpy((char*)buf->value, tmp);
712
713 return TRUE;
714 }
715
716 static WORD parse_TOKEN(parse_buffer * buf)
717 {
718 WORD token;
719
720 if (buf->txt)
721 {
722 while(1)
723 {
724 char c;
725 if (!read_bytes(buf, &c, 1))
726 return 0;
727 /*TRACE("char = '%c'\n", is_space(c) ? ' ' : c);*/
728 if ((c == '#') || (c == '/'))
729 {
730 /* Handle comment (# or //) */
731 if (c == '/')
732 {
733 if (!read_bytes(buf, &c, 1))
734 return 0;
735 if (c != '/')
736 return 0;
737 }
738 c = 0;
739 while (c != 0x0A)
740 {
741 if (!read_bytes(buf, &c, 1))
742 return 0;
743 }
744 continue;
745 }
746 if (is_space(c))
747 continue;
748 if (is_operator(c) && (c != '<'))
749 {
750 token = get_operator_token(c);
751 break;
752 }
753 else if (c == '.')
754 {
755 token = TOKEN_DOT;
756 break;
757 }
758 else
759 {
760 buf->buffer -= 1;
761 buf->rem_bytes += 1;
762
763 if ((token = get_keyword_token(buf)))
764 break;
765
766 if (is_guid(buf))
767 {
768 token = TOKEN_GUID;
769 break;
770 }
771 if (is_integer(buf))
772 {
773 token = TOKEN_INTEGER;
774 break;
775 }
776 if (is_float(buf))
777 {
778 token = TOKEN_FLOAT;
779 break;
780 }
781 if (is_string(buf))
782 {
783 token = TOKEN_LPSTR;
784 break;
785 }
786 if (is_name(buf))
787 {
788 token = TOKEN_NAME;
789 break;
790 }
791
792 FIXME("Unrecognize element\n");
793 return 0;
794 }
795 }
796 }
797 else
798 {
799 static int nb_elem;
800 static int is_float;
801
802 if (!nb_elem)
803 {
804 if (!read_bytes(buf, &token, 2))
805 return 0;
806
807 /* Convert integer and float list into sereparate elements */
808 if (token == TOKEN_INTEGER_LIST)
809 {
810 if (!read_bytes(buf, &nb_elem, 4))
811 return 0;
812 token = TOKEN_INTEGER;
813 is_float = FALSE;
814 TRACE("Integer list (TOKEN_INTEGER_LIST) of size %d\n", nb_elem);
815 }
816 else if (token == TOKEN_FLOAT_LIST)
817 {
818 if (!read_bytes(buf, &nb_elem, 4))
819 return 0;
820 token = TOKEN_FLOAT;
821 is_float = TRUE;
822 TRACE("Float list (TOKEN_FLOAT_LIST) of size %d\n", nb_elem);
823 }
824 }
825
826 if (nb_elem)
827 {
828 token = is_float ? TOKEN_FLOAT : TOKEN_INTEGER;
829 nb_elem--;
830 {
831 DWORD integer;
832
833 if (!read_bytes(buf, &integer, 4))
834 return 0;
835
836 *(DWORD*)buf->value = integer;
837 }
838 dump_TOKEN(token);
839 return token;
840 }
841
842 switch (token)
843 {
844 case TOKEN_NAME:
845 {
846 DWORD count;
847 char strname[100];
848
849 if (!read_bytes(buf, &count, 4))
850 return 0;
851 if (!read_bytes(buf, strname, count))
852 return 0;
853 strname[count] = 0;
854 /*TRACE("name = %s\n", strname);*/
855
856 strcpy((char*)buf->value, strname);
857 }
858 break;
859 case TOKEN_INTEGER:
860 {
861 DWORD integer;
862
863 if (!read_bytes(buf, &integer, 4))
864 return 0;
865 /*TRACE("integer = %ld\n", integer);*/
866
867 *(DWORD*)buf->value = integer;
868 }
869 break;
870 case TOKEN_GUID:
871 {
872 char strguid[39];
873 GUID class_id;
874
875 if (!read_bytes(buf, &class_id, 16))
876 return 0;
877 sprintf(strguid, CLSIDFMT, class_id.Data1, class_id.Data2, class_id.Data3, class_id.Data4[0],
878 class_id.Data4[1], class_id.Data4[2], class_id.Data4[3], class_id.Data4[4], class_id.Data4[5],
879 class_id.Data4[6], class_id.Data4[7]);
880 /*TRACE("guid = {%s}\n", strguid);*/
881
882 *(GUID*)buf->value = class_id;
883 }
884 break;
885 case TOKEN_STRING:
886 {
887 DWORD count;
888 WORD tmp_token;
889 char strname[100];
890 if (!read_bytes(buf, &count, 4))
891 return 0;
892 if (!read_bytes(buf, strname, count))
893 return 0;
894 strname[count] = 0;
895 if (!read_bytes(buf, &tmp_token, 2))
896 return 0;
897 if ((tmp_token != TOKEN_COMMA) && (tmp_token != TOKEN_SEMICOLON))
898 ERR("No comma or semicolon (got %d)\n", tmp_token);
899 /*TRACE("name = %s\n", strname);*/
900
901 strcpy((char*)buf->value, strname);
902 token = TOKEN_LPSTR;
903 }
904 break;
905 case TOKEN_OBRACE:
906 case TOKEN_CBRACE:
907 case TOKEN_OPAREN:
908 case TOKEN_CPAREN:
909 case TOKEN_OBRACKET:
910 case TOKEN_CBRACKET:
911 case TOKEN_OANGLE:
912 case TOKEN_CANGLE:
913 case TOKEN_DOT:
914 case TOKEN_COMMA:
915 case TOKEN_SEMICOLON:
916 case TOKEN_TEMPLATE:
917 case TOKEN_WORD:
918 case TOKEN_DWORD:
919 case TOKEN_FLOAT:
920 case TOKEN_DOUBLE:
921 case TOKEN_CHAR:
922 case TOKEN_UCHAR:
923 case TOKEN_SWORD:
924 case TOKEN_SDWORD:
925 case TOKEN_VOID:
926 case TOKEN_LPSTR:
927 case TOKEN_UNICODE:
928 case TOKEN_CSTRING:
929 case TOKEN_ARRAY:
930 break;
931 default:
932 return 0;
933 }
934 }
935
936 dump_TOKEN(token);
937
938 return token;
939 }
940
941 static const char* get_primitive_string(WORD token)
942 {
943 switch(token)
944 {
945 case TOKEN_WORD:
946 return "WORD";
947 case TOKEN_DWORD:
948 return "DWORD";
949 case TOKEN_FLOAT:
950 return "FLOAT";
951 case TOKEN_DOUBLE:
952 return "DOUBLE";
953 case TOKEN_CHAR:
954 return "CHAR";
955 case TOKEN_UCHAR:
956 return "UCHAR";
957 case TOKEN_SWORD:
958 return "SWORD";
959 case TOKEN_SDWORD:
960 return "SDWORD";
961 case TOKEN_VOID:
962 return "VOID";
963 case TOKEN_LPSTR:
964 return "STRING";
965 case TOKEN_UNICODE:
966 return "UNICODE";
967 case TOKEN_CSTRING:
968 return "CSTRING ";
969 default:
970 break;
971 }
972 return NULL;
973 }
974
975 static WORD get_TOKEN(parse_buffer * buf)
976 {
977 if (buf->token_present)
978 {
979 buf->token_present = FALSE;
980 return buf->current_token;
981 }
982
983 buf->current_token = parse_TOKEN(buf);
984
985 return buf->current_token;
986 }
987
988 static WORD check_TOKEN(parse_buffer * buf)
989 {
990 if (buf->token_present)
991 return buf->current_token;
992
993 buf->current_token = parse_TOKEN(buf);
994 buf->token_present = TRUE;
995
996 return buf->current_token;
997 }
998
999 static inline BOOL is_primitive_type(WORD token)
1000 {
1001 BOOL ret;
1002 switch(token)
1003 {
1004 case TOKEN_WORD:
1005 case TOKEN_DWORD:
1006 case TOKEN_FLOAT:
1007 case TOKEN_DOUBLE:
1008 case TOKEN_CHAR:
1009 case TOKEN_UCHAR:
1010 case TOKEN_SWORD:
1011 case TOKEN_SDWORD:
1012 case TOKEN_LPSTR:
1013 case TOKEN_UNICODE:
1014 case TOKEN_CSTRING:
1015 ret = 1;
1016 break;
1017 default:
1018 ret = 0;
1019 break;
1020 }
1021 return ret;
1022 }
1023
1024 static BOOL parse_template_option_info(parse_buffer * buf)
1025 {
1026 xtemplate* cur_template = &buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates];
1027
1028 if (check_TOKEN(buf) == TOKEN_DOT)
1029 {
1030 get_TOKEN(buf);
1031 if (get_TOKEN(buf) != TOKEN_DOT)
1032 return FALSE;
1033 if (get_TOKEN(buf) != TOKEN_DOT)
1034 return FALSE;
1035 cur_template->open = TRUE;
1036 }
1037 else
1038 {
1039 while (1)
1040 {
1041 if (get_TOKEN(buf) != TOKEN_NAME)
1042 return FALSE;
1043 strcpy(cur_template->childs[cur_template->nb_childs], (char*)buf->value);
1044 if (check_TOKEN(buf) == TOKEN_GUID)
1045 get_TOKEN(buf);
1046 cur_template->nb_childs++;
1047 if (check_TOKEN(buf) != TOKEN_COMMA)
1048 break;
1049 get_TOKEN(buf);
1050 }
1051 cur_template->open = FALSE;
1052 }
1053
1054 return TRUE;
1055 }
1056
1057 static BOOL parse_template_members_list(parse_buffer * buf)
1058 {
1059 int idx_member = 0;
1060 member* cur_member;
1061
1062 while (1)
1063 {
1064 BOOL array = 0;
1065 int nb_dims = 0;
1066 cur_member = &buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].members[idx_member];
1067
1068 if (check_TOKEN(buf) == TOKEN_ARRAY)
1069 {
1070 get_TOKEN(buf);
1071 array = 1;
1072 }
1073
1074 if (check_TOKEN(buf) == TOKEN_NAME)
1075 {
1076 cur_member->type = get_TOKEN(buf);
1077 cur_member->idx_template = 0;
1078 while (cur_member->idx_template < buf->pdxf->nb_xtemplates)
1079 {
1080 if (!strcmp((char*)buf->value, buf->pdxf->xtemplates[cur_member->idx_template].name))
1081 break;
1082 cur_member->idx_template++;
1083 }
1084 if (cur_member->idx_template == buf->pdxf->nb_xtemplates)
1085 {
1086 TRACE("Reference to a nonexistent template '%s'\n", (char*)buf->value);
1087 return FALSE;
1088 }
1089 }
1090 else if (is_primitive_type(check_TOKEN(buf)))
1091 cur_member->type = get_TOKEN(buf);
1092 else
1093 break;
1094
1095 if (get_TOKEN(buf) != TOKEN_NAME)
1096 return FALSE;
1097 strcpy(cur_member->name, (char*)buf->value);
1098
1099 if (array)
1100 {
1101 while (check_TOKEN(buf) == TOKEN_OBRACKET)
1102 {
1103 if (nb_dims)
1104 {
1105 FIXME("No support for multi-dimensional array yet\n");
1106 return FALSE;
1107 }
1108 get_TOKEN(buf);
1109 if (check_TOKEN(buf) == TOKEN_INTEGER)
1110 {
1111 get_TOKEN(buf);
1112 cur_member->dim_fixed[nb_dims] = TRUE;
1113 cur_member->dim_value[nb_dims] = *(DWORD*)buf->value;
1114 }
1115 else
1116 {
1117 if (get_TOKEN(buf) != TOKEN_NAME)
1118 return FALSE;
1119 cur_member->dim_fixed[nb_dims] = FALSE;
1120 /* Hack: Assume array size is specified in previous member */
1121 cur_member->dim_value[nb_dims] = idx_member - 1;
1122 }
1123 if (get_TOKEN(buf) != TOKEN_CBRACKET)
1124 return FALSE;
1125 nb_dims++;
1126 }
1127 if (!nb_dims)
1128 return FALSE;
1129 cur_member->nb_dims = nb_dims;
1130 }
1131 if (get_TOKEN(buf) != TOKEN_SEMICOLON)
1132 return FALSE;
1133
1134 idx_member++;
1135 }
1136
1137 buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].nb_members = idx_member;
1138
1139 return TRUE;
1140 }
1141
1142 static BOOL parse_template_parts(parse_buffer * buf)
1143 {
1144 if (!parse_template_members_list(buf))
1145 return FALSE;
1146 if (check_TOKEN(buf) == TOKEN_OBRACKET)
1147 {
1148 get_TOKEN(buf);
1149 if (!parse_template_option_info(buf))
1150 return FALSE;
1151 if (get_TOKEN(buf) != TOKEN_CBRACKET)
1152 return FALSE;
1153 }
1154
1155 return TRUE;
1156 }
1157
1158 static BOOL parse_template(parse_buffer * buf)
1159 {
1160 if (get_TOKEN(buf) != TOKEN_TEMPLATE)
1161 return FALSE;
1162 if (get_TOKEN(buf) != TOKEN_NAME)
1163 return FALSE;
1164 strcpy(buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].name, (char*)buf->value);
1165 if (get_TOKEN(buf) != TOKEN_OBRACE)
1166 return FALSE;
1167 if (get_TOKEN(buf) != TOKEN_GUID)
1168 return FALSE;
1169 buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].class_id = *(GUID*)buf->value;
1170 if (!parse_template_parts(buf))
1171 return FALSE;
1172 if (get_TOKEN(buf) != TOKEN_CBRACE)
1173 return FALSE;
1174 if (buf->txt)
1175 {
1176 /* Go to the next template */
1177 while (buf->rem_bytes && is_space(*buf->buffer))
1178 {
1179 buf->buffer++;
1180 buf->rem_bytes--;
1181 }
1182 }
1183
1184 TRACE("%d - %s - %s\n", buf->pdxf->nb_xtemplates, buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].name, debugstr_guid(&buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].class_id));
1185 buf->pdxf->nb_xtemplates++;
1186
1187 return TRUE;
1188 }
1189
1190 static HRESULT WINAPI IDirectXFileImpl_RegisterTemplates(IDirectXFile* iface, LPVOID pvData, DWORD cbSize)
1191 {
1192 IDirectXFileImpl *This = (IDirectXFileImpl *)iface;
1193 DWORD token_header;
1194 parse_buffer buf;
1195
1196 buf.buffer = (LPBYTE)pvData;
1197 buf.rem_bytes = cbSize;
1198 buf.txt = FALSE;
1199 buf.token_present = FALSE;
1200 buf.pdxf = This;
1201
1202 TRACE("(%p/%p)->(%p,%d)\n", This, iface, pvData, cbSize);
1203
1204 if (!pvData)
1205 return DXFILEERR_BADVALUE;
1206
1207 if (cbSize < 16)
1208 return DXFILEERR_BADFILETYPE;
1209
1210 if (TRACE_ON(d3dxof))
1211 {
1212 char string[17];
1213 memcpy(string, pvData, 16);
1214 string[16] = 0;
1215 TRACE("header = '%s'\n", string);
1216 }
1217
1218 read_bytes(&buf, &token_header, 4);
1219
1220 if (token_header != XOFFILE_FORMAT_MAGIC)
1221 return DXFILEERR_BADFILETYPE;
1222
1223 read_bytes(&buf, &token_header, 4);
1224
1225 if ((token_header != XOFFILE_FORMAT_VERSION_302) && (token_header != XOFFILE_FORMAT_VERSION_303))
1226 return DXFILEERR_BADFILEVERSION;
1227
1228 read_bytes(&buf, &token_header, 4);
1229
1230 if ((token_header != XOFFILE_FORMAT_BINARY) && (token_header != XOFFILE_FORMAT_TEXT) && (token_header != XOFFILE_FORMAT_COMPRESSED))
1231 return DXFILEERR_BADFILETYPE;
1232
1233 if (token_header == XOFFILE_FORMAT_TEXT)
1234 {
1235 buf.txt = TRUE;
1236 }
1237
1238 if (token_header == XOFFILE_FORMAT_COMPRESSED)
1239 {
1240 FIXME("Compressed formats not supported yet\n");
1241 return DXFILEERR_BADVALUE;
1242 }
1243
1244 read_bytes(&buf, &token_header, 4);
1245
1246 if ((token_header != XOFFILE_FORMAT_FLOAT_BITS_32) && (token_header != XOFFILE_FORMAT_FLOAT_BITS_64))
1247 return DXFILEERR_BADFILEFLOATSIZE;
1248
1249 TRACE("Header is correct\n");
1250
1251 while (buf.rem_bytes)
1252 {
1253 if (!parse_template(&buf))
1254 {
1255 TRACE("Template is not correct\n");
1256 return DXFILEERR_BADVALUE;
1257 }
1258 else
1259 {
1260 TRACE("Template successfully parsed:\n");
1261 if (TRACE_ON(d3dxof))
1262 dump_template(This->xtemplates, &This->xtemplates[This->nb_xtemplates - 1]);
1263 }
1264 }
1265
1266 if (TRACE_ON(d3dxof))
1267 {
1268 int i;
1269 TRACE("Registered templates (%d):\n", This->nb_xtemplates);
1270 for (i = 0; i < This->nb_xtemplates; i++)
1271 DPRINTF("%s - %s\n", This->xtemplates[i].name, debugstr_guid(&This->xtemplates[i].class_id));
1272 }
1273
1274 return DXFILE_OK;
1275 }
1276
1277 static const IDirectXFileVtbl IDirectXFile_Vtbl =
1278 {
1279 IDirectXFileImpl_QueryInterface,
1280 IDirectXFileImpl_AddRef,
1281 IDirectXFileImpl_Release,
1282 IDirectXFileImpl_CreateEnumObject,
1283 IDirectXFileImpl_CreateSaveObject,
1284 IDirectXFileImpl_RegisterTemplates
1285 };
1286
1287 HRESULT IDirectXFileBinaryImpl_Create(IDirectXFileBinaryImpl** ppObj)
1288 {
1289 IDirectXFileBinaryImpl* object;
1290
1291 TRACE("(%p)\n", ppObj);
1292
1293 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileBinaryImpl));
1294
1295 object->lpVtbl.lpVtbl = &IDirectXFileBinary_Vtbl;
1296 object->ref = 1;
1297
1298 *ppObj = object;
1299
1300 return DXFILE_OK;
1301 }
1302
1303 /*** IUnknown methods ***/
1304 static HRESULT WINAPI IDirectXFileBinaryImpl_QueryInterface(IDirectXFileBinary* iface, REFIID riid, void** ppvObject)
1305 {
1306 IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1307
1308 TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1309
1310 if (IsEqualGUID(riid, &IID_IUnknown)
1311 || IsEqualGUID(riid, &IID_IDirectXFileObject)
1312 || IsEqualGUID(riid, &IID_IDirectXFileBinary))
1313 {
1314 IClassFactory_AddRef(iface);
1315 *ppvObject = This;
1316 return S_OK;
1317 }
1318
1319 /* Do not print an error for interfaces that can be queried to retrieve the type of the object */
1320 if (!IsEqualGUID(riid, &IID_IDirectXFileData)
1321 && !IsEqualGUID(riid, &IID_IDirectXFileDataReference))
1322 ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1323
1324 return E_NOINTERFACE;
1325 }
1326
1327 static ULONG WINAPI IDirectXFileBinaryImpl_AddRef(IDirectXFileBinary* iface)
1328 {
1329 IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1330 ULONG ref = InterlockedIncrement(&This->ref);
1331
1332 TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1333
1334 return ref;
1335 }
1336
1337 static ULONG WINAPI IDirectXFileBinaryImpl_Release(IDirectXFileBinary* iface)
1338 {
1339 IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1340 ULONG ref = InterlockedDecrement(&This->ref);
1341
1342 TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1343
1344 if (!ref)
1345 HeapFree(GetProcessHeap(), 0, This);
1346
1347 return ref;
1348 }
1349
1350 /*** IDirectXFileObject methods ***/
1351 static HRESULT WINAPI IDirectXFileBinaryImpl_GetName(IDirectXFileBinary* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1352
1353 {
1354 IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1355
1356 FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pstrNameBuf, pdwBufLen);
1357
1358 return DXFILEERR_BADVALUE;
1359 }
1360
1361 static HRESULT WINAPI IDirectXFileBinaryImpl_GetId(IDirectXFileBinary* iface, LPGUID pGuid)
1362 {
1363 IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1364
1365 FIXME("(%p/%p)->(%p) stub!\n", This, iface, pGuid);
1366
1367 return DXFILEERR_BADVALUE;
1368 }
1369
1370 /*** IDirectXFileBinary methods ***/
1371 static HRESULT WINAPI IDirectXFileBinaryImpl_GetSize(IDirectXFileBinary* iface, DWORD* pcbSize)
1372 {
1373 IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1374
1375 FIXME("(%p/%p)->(%p) stub!\n", This, iface, pcbSize);
1376
1377 return DXFILEERR_BADVALUE;
1378 }
1379
1380 static HRESULT WINAPI IDirectXFileBinaryImpl_GetMimeType(IDirectXFileBinary* iface, LPCSTR* pszMimeType)
1381 {
1382 IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1383
1384 FIXME("(%p/%p)->(%p) stub!\n", This, iface, pszMimeType);
1385
1386 return DXFILEERR_BADVALUE;
1387 }
1388
1389 static HRESULT WINAPI IDirectXFileBinaryImpl_Read(IDirectXFileBinary* iface, LPVOID pvData, DWORD cbSize, LPDWORD pcbRead)
1390 {
1391 IDirectXFileBinaryImpl *This = (IDirectXFileBinaryImpl *)iface;
1392
1393 FIXME("(%p/%p)->(%p, %d, %p) stub!\n", This, iface, pvData, cbSize, pcbRead);
1394
1395 return DXFILEERR_BADVALUE;
1396 }
1397
1398 static const IDirectXFileBinaryVtbl IDirectXFileBinary_Vtbl =
1399 {
1400 IDirectXFileBinaryImpl_QueryInterface,
1401 IDirectXFileBinaryImpl_AddRef,
1402 IDirectXFileBinaryImpl_Release,
1403 IDirectXFileBinaryImpl_GetName,
1404 IDirectXFileBinaryImpl_GetId,
1405 IDirectXFileBinaryImpl_GetSize,
1406 IDirectXFileBinaryImpl_GetMimeType,
1407 IDirectXFileBinaryImpl_Read
1408 };
1409
1410 HRESULT IDirectXFileDataImpl_Create(IDirectXFileDataImpl** ppObj)
1411 {
1412 IDirectXFileDataImpl* object;
1413
1414 TRACE("(%p)\n", ppObj);
1415
1416 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileDataImpl));
1417
1418 object->lpVtbl.lpVtbl = &IDirectXFileData_Vtbl;
1419 object->ref = 1;
1420
1421 *ppObj = object;
1422
1423 return S_OK;
1424 }
1425
1426 /*** IUnknown methods ***/
1427 static HRESULT WINAPI IDirectXFileDataImpl_QueryInterface(IDirectXFileData* iface, REFIID riid, void** ppvObject)
1428 {
1429 IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1430
1431 TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1432
1433 if (IsEqualGUID(riid, &IID_IUnknown)
1434 || IsEqualGUID(riid, &IID_IDirectXFileObject)
1435 || IsEqualGUID(riid, &IID_IDirectXFileData))
1436 {
1437 IClassFactory_AddRef(iface);
1438 *ppvObject = This;
1439 return S_OK;
1440 }
1441
1442 /* Do not print an error for interfaces that can be queried to retrieve the type of the object */
1443 if (!IsEqualGUID(riid, &IID_IDirectXFileBinary)
1444 && !IsEqualGUID(riid, &IID_IDirectXFileDataReference))
1445 ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1446
1447 return E_NOINTERFACE;
1448 }
1449
1450 static ULONG WINAPI IDirectXFileDataImpl_AddRef(IDirectXFileData* iface)
1451 {
1452 IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1453 ULONG ref = InterlockedIncrement(&This->ref);
1454
1455 TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1456
1457 return ref;
1458 }
1459
1460 static ULONG WINAPI IDirectXFileDataImpl_Release(IDirectXFileData* iface)
1461 {
1462 IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1463 ULONG ref = InterlockedDecrement(&This->ref);
1464
1465 TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1466
1467 if (!ref)
1468 HeapFree(GetProcessHeap(), 0, This);
1469
1470 return ref;
1471 }
1472
1473 /*** IDirectXFileObject methods ***/
1474 static HRESULT WINAPI IDirectXFileDataImpl_GetName(IDirectXFileData* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1475
1476 {
1477 IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1478
1479 TRACE("(%p/%p)->(%p,%p)\n", This, iface, pstrNameBuf, pdwBufLen);
1480
1481 if (!pstrNameBuf)
1482 return DXFILEERR_BADVALUE;
1483
1484 strcpy(pstrNameBuf, This->pobj->name);
1485
1486 return DXFILE_OK;
1487 }
1488
1489 static HRESULT WINAPI IDirectXFileDataImpl_GetId(IDirectXFileData* iface, LPGUID pGuid)
1490 {
1491 IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1492
1493 TRACE("(%p/%p)->(%p)\n", This, iface, pGuid);
1494
1495 if (!pGuid)
1496 return DXFILEERR_BADVALUE;
1497
1498 memcpy(pGuid, &This->pobj->class_id, 16);
1499
1500 return DXFILE_OK;
1501 }
1502
1503 /*** IDirectXFileData methods ***/
1504 static HRESULT WINAPI IDirectXFileDataImpl_GetData(IDirectXFileData* iface, LPCSTR szMember, DWORD* pcbSize, void** ppvData)
1505 {
1506 IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1507
1508 TRACE("(%p/%p)->(%s,%p,%p)\n", This, iface, szMember, pcbSize, ppvData);
1509
1510 if (!pcbSize || !ppvData)
1511 return DXFILEERR_BADVALUE;
1512
1513 if (szMember)
1514 {
1515 FIXME("Specifying a member is not supported yet!\n");
1516 return DXFILEERR_BADVALUE;
1517 }
1518
1519 *pcbSize = This->pobj->size;
1520 *ppvData = This->pobj->pdata;
1521
1522 return DXFILE_OK;
1523 }
1524
1525 static HRESULT WINAPI IDirectXFileDataImpl_GetType(IDirectXFileData* iface, const GUID** pguid)
1526 {
1527 IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1528 static GUID guid;
1529
1530 TRACE("(%p/%p)->(%p)\n", This, iface, pguid);
1531
1532 if (!pguid)
1533 return DXFILEERR_BADVALUE;
1534
1535 memcpy(&guid, &This->pobj->type, 16);
1536 *pguid = &guid;
1537
1538 return DXFILE_OK;
1539 }
1540
1541 static HRESULT WINAPI IDirectXFileDataImpl_GetNextObject(IDirectXFileData* iface, LPDIRECTXFILEOBJECT* ppChildObj)
1542 {
1543 HRESULT hr;
1544 IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1545
1546 TRACE("(%p/%p)->(%p)\n", This, iface, ppChildObj);
1547
1548 if (This->cur_enum_object >= This->pobj->nb_childs)
1549 return DXFILEERR_NOMOREOBJECTS;
1550
1551 if (This->from_ref && (This->level >= 1))
1552 {
1553 /* Only 2 levels can enumerated if the object is obtained from a reference */
1554 return DXFILEERR_NOMOREOBJECTS;
1555 }
1556
1557 if (This->pobj->childs[This->cur_enum_object]->ptarget)
1558 {
1559 IDirectXFileDataReferenceImpl *object;
1560
1561 hr = IDirectXFileDataReferenceImpl_Create(&object);
1562 if (hr != S_OK)
1563 return DXFILEERR_BADVALUE;
1564
1565 object->ptarget = This->pobj->childs[This->cur_enum_object++]->ptarget;
1566
1567 *ppChildObj = (LPDIRECTXFILEOBJECT)object;
1568 }
1569 else
1570 {
1571 IDirectXFileDataImpl *object;
1572
1573 hr = IDirectXFileDataImpl_Create(&object);
1574 if (hr != S_OK)
1575 return DXFILEERR_BADVALUE;
1576
1577 object->pobj = This->pobj->childs[This->cur_enum_object++];
1578 object->cur_enum_object = 0;
1579 object->from_ref = This->from_ref;
1580 object->level = This->level + 1;
1581
1582 *ppChildObj = (LPDIRECTXFILEOBJECT)object;
1583 }
1584
1585 return DXFILE_OK;
1586 }
1587
1588 static HRESULT WINAPI IDirectXFileDataImpl_AddDataObject(IDirectXFileData* iface, LPDIRECTXFILEDATA pDataObj)
1589 {
1590 IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1591
1592 FIXME("(%p/%p)->(%p) stub!\n", This, iface, pDataObj);
1593
1594 return DXFILEERR_BADVALUE;
1595 }
1596
1597 static HRESULT WINAPI IDirectXFileDataImpl_AddDataReference(IDirectXFileData* iface, LPCSTR szRef, const GUID* pguidRef)
1598 {
1599 IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1600
1601 FIXME("(%p/%p)->(%s,%p) stub!\n", This, iface, szRef, pguidRef);
1602
1603 return DXFILEERR_BADVALUE;
1604 }
1605
1606 static HRESULT WINAPI IDirectXFileDataImpl_AddBinaryObject(IDirectXFileData* iface, LPCSTR szName, const GUID* pguid, LPCSTR szMimeType, LPVOID pvData, DWORD cbSize)
1607 {
1608 IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1609
1610 FIXME("(%p/%p)->(%s,%p,%s,%p,%d) stub!\n", This, iface, szName, pguid, szMimeType, pvData, cbSize);
1611
1612 return DXFILEERR_BADVALUE;
1613 }
1614
1615 static const IDirectXFileDataVtbl IDirectXFileData_Vtbl =
1616 {
1617 IDirectXFileDataImpl_QueryInterface,
1618 IDirectXFileDataImpl_AddRef,
1619 IDirectXFileDataImpl_Release,
1620 IDirectXFileDataImpl_GetName,
1621 IDirectXFileDataImpl_GetId,
1622 IDirectXFileDataImpl_GetData,
1623 IDirectXFileDataImpl_GetType,
1624 IDirectXFileDataImpl_GetNextObject,
1625 IDirectXFileDataImpl_AddDataObject,
1626 IDirectXFileDataImpl_AddDataReference,
1627 IDirectXFileDataImpl_AddBinaryObject
1628 };
1629
1630 HRESULT IDirectXFileDataReferenceImpl_Create(IDirectXFileDataReferenceImpl** ppObj)
1631 {
1632 IDirectXFileDataReferenceImpl* object;
1633
1634 TRACE("(%p)\n", ppObj);
1635
1636 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileDataReferenceImpl));
1637
1638 object->lpVtbl.lpVtbl = &IDirectXFileDataReference_Vtbl;
1639 object->ref = 1;
1640
1641 *ppObj = object;
1642
1643 return S_OK;
1644 }
1645
1646 /*** IUnknown methods ***/
1647 static HRESULT WINAPI IDirectXFileDataReferenceImpl_QueryInterface(IDirectXFileDataReference* iface, REFIID riid, void** ppvObject)
1648 {
1649 IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1650
1651 TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1652
1653 if (IsEqualGUID(riid, &IID_IUnknown)
1654 || IsEqualGUID(riid, &IID_IDirectXFileObject)
1655 || IsEqualGUID(riid, &IID_IDirectXFileDataReference))
1656 {
1657 IClassFactory_AddRef(iface);
1658 *ppvObject = This;
1659 return S_OK;
1660 }
1661
1662 /* Do not print an error for interfaces that can be queried to retrieve the type of the object */
1663 if (!IsEqualGUID(riid, &IID_IDirectXFileData)
1664 && !IsEqualGUID(riid, &IID_IDirectXFileBinary))
1665 ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1666
1667 return E_NOINTERFACE;
1668 }
1669
1670 static ULONG WINAPI IDirectXFileDataReferenceImpl_AddRef(IDirectXFileDataReference* iface)
1671 {
1672 IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1673 ULONG ref = InterlockedIncrement(&This->ref);
1674
1675 TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1676
1677 return ref;
1678 }
1679
1680 static ULONG WINAPI IDirectXFileDataReferenceImpl_Release(IDirectXFileDataReference* iface)
1681 {
1682 IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1683 ULONG ref = InterlockedDecrement(&This->ref);
1684
1685 TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1686
1687 if (!ref)
1688 HeapFree(GetProcessHeap(), 0, This);
1689
1690 return ref;
1691 }
1692
1693 /*** IDirectXFileObject methods ***/
1694 static HRESULT WINAPI IDirectXFileDataReferenceImpl_GetName(IDirectXFileDataReference* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1695 {
1696 IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1697
1698 TRACE("(%p/%p)->(%p,%p)\n", This, iface, pstrNameBuf, pdwBufLen);
1699
1700 if (!pstrNameBuf)
1701 return DXFILEERR_BADVALUE;
1702
1703 strcpy(pstrNameBuf, This->ptarget->name);
1704
1705 return DXFILEERR_BADVALUE;
1706 }
1707
1708 static HRESULT WINAPI IDirectXFileDataReferenceImpl_GetId(IDirectXFileDataReference* iface, LPGUID pGuid)
1709 {
1710 IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1711
1712 TRACE("(%p/%p)->(%p)\n", This, iface, pGuid);
1713
1714 if (!pGuid)
1715 return DXFILEERR_BADVALUE;
1716
1717 memcpy(pGuid, &This->ptarget->class_id, 16);
1718
1719 return DXFILE_OK;
1720 }
1721
1722 /*** IDirectXFileDataReference ***/
1723 static HRESULT WINAPI IDirectXFileDataReferenceImpl_Resolve(IDirectXFileDataReference* iface, LPDIRECTXFILEDATA* ppDataObj)
1724 {
1725 IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1726 IDirectXFileDataImpl *object;
1727 HRESULT hr;
1728
1729 TRACE("(%p/%p)->(%p)\n", This, iface, ppDataObj);
1730
1731 if (!ppDataObj)
1732 return DXFILEERR_BADVALUE;
1733
1734 hr = IDirectXFileDataImpl_Create(&object);
1735 if (hr != S_OK)
1736 return DXFILEERR_BADVALUE;
1737
1738 object->pobj = This->ptarget;
1739 object->cur_enum_object = 0;
1740 object->level = 0;
1741 object->from_ref = TRUE;
1742
1743 *ppDataObj = (LPDIRECTXFILEDATA)object;
1744
1745 return DXFILE_OK;
1746 }
1747
1748 static const IDirectXFileDataReferenceVtbl IDirectXFileDataReference_Vtbl =
1749 {
1750 IDirectXFileDataReferenceImpl_QueryInterface,
1751 IDirectXFileDataReferenceImpl_AddRef,
1752 IDirectXFileDataReferenceImpl_Release,
1753 IDirectXFileDataReferenceImpl_GetName,
1754 IDirectXFileDataReferenceImpl_GetId,
1755 IDirectXFileDataReferenceImpl_Resolve
1756 };
1757
1758 HRESULT IDirectXFileEnumObjectImpl_Create(IDirectXFileEnumObjectImpl** ppObj)
1759 {
1760 IDirectXFileEnumObjectImpl* object;
1761
1762 TRACE("(%p)\n", ppObj);
1763
1764 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileEnumObjectImpl));
1765
1766 object->lpVtbl.lpVtbl = &IDirectXFileEnumObject_Vtbl;
1767 object->ref = 1;
1768
1769 *ppObj = object;
1770
1771 return S_OK;
1772 }
1773
1774 /*** IUnknown methods ***/
1775 static HRESULT WINAPI IDirectXFileEnumObjectImpl_QueryInterface(IDirectXFileEnumObject* iface, REFIID riid, void** ppvObject)
1776 {
1777 IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1778
1779 TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1780
1781 if (IsEqualGUID(riid, &IID_IUnknown)
1782 || IsEqualGUID(riid, &IID_IDirectXFileEnumObject))
1783 {
1784 IClassFactory_AddRef(iface);
1785 *ppvObject = This;
1786 return S_OK;
1787 }
1788
1789 ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1790 return E_NOINTERFACE;
1791 }
1792
1793 static ULONG WINAPI IDirectXFileEnumObjectImpl_AddRef(IDirectXFileEnumObject* iface)
1794 {
1795 IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1796 ULONG ref = InterlockedIncrement(&This->ref);
1797
1798 TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1799
1800 return ref;
1801 }
1802
1803 static ULONG WINAPI IDirectXFileEnumObjectImpl_Release(IDirectXFileEnumObject* iface)
1804 {
1805 IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1806 ULONG ref = InterlockedDecrement(&This->ref);
1807
1808 TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1809
1810 if (!ref)
1811 {
1812 CloseHandle(This->hFile);
1813 HeapFree(GetProcessHeap(), 0, This);
1814 }
1815
1816 return ref;
1817 }
1818
1819 static BOOL parse_object_members_list(parse_buffer * buf)
1820 {
1821 DWORD token;
1822 int i;
1823 xtemplate* pt = buf->pxt[buf->level];
1824 DWORD last_dword = 0;
1825
1826 for (i = 0; i < pt->nb_members; i++)
1827 {
1828 int nb_elems, k;
1829
1830 if (pt->members[i].nb_dims > 1)
1831 {
1832 FIXME("Arrays with dimension > 1 not yet supported\n");
1833 return FALSE;
1834 }
1835 else if (pt->members[i].nb_dims)
1836 {
1837 if (!pt->members[i].dim_fixed[0])
1838 {
1839 if (!i)
1840 {
1841 FIXME("Array with variable must be preceded by the size\n");
1842 return FALSE;
1843 }
1844 nb_elems = last_dword;
1845 /*FIXME("Arrays with variable size not yet supported\n");
1846 return FALSE;*/
1847 }
1848 else
1849 nb_elems = pt->members[i].dim_value[0];
1850 }
1851 else
1852 nb_elems = 1;
1853
1854 for (k = 0; k < nb_elems; k++)
1855 {
1856 if (buf->txt && k)
1857 {
1858 token = check_TOKEN(buf);
1859 if (token == TOKEN_COMMA)
1860 {
1861 get_TOKEN(buf);
1862 }
1863 else
1864 {
1865 /* Allow comma omission */
1866 if (!((token == TOKEN_FLOAT)))
1867 return FALSE;
1868 }
1869 }
1870
1871 if (pt->members[i].type == TOKEN_NAME)
1872 {
1873 int j;
1874
1875 TRACE("Found suboject %s\n", buf->pdxf->xtemplates[pt->members[i].idx_template].name);
1876 buf->level++;
1877 /* To do template lookup */
1878 for (j = 0; j < buf->pdxf->nb_xtemplates; j++)
1879 {
1880 if (!strcmp(buf->pdxf->xtemplates[pt->members[i].idx_template].name, buf->pdxf->xtemplates[j].name))
1881 {
1882 buf->pxt[buf->level] = &buf->pdxf->xtemplates[j];
1883 break;
1884 }
1885 }
1886 if (j == buf->pdxf->nb_xtemplates)
1887 {
1888 FIXME("Unknown template %s\n", (char*)buf->value);
1889 buf->level--;
1890 return FALSE;
1891 }
1892 TRACE("Enter %s\n", buf->pdxf->xtemplates[pt->members[i].idx_template].name);
1893 if (!parse_object_parts(buf, FALSE))
1894 {
1895 buf->level--;
1896 return FALSE;
1897 }
1898 buf->level--;
1899 /*if (get_TOKEN(buf) != TOKEN_SEMICOLON)
1900 return FALSE;*/
1901 }
1902 else
1903 {
1904 token = check_TOKEN(buf);
1905 if (token == TOKEN_INTEGER)
1906 {
1907 get_TOKEN(buf);
1908 last_dword = *(DWORD*)buf->value;
1909 TRACE("%s = %d\n", pt->members[i].name, *(DWORD*)buf->value);
1910 /* Assume larger size */
1911 if ((buf->cur_pdata - buf->pdata + 4) > MAX_DATA_SIZE)
1912 {
1913 FIXME("Buffer too small\n");
1914 return FALSE;
1915 }
1916 if (pt->members[i].type == TOKEN_WORD)
1917 {
1918 *(((WORD*)(buf->cur_pdata))) = (WORD)(*(DWORD*)buf->value);
1919 buf->cur_pdata += 2;
1920 }
1921 else if (pt->members[i].type == TOKEN_DWORD)
1922 {
1923 *(((DWORD*)(buf->cur_pdata))) = (DWORD)(*(DWORD*)buf->value);
1924 buf->cur_pdata += 4;
1925 }
1926 else
1927 {
1928 FIXME("Token %d not supported\n", pt->members[i].type);
1929 return FALSE;
1930 }
1931 }
1932 else if (token == TOKEN_FLOAT)
1933 {
1934 get_TOKEN(buf);
1935 TRACE("%s = %f\n", pt->members[i].name, *(float*)buf->value);
1936 /* Assume larger size */
1937 if ((buf->cur_pdata - buf->pdata + 4) > MAX_DATA_SIZE)
1938 {
1939 FIXME("Buffer too small\n");
1940 return FALSE;
1941 }
1942 if (pt->members[i].type == TOKEN_FLOAT)
1943 {
1944 *(((float*)(buf->cur_pdata))) = (float)(*(float*)buf->value);
1945 buf->cur_pdata += 4;
1946 }
1947 else
1948 {
1949 FIXME("Token %d not supported\n", pt->members[i].type);
1950 return FALSE;
1951 }
1952 }
1953 else if (token == TOKEN_LPSTR)
1954 {
1955 get_TOKEN(buf);
1956 TRACE("%s = %s\n", pt->members[i].name, (char*)buf->value);
1957 /* Assume larger size */
1958 if ((buf->cur_pdata - buf->pdata + 4) > MAX_DATA_SIZE)
1959 {
1960 FIXME("Buffer too small\n");
1961 return FALSE;
1962 }
1963 if (pt->members[i].type == TOKEN_LPSTR)
1964 {
1965 int len = strlen((char*)buf->value) + 1;
1966 if ((buf->cur_pstrings - buf->pstrings + len) > MAX_STRINGS_BUFFER)
1967 {
1968 FIXME("Buffer too small %p %p %d\n", buf->cur_pstrings, buf->pstrings, len);
1969 return FALSE;
1970 }
1971 strcpy((char*)buf->cur_pstrings, (char*)buf->value);
1972 *(((LPCSTR*)(buf->cur_pdata))) = (char*)buf->cur_pstrings;
1973 buf->cur_pstrings += len;
1974 buf->cur_pdata += 4;
1975 }
1976 else
1977 {
1978 FIXME("Token %d not supported\n", pt->members[i].type);
1979 return FALSE;
1980 }
1981 }
1982 else
1983 {
1984 FIXME("Unexpected token %d\n", token);
1985 return FALSE;
1986 }
1987 }
1988 }
1989
1990 if (buf->txt)
1991 {
1992 token = get_TOKEN(buf);
1993 if (token != TOKEN_SEMICOLON)
1994 {
1995 /* Allow comma instead of semicolon in some specific cases */
1996 if (!((token == TOKEN_COMMA) && ((i+1) < pt->nb_members) && (pt->members[i].type == pt->members[i+1].type)
1997 && (!pt->members[i].nb_dims) && (!pt->members[i+1].nb_dims)))
1998 return FALSE;
1999 }
2000 }
2001 }
2002
2003 return TRUE;
2004 }
2005
2006 static BOOL parse_object_parts(parse_buffer * buf, BOOL allow_optional)
2007 {
2008 if (!parse_object_members_list(buf))
2009 return FALSE;
2010
2011 if (allow_optional)
2012 {
2013 buf->pxo->size = buf->cur_pdata - buf->pxo->pdata;
2014
2015 /* Skip trailing semicolon */
2016 while (check_TOKEN(buf) == TOKEN_SEMICOLON)
2017 get_TOKEN(buf);
2018
2019 while (1)
2020 {
2021 if (check_TOKEN(buf) == TOKEN_OBRACE)
2022 {
2023 int i, j;
2024 get_TOKEN(buf);
2025 if (get_TOKEN(buf) != TOKEN_NAME)
2026 return FALSE;
2027 if (get_TOKEN(buf) != TOKEN_CBRACE)
2028 return FALSE;
2029 TRACE("Found optional reference %s\n", (char*)buf->value);
2030 for (i = 0; i < buf->nb_pxo_globals; i++)
2031 {
2032 for (j = 0; j < buf->pxo_globals[i*MAX_SUBOBJECTS].nb_subobjects; j++)
2033 {
2034 if (!strcmp(buf->pxo_globals[i*MAX_SUBOBJECTS+j].name, (char*)buf->value))
2035 goto _exit;
2036 }
2037 }
2038 _exit:
2039 if (i == buf->nb_pxo_globals)
2040 {
2041 ERR("Reference to unknown object %s\n", (char*)buf->value);
2042 return FALSE;
2043 }
2044 buf->pxo->childs[buf->pxo->nb_childs] = &buf->pxo_tab[buf->cur_subobject++];
2045 buf->pxo->childs[buf->pxo->nb_childs]->ptarget = &buf->pxo_globals[i*MAX_SUBOBJECTS+j];
2046 buf->pxo->nb_childs++;
2047 }
2048 else if (check_TOKEN(buf) == TOKEN_NAME)
2049 {
2050 xobject* pxo = buf->pxo;
2051 buf->pxo = buf->pxo->childs[buf->pxo->nb_childs] = &buf->pxo_tab[buf->cur_subobject++];
2052
2053 TRACE("Enter optional %s\n", (char*)buf->value);
2054 buf->level++;
2055 if (!parse_object(buf))
2056 {
2057 buf->level--;
2058 return FALSE;
2059 }
2060 buf->level--;
2061 buf->pxo = pxo;
2062 buf->pxo->nb_childs++;
2063 }
2064 else
2065 break;
2066 }
2067 }
2068
2069 if (buf->pxo->nb_childs > MAX_CHILDS)
2070 {
2071 FIXME("Too many childs %d\n", buf->pxo->nb_childs);
2072 return FALSE;
2073 }
2074
2075 return TRUE;
2076 }
2077
2078 static BOOL parse_object(parse_buffer * buf)
2079 {
2080 int i;
2081
2082 buf->pxo->pdata = buf->cur_pdata;
2083 buf->pxo->ptarget = NULL;
2084
2085 if (get_TOKEN(buf) != TOKEN_NAME)
2086 return FALSE;
2087
2088 /* To do template lookup */
2089 for (i = 0; i < buf->pdxf->nb_xtemplates; i++)
2090 {
2091 if (!strcmp((char*)buf->value, buf->pdxf->xtemplates[i].name))
2092 {
2093 buf->pxt[buf->level] = &buf->pdxf->xtemplates[i];
2094 memcpy(&buf->pxo->type, &buf->pdxf->xtemplates[i].class_id, 16);
2095 break;
2096 }
2097 }
2098 if (i == buf->pdxf->nb_xtemplates)
2099 {
2100 FIXME("Unknown template %s\n", (char*)buf->value);
2101 return FALSE;
2102 }
2103
2104 if (check_TOKEN(buf) == TOKEN_NAME)
2105 {
2106 get_TOKEN(buf);
2107 strcpy(buf->pxo->name, (char*)buf->value);
2108 }
2109 else
2110 buf->pxo->name[0] = 0;
2111
2112 if (get_TOKEN(buf) != TOKEN_OBRACE)
2113 return FALSE;
2114 if (check_TOKEN(buf) == TOKEN_GUID)
2115 {
2116 get_TOKEN(buf);
2117 memcpy(&buf->pxo->class_id, buf->value, 16);
2118 }
2119 else
2120 memset(&buf->pxo->class_id, 0, 16);
2121
2122 if (!parse_object_parts(buf, TRUE))
2123 return FALSE;
2124 if (get_TOKEN(buf) != TOKEN_CBRACE)
2125 return FALSE;
2126
2127 if (buf->txt)
2128 {
2129 /* Go to the next object */
2130 while (buf->rem_bytes && is_space(*buf->buffer))
2131 {
2132 buf->buffer++;
2133 buf->rem_bytes--;
2134 }
2135 }
2136
2137 return TRUE;
2138 }
2139
2140 /*** IDirectXFileEnumObject methods ***/
2141 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetNextDataObject(IDirectXFileEnumObject* iface, LPDIRECTXFILEDATA* ppDataObj)
2142 {
2143 IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
2144 IDirectXFileDataImpl* object;
2145 HRESULT hr;
2146 LPBYTE pdata;
2147 LPBYTE pstrings;
2148
2149 TRACE("(%p/%p)->(%p)\n", This, iface, ppDataObj);
2150
2151 if (This->nb_xobjects >= MAX_OBJECTS)
2152 {
2153 ERR("Too many objects\n");
2154 return DXFILEERR_NOMOREOBJECTS;
2155 }
2156
2157 if (!This->buf.rem_bytes)
2158 return DXFILEERR_NOMOREOBJECTS;
2159
2160 hr = IDirectXFileDataImpl_Create(&object);
2161 if (FAILED(hr))
2162 return hr;
2163
2164 This->buf.pxo_globals = &This->xobjects[0][0];
2165 This->buf.nb_pxo_globals = This->nb_xobjects;
2166 This->buf.pxo_tab = &This->xobjects[This->nb_xobjects][0];
2167 This->buf.cur_subobject = 0;
2168 This->buf.pxo = &This->buf.pxo_tab[This->buf.cur_subobject++];
2169 This->buf.level = 0;
2170
2171 pdata = HeapAlloc(GetProcessHeap(), 0, MAX_DATA_SIZE);
2172 if (!pdata)
2173 {
2174 WARN("Out of memory\n");
2175 return DXFILEERR_BADALLOC;
2176 }
2177 This->buf.cur_pdata = This->buf.pdata = pdata;
2178
2179 pstrings = HeapAlloc(GetProcessHeap(), 0, MAX_STRINGS_BUFFER);
2180 if (!pstrings)
2181 {
2182 WARN("Out of memory\n");
2183 HeapFree(GetProcessHeap(), 0, This->buf.pxo->pdata);
2184 return DXFILEERR_BADALLOC;
2185 }
2186 This->buf.cur_pstrings = This->buf.pstrings = pstrings;
2187
2188 if (!parse_object(&This->buf))
2189 {
2190 TRACE("Object is not correct\n");
2191 HeapFree(GetProcessHeap(), 0, This->buf.pxo->pdata);
2192 HeapFree(GetProcessHeap(), 0, This->buf.pstrings);
2193 return DXFILEERR_PARSEERROR;
2194 }
2195
2196 This->buf.pxo->nb_subobjects = This->buf.cur_subobject;
2197 if (This->buf.cur_subobject > MAX_SUBOBJECTS)
2198 {
2199 FIXME("Too many suobjects %d\n", This->buf.cur_subobject);
2200 return DXFILEERR_BADALLOC;
2201 }
2202
2203 object->pstrings = pstrings;
2204 object->pobj = This->buf.pxo;
2205 object->cur_enum_object = 0;
2206 object->level = 0;
2207 object->from_ref = FALSE;
2208
2209 *ppDataObj = (LPDIRECTXFILEDATA)object;
2210
2211 This->nb_xobjects++;
2212
2213 return DXFILE_OK;
2214 }
2215
2216 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetDataObjectById(IDirectXFileEnumObject* iface, REFGUID rguid, LPDIRECTXFILEDATA* ppDataObj)
2217 {
2218 IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
2219
2220 FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, rguid, ppDataObj);
2221
2222 return DXFILEERR_BADVALUE;
2223 }
2224
2225 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetDataObjectByName(IDirectXFileEnumObject* iface, LPCSTR szName, LPDIRECTXFILEDATA* ppDataObj)
2226 {
2227 IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
2228
2229 FIXME("(%p/%p)->(%s,%p) stub!\n", This, iface, szName, ppDataObj);
2230
2231 return DXFILEERR_BADVALUE;
2232 }
2233
2234 static const IDirectXFileEnumObjectVtbl IDirectXFileEnumObject_Vtbl =
2235 {
2236 IDirectXFileEnumObjectImpl_QueryInterface,
2237 IDirectXFileEnumObjectImpl_AddRef,
2238 IDirectXFileEnumObjectImpl_Release,
2239 IDirectXFileEnumObjectImpl_GetNextDataObject,
2240 IDirectXFileEnumObjectImpl_GetDataObjectById,
2241 IDirectXFileEnumObjectImpl_GetDataObjectByName
2242 };
2243
2244 HRESULT IDirectXFileObjectImpl_Create(IDirectXFileObjectImpl** ppObj)
2245 {
2246 IDirectXFileObjectImpl* object;
2247
2248 TRACE("(%p)\n", ppObj);
2249
2250 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileObjectImpl));
2251
2252 object->lpVtbl.lpVtbl = &IDirectXFileObject_Vtbl;
2253 object->ref = 1;
2254
2255 *ppObj = object;
2256
2257 return S_OK;
2258 }
2259
2260 /*** IUnknown methods ***/
2261 static HRESULT WINAPI IDirectXFileObjectImpl_QueryInterface(IDirectXFileObject* iface, REFIID riid, void** ppvObject)
2262 {
2263 IDirectXFileObjectImpl *This = (IDirectXFileObjectImpl *)iface;
2264
2265 TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
2266
2267 if (IsEqualGUID(riid, &IID_IUnknown)
2268 || IsEqualGUID(riid, &IID_IDirectXFileObject))
2269 {
2270 IClassFactory_AddRef(iface);
2271 *ppvObject = This;
2272 return S_OK;
2273 }
2274
2275 ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
2276 return E_NOINTERFACE;
2277 }
2278
2279 static ULONG WINAPI IDirectXFileObjectImpl_AddRef(IDirectXFileObject* iface)
2280 {
2281 IDirectXFileObjectImpl *This = (IDirectXFileObjectImpl *)iface;
2282 ULONG ref = InterlockedIncrement(&This->ref);
2283
2284 TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
2285
2286 return ref;
2287 }
2288
2289 static ULONG WINAPI IDirectXFileObjectImpl_Release(IDirectXFileObject* iface)
2290 {
2291 IDirectXFileObjectImpl *This = (IDirectXFileObjectImpl *)iface;
2292 ULONG ref = InterlockedDecrement(&This->ref);
2293
2294 TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
2295
2296 if (!ref)
2297 HeapFree(GetProcessHeap(), 0, This);
2298
2299 return ref;
2300 }
2301
2302 /*** IDirectXFileObject methods ***/
2303 static HRESULT WINAPI IDirectXFileObjectImpl_GetName(IDirectXFileObject* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
2304 {
2305 IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
2306
2307 FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, pstrNameBuf, pdwBufLen);
2308
2309 return DXFILEERR_BADVALUE;
2310 }
2311
2312 static HRESULT WINAPI IDirectXFileObjectImpl_GetId(IDirectXFileObject* iface, LPGUID pGuid)
2313 {
2314 IDirectXFileObjectImpl *This = (IDirectXFileObjectImpl *)iface;
2315
2316 FIXME("(%p/%p)->(%p) stub!\n", This, iface, pGuid);
2317
2318 return DXFILEERR_BADVALUE;
2319 }
2320
2321 static const IDirectXFileObjectVtbl IDirectXFileObject_Vtbl =
2322 {
2323 IDirectXFileObjectImpl_QueryInterface,
2324 IDirectXFileObjectImpl_AddRef,
2325 IDirectXFileObjectImpl_Release,
2326 IDirectXFileObjectImpl_GetName,
2327 IDirectXFileObjectImpl_GetId
2328 };
2329
2330 HRESULT IDirectXFileSaveObjectImpl_Create(IDirectXFileSaveObjectImpl** ppObj)
2331 {
2332 IDirectXFileSaveObjectImpl* object;
2333
2334 TRACE("(%p)\n", ppObj);
2335
2336 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileSaveObjectImpl));
2337
2338 object->lpVtbl.lpVtbl = &IDirectXFileSaveObject_Vtbl;
2339 object->ref = 1;
2340
2341 *ppObj = object;
2342
2343 return S_OK;
2344 }
2345
2346 /*** IUnknown methods ***/
2347 static HRESULT WINAPI IDirectXFileSaveObjectImpl_QueryInterface(IDirectXFileSaveObject* iface, REFIID riid, void** ppvObject)
2348 {
2349 IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
2350
2351 TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
2352
2353 if (IsEqualGUID(riid, &IID_IUnknown)
2354 || IsEqualGUID(riid, &IID_IDirectXFileSaveObject))
2355 {
2356 IClassFactory_AddRef(iface);
2357 *ppvObject = This;
2358 return S_OK;
2359 }
2360
2361 ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
2362 return E_NOINTERFACE;
2363 }
2364
2365 static ULONG WINAPI IDirectXFileSaveObjectImpl_AddRef(IDirectXFileSaveObject* iface)
2366 {
2367 IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
2368 ULONG ref = InterlockedIncrement(&This->ref);
2369
2370 TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
2371
2372 return ref;
2373 }
2374
2375 static ULONG WINAPI IDirectXFileSaveObjectImpl_Release(IDirectXFileSaveObject* iface)
2376 {
2377 IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
2378 ULONG ref = InterlockedDecrement(&This->ref);
2379
2380 TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
2381
2382 if (!ref)
2383 HeapFree(GetProcessHeap(), 0, This);
2384
2385 return ref;
2386 }
2387
2388 static HRESULT WINAPI IDirectXFileSaveObjectImpl_SaveTemplates(IDirectXFileSaveObject* iface, DWORD cTemplates, const GUID** ppguidTemplates)
2389 {
2390 IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
2391
2392 FIXME("(%p/%p)->(%d,%p) stub!\n", This, iface, cTemplates, ppguidTemplates);
2393
2394 return DXFILEERR_BADVALUE;
2395 }
2396
2397 static HRESULT WINAPI IDirectXFileSaveObjectImpl_CreateDataObject(IDirectXFileSaveObject* iface, REFGUID rguidTemplate, LPCSTR szName, const GUID* pguid, DWORD cbSize, LPVOID pvData, LPDIRECTXFILEDATA* ppDataObj)
2398 {
2399 IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
2400
2401 FIXME("(%p/%p)->(%p,%s,%p,%d,%p,%p) stub!\n", This, iface, rguidTemplate, szName, pguid, cbSize, pvData, ppDataObj);
2402
2403 return DXFILEERR_BADVALUE;
2404 }
2405
2406 static HRESULT WINAPI IDirectXFileSaveObjectImpl_SaveData(IDirectXFileSaveObject* iface, LPDIRECTXFILEDATA ppDataObj)
2407 {
2408 IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
2409
2410 FIXME("(%p/%p)->(%p) stub!\n", This, iface, ppDataObj);
2411
2412 return DXFILEERR_BADVALUE;
2413 }
2414
2415 static const IDirectXFileSaveObjectVtbl IDirectXFileSaveObject_Vtbl =
2416 {
2417 IDirectXFileSaveObjectImpl_QueryInterface,
2418 IDirectXFileSaveObjectImpl_AddRef,
2419 IDirectXFileSaveObjectImpl_Release,
2420 IDirectXFileSaveObjectImpl_SaveTemplates,
2421 IDirectXFileSaveObjectImpl_CreateDataObject,
2422 IDirectXFileSaveObjectImpl_SaveData
2423 };
useful hacks and other patches not (yet) suitable for mainline