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