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