dlls/d3dxof/d3dxof.c

   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 (!strcasecmp((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         ERR("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   {
1542     if (!This->level)
1543     {
1544       HeapFree(GetProcessHeap(), 0, This->pdata);
1545       HeapFree(GetProcessHeap(), 0, This->pstrings);
1546     }
1547     HeapFree(GetProcessHeap(), 0, This);
1548   }
1549
1550   return ref;
1551 }
1552
1553 /*** IDirectXFileObject methods ***/
1554 static HRESULT WINAPI IDirectXFileDataImpl_GetName(IDirectXFileData* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1555
1556 {
1557   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1558
1559   TRACE("(%p/%p)->(%p,%p)\n", This, iface, pstrNameBuf, pdwBufLen);
1560
1561   if (!pstrNameBuf)
1562     return DXFILEERR_BADVALUE;
1563
1564   strcpy(pstrNameBuf, This->pobj->name);
1565
1566   return DXFILE_OK;
1567 }
1568
1569 static HRESULT WINAPI IDirectXFileDataImpl_GetId(IDirectXFileData* iface, LPGUID pGuid)
1570 {
1571   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1572
1573   TRACE("(%p/%p)->(%p)\n", This, iface, pGuid);
1574
1575   if (!pGuid)
1576     return DXFILEERR_BADVALUE;
1577
1578   memcpy(pGuid, &This->pobj->class_id, 16);
1579
1580   return DXFILE_OK;
1581 }
1582
1583 /*** IDirectXFileData methods ***/
1584 static HRESULT WINAPI IDirectXFileDataImpl_GetData(IDirectXFileData* iface, LPCSTR szMember, DWORD* pcbSize, void** ppvData)
1585 {
1586   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1587
1588   TRACE("(%p/%p)->(%s,%p,%p)\n", This, iface, szMember, pcbSize, ppvData);
1589
1590   if (!pcbSize || !ppvData)
1591     return DXFILEERR_BADVALUE;
1592
1593   if (szMember)
1594   {
1595     FIXME("Specifying a member is not supported yet!\n");
1596     return DXFILEERR_BADVALUE;
1597   }
1598
1599   *pcbSize = This->pobj->size;
1600   *ppvData = This->pobj->pdata;
1601
1602   return DXFILE_OK;
1603 }
1604
1605 static HRESULT WINAPI IDirectXFileDataImpl_GetType(IDirectXFileData* iface, const GUID** pguid)
1606 {
1607   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1608   static GUID guid;
1609
1610   TRACE("(%p/%p)->(%p)\n", This, iface, pguid);
1611
1612   if (!pguid)
1613     return DXFILEERR_BADVALUE;
1614
1615   memcpy(&guid, &This->pobj->type, 16);
1616   *pguid = &guid;
1617
1618   return DXFILE_OK;
1619 }
1620
1621 static HRESULT WINAPI IDirectXFileDataImpl_GetNextObject(IDirectXFileData* iface, LPDIRECTXFILEOBJECT* ppChildObj)
1622 {
1623   HRESULT hr;
1624   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1625
1626   TRACE("(%p/%p)->(%p)\n", This, iface, ppChildObj);
1627
1628   if (This->cur_enum_object >= This->pobj->nb_childs)
1629     return DXFILEERR_NOMOREOBJECTS;
1630
1631   if (This->from_ref && (This->level >= 1))
1632   {
1633     /* Only 2 levels can enumerated if the object is obtained from a reference */
1634     return DXFILEERR_NOMOREOBJECTS;
1635   }
1636
1637   if (This->pobj->childs[This->cur_enum_object]->binary)
1638   {
1639     IDirectXFileBinaryImpl *object;
1640
1641     hr = IDirectXFileBinaryImpl_Create(&object);
1642     if (FAILED(hr))
1643       return hr;
1644
1645     *ppChildObj = (LPDIRECTXFILEOBJECT)object;
1646   }
1647   else if (This->pobj->childs[This->cur_enum_object]->ptarget)
1648   {
1649     IDirectXFileDataReferenceImpl *object;
1650
1651     hr = IDirectXFileDataReferenceImpl_Create(&object);
1652     if (FAILED(hr))
1653       return hr;
1654
1655     object->ptarget = This->pobj->childs[This->cur_enum_object++]->ptarget;
1656
1657     *ppChildObj = (LPDIRECTXFILEOBJECT)object;
1658   }
1659   else
1660   {
1661     IDirectXFileDataImpl *object;
1662
1663     hr = IDirectXFileDataImpl_Create(&object);
1664     if (FAILED(hr))
1665       return hr;
1666
1667     object->pobj = This->pobj->childs[This->cur_enum_object++];
1668     object->cur_enum_object = 0;
1669     object->from_ref = This->from_ref;
1670     object->level = This->level + 1;
1671
1672     *ppChildObj = (LPDIRECTXFILEOBJECT)object;
1673   }
1674
1675   return DXFILE_OK;
1676 }
1677
1678 static HRESULT WINAPI IDirectXFileDataImpl_AddDataObject(IDirectXFileData* iface, LPDIRECTXFILEDATA pDataObj)
1679 {
1680   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1681
1682   FIXME("(%p/%p)->(%p) stub!\n", This, iface, pDataObj);
1683
1684   return DXFILEERR_BADVALUE;
1685 }
1686
1687 static HRESULT WINAPI IDirectXFileDataImpl_AddDataReference(IDirectXFileData* iface, LPCSTR szRef, const GUID* pguidRef)
1688 {
1689   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1690
1691   FIXME("(%p/%p)->(%s,%p) stub!\n", This, iface, szRef, pguidRef);
1692
1693   return DXFILEERR_BADVALUE;
1694 }
1695
1696 static HRESULT WINAPI IDirectXFileDataImpl_AddBinaryObject(IDirectXFileData* iface, LPCSTR szName, const GUID* pguid, LPCSTR szMimeType, LPVOID pvData, DWORD cbSize)
1697 {
1698   IDirectXFileDataImpl *This = (IDirectXFileDataImpl *)iface;
1699
1700   FIXME("(%p/%p)->(%s,%p,%s,%p,%d) stub!\n", This, iface, szName, pguid, szMimeType, pvData, cbSize);
1701
1702   return DXFILEERR_BADVALUE;
1703 }
1704
1705 static const IDirectXFileDataVtbl IDirectXFileData_Vtbl =
1706 {
1707     IDirectXFileDataImpl_QueryInterface,
1708     IDirectXFileDataImpl_AddRef,
1709     IDirectXFileDataImpl_Release,
1710     IDirectXFileDataImpl_GetName,
1711     IDirectXFileDataImpl_GetId,
1712     IDirectXFileDataImpl_GetData,
1713     IDirectXFileDataImpl_GetType,
1714     IDirectXFileDataImpl_GetNextObject,
1715     IDirectXFileDataImpl_AddDataObject,
1716     IDirectXFileDataImpl_AddDataReference,
1717     IDirectXFileDataImpl_AddBinaryObject
1718 };
1719
1720 static HRESULT IDirectXFileDataReferenceImpl_Create(IDirectXFileDataReferenceImpl** ppObj)
1721 {
1722     IDirectXFileDataReferenceImpl* object;
1723
1724     TRACE("(%p)\n", ppObj);
1725
1726     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileDataReferenceImpl));
1727     if (!object)
1728     {
1729         ERR("Out of memory\n");
1730         return DXFILEERR_BADALLOC;
1731     }
1732
1733     object->lpVtbl.lpVtbl = &IDirectXFileDataReference_Vtbl;
1734     object->ref = 1;
1735
1736     *ppObj = object;
1737
1738     return S_OK;
1739 }
1740
1741 /*** IUnknown methods ***/
1742 static HRESULT WINAPI IDirectXFileDataReferenceImpl_QueryInterface(IDirectXFileDataReference* iface, REFIID riid, void** ppvObject)
1743 {
1744   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1745
1746   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1747
1748   if (IsEqualGUID(riid, &IID_IUnknown)
1749       || IsEqualGUID(riid, &IID_IDirectXFileObject)
1750       || IsEqualGUID(riid, &IID_IDirectXFileDataReference))
1751   {
1752     IClassFactory_AddRef(iface);
1753     *ppvObject = This;
1754     return S_OK;
1755   }
1756
1757   /* Do not print an error for interfaces that can be queried to retrieve the type of the object */
1758   if (!IsEqualGUID(riid, &IID_IDirectXFileData)
1759       && !IsEqualGUID(riid, &IID_IDirectXFileBinary))
1760     ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1761
1762   return E_NOINTERFACE;
1763 }
1764
1765 static ULONG WINAPI IDirectXFileDataReferenceImpl_AddRef(IDirectXFileDataReference* iface)
1766 {
1767   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1768   ULONG ref = InterlockedIncrement(&This->ref);
1769
1770   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1771
1772   return ref;
1773 }
1774
1775 static ULONG WINAPI IDirectXFileDataReferenceImpl_Release(IDirectXFileDataReference* iface)
1776 {
1777   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1778   ULONG ref = InterlockedDecrement(&This->ref);
1779
1780   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1781
1782   if (!ref)
1783     HeapFree(GetProcessHeap(), 0, This);
1784
1785   return ref;
1786 }
1787
1788 /*** IDirectXFileObject methods ***/
1789 static HRESULT WINAPI IDirectXFileDataReferenceImpl_GetName(IDirectXFileDataReference* iface, LPSTR pstrNameBuf, LPDWORD pdwBufLen)
1790 {
1791   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1792
1793   TRACE("(%p/%p)->(%p,%p)\n", This, iface, pstrNameBuf, pdwBufLen);
1794
1795   if (!pstrNameBuf)
1796     return DXFILEERR_BADVALUE;
1797
1798   strcpy(pstrNameBuf, This->ptarget->name);
1799
1800   return DXFILEERR_BADVALUE;
1801 }
1802
1803 static HRESULT WINAPI IDirectXFileDataReferenceImpl_GetId(IDirectXFileDataReference* iface, LPGUID pGuid)
1804 {
1805   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1806
1807   TRACE("(%p/%p)->(%p)\n", This, iface, pGuid);
1808
1809   if (!pGuid)
1810     return DXFILEERR_BADVALUE;
1811
1812   memcpy(pGuid, &This->ptarget->class_id, 16);
1813
1814   return DXFILE_OK;
1815 }
1816
1817 /*** IDirectXFileDataReference ***/
1818 static HRESULT WINAPI IDirectXFileDataReferenceImpl_Resolve(IDirectXFileDataReference* iface, LPDIRECTXFILEDATA* ppDataObj)
1819 {
1820   IDirectXFileDataReferenceImpl *This = (IDirectXFileDataReferenceImpl *)iface;
1821   IDirectXFileDataImpl *object;
1822   HRESULT hr;
1823
1824   TRACE("(%p/%p)->(%p)\n", This, iface, ppDataObj);
1825
1826   if (!ppDataObj)
1827     return DXFILEERR_BADVALUE;
1828
1829   hr = IDirectXFileDataImpl_Create(&object);
1830   if (FAILED(hr))
1831     return hr;
1832
1833   object->pobj = This->ptarget;
1834   object->cur_enum_object = 0;
1835   object->level = 0;
1836   object->from_ref = TRUE;
1837
1838   *ppDataObj = (LPDIRECTXFILEDATA)object;
1839
1840   return DXFILE_OK;
1841 }
1842
1843 static const IDirectXFileDataReferenceVtbl IDirectXFileDataReference_Vtbl =
1844 {
1845     IDirectXFileDataReferenceImpl_QueryInterface,
1846     IDirectXFileDataReferenceImpl_AddRef,
1847     IDirectXFileDataReferenceImpl_Release,
1848     IDirectXFileDataReferenceImpl_GetName,
1849     IDirectXFileDataReferenceImpl_GetId,
1850     IDirectXFileDataReferenceImpl_Resolve
1851 };
1852
1853 static HRESULT IDirectXFileEnumObjectImpl_Create(IDirectXFileEnumObjectImpl** ppObj)
1854 {
1855     IDirectXFileEnumObjectImpl* object;
1856
1857     TRACE("(%p)\n", ppObj);
1858
1859     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileEnumObjectImpl));
1860     if (!object)
1861     {
1862         ERR("Out of memory\n");
1863         return DXFILEERR_BADALLOC;
1864     }
1865
1866     object->lpVtbl.lpVtbl = &IDirectXFileEnumObject_Vtbl;
1867     object->ref = 1;
1868
1869     *ppObj = object;
1870
1871     return S_OK;
1872 }
1873
1874 /*** IUnknown methods ***/
1875 static HRESULT WINAPI IDirectXFileEnumObjectImpl_QueryInterface(IDirectXFileEnumObject* iface, REFIID riid, void** ppvObject)
1876 {
1877   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1878
1879   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
1880
1881   if (IsEqualGUID(riid, &IID_IUnknown)
1882       || IsEqualGUID(riid, &IID_IDirectXFileEnumObject))
1883   {
1884     IClassFactory_AddRef(iface);
1885     *ppvObject = This;
1886     return S_OK;
1887   }
1888
1889   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
1890   return E_NOINTERFACE;
1891 }
1892
1893 static ULONG WINAPI IDirectXFileEnumObjectImpl_AddRef(IDirectXFileEnumObject* iface)
1894 {
1895   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1896   ULONG ref = InterlockedIncrement(&This->ref);
1897
1898   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
1899
1900   return ref;
1901 }
1902
1903 static ULONG WINAPI IDirectXFileEnumObjectImpl_Release(IDirectXFileEnumObject* iface)
1904 {
1905   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
1906   ULONG ref = InterlockedDecrement(&This->ref);
1907
1908   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
1909
1910   if (!ref)
1911   {
1912     int i;
1913     for (i = 0; i < This->nb_xobjects; i++)
1914     {
1915       IDirectXFileData_Release(This->pRefObjects[i]);
1916       HeapFree(GetProcessHeap(), 0, This->xobjects[i]);
1917     }
1918     if (This->source == DXFILELOAD_FROMFILE)
1919     {
1920       HeapFree(GetProcessHeap(), 0, This->buf.buffer);
1921       CloseHandle(This->hFile);
1922     }
1923     HeapFree(GetProcessHeap(), 0, This);
1924   }
1925
1926   return ref;
1927 }
1928
1929 static BOOL parse_object_members_list(parse_buffer * buf)
1930 {
1931   DWORD token;
1932   int i;
1933   xtemplate* pt = buf->pxt[buf->level];
1934   DWORD last_dword = 0;
1935
1936   for (i = 0; i < pt->nb_members; i++)
1937   {
1938     int k;
1939     int nb_elems = 1;
1940
1941     buf->pxo->members[i].name = pt->members[i].name;
1942     buf->pxo->members[i].start = buf->cur_pdata;
1943
1944     for (k = 0; k < pt->members[i].nb_dims; k++)
1945     {
1946       if (pt->members[i].dim_fixed[k])
1947         nb_elems *= pt->members[i].dim_value[k];
1948       else
1949         nb_elems *= *(DWORD*)buf->pxo->members[pt->members[i].dim_value[k]].start;
1950     }
1951
1952     TRACE("Elements to consider: %d\n", nb_elems);
1953
1954     for (k = 0; k < nb_elems; k++)
1955     {
1956       if (buf->txt && k)
1957       {
1958         token = check_TOKEN(buf);
1959         if (token == TOKEN_COMMA)
1960         {
1961           get_TOKEN(buf);
1962         }
1963         else
1964         {
1965           /* Allow comma omission */
1966           if (!((token == TOKEN_FLOAT) || (token == TOKEN_INTEGER)))
1967             return FALSE;
1968         }
1969       }
1970
1971       if (pt->members[i].type == TOKEN_NAME)
1972       {
1973         int j;
1974
1975         TRACE("Found sub-object %s\n", buf->pdxf->xtemplates[pt->members[i].idx_template].name);
1976         buf->level++;
1977         /* To do template lookup */
1978         for (j = 0; j < buf->pdxf->nb_xtemplates; j++)
1979         {
1980           if (!strcasecmp(buf->pdxf->xtemplates[pt->members[i].idx_template].name, buf->pdxf->xtemplates[j].name))
1981           {
1982             buf->pxt[buf->level] = &buf->pdxf->xtemplates[j];
1983             break;
1984           }
1985         }
1986         if (j == buf->pdxf->nb_xtemplates)
1987         {
1988           ERR("Unknown template %s\n", (char*)buf->value);
1989           buf->level--;
1990           return FALSE;
1991         }
1992         TRACE("Enter %s\n", buf->pdxf->xtemplates[pt->members[i].idx_template].name);
1993         if (!parse_object_parts(buf, FALSE))
1994         {
1995           buf->level--;
1996           return FALSE;
1997         }
1998         buf->level--;
1999       }
2000       else
2001       {
2002         token = check_TOKEN(buf);
2003         if (token == TOKEN_INTEGER)
2004         {
2005           get_TOKEN(buf);
2006           last_dword = *(DWORD*)buf->value;
2007           TRACE("%s = %d\n", pt->members[i].name, *(DWORD*)buf->value);
2008           /* Assume larger size */
2009           if ((buf->cur_pdata - buf->pdata + 4) > MAX_DATA_SIZE)
2010           {
2011             FIXME("Buffer too small\n");
2012             return FALSE;
2013           }
2014           if (pt->members[i].type == TOKEN_WORD)
2015           {
2016             *(((WORD*)(buf->cur_pdata))) = (WORD)(*(DWORD*)buf->value);
2017             buf->cur_pdata += 2;
2018           }
2019           else if (pt->members[i].type == TOKEN_DWORD)
2020           {
2021             *(((DWORD*)(buf->cur_pdata))) = (DWORD)(*(DWORD*)buf->value);
2022             buf->cur_pdata += 4;
2023           }
2024           else
2025           {
2026             FIXME("Token %d not supported\n", pt->members[i].type);
2027             return FALSE;
2028           }
2029         }
2030         else if (token == TOKEN_FLOAT)
2031         {
2032           get_TOKEN(buf);
2033           TRACE("%s = %f\n", pt->members[i].name, *(float*)buf->value);
2034           /* Assume larger size */
2035           if ((buf->cur_pdata - buf->pdata + 4) > MAX_DATA_SIZE)
2036           {
2037             FIXME("Buffer too small\n");
2038             return FALSE;
2039           }
2040           if (pt->members[i].type == TOKEN_FLOAT)
2041           {
2042             *(((float*)(buf->cur_pdata))) = (float)(*(float*)buf->value);
2043             buf->cur_pdata += 4;
2044           }
2045           else
2046           {
2047             FIXME("Token %d not supported\n", pt->members[i].type);
2048             return FALSE;
2049           }
2050         }
2051         else if (token == TOKEN_LPSTR)
2052         {
2053           get_TOKEN(buf);
2054           TRACE("%s = %s\n", pt->members[i].name, (char*)buf->value);
2055           /* Assume larger size */
2056           if ((buf->cur_pdata - buf->pdata + 4) > MAX_DATA_SIZE)
2057           {
2058             FIXME("Buffer too small\n");
2059             return FALSE;
2060           }
2061           if (pt->members[i].type == TOKEN_LPSTR)
2062           {
2063             int len = strlen((char*)buf->value) + 1;
2064             if ((buf->cur_pstrings - buf->pstrings + len) > MAX_STRINGS_BUFFER)
2065             {
2066               FIXME("Buffer too small %p %p %d\n", buf->cur_pstrings, buf->pstrings, len);
2067               return FALSE;
2068             }
2069             strcpy((char*)buf->cur_pstrings, (char*)buf->value);
2070             *(((LPCSTR*)(buf->cur_pdata))) = (char*)buf->cur_pstrings;
2071             buf->cur_pstrings += len;
2072             buf->cur_pdata += 4;
2073           }
2074           else
2075           {
2076             FIXME("Token %d not supported\n", pt->members[i].type);
2077             return FALSE;
2078           }
2079         }
2080         else
2081         {
2082           FIXME("Unexpected token %d\n", token);
2083           return FALSE;
2084         }
2085       }
2086     }
2087
2088     if (buf->txt && (check_TOKEN(buf) != TOKEN_CBRACE))
2089     {
2090       token = get_TOKEN(buf);
2091       if ((token != TOKEN_SEMICOLON) && (token != TOKEN_COMMA))
2092       {
2093         /* Allow comma instead of semicolon in some specific cases */
2094         if (!((token == TOKEN_COMMA) && ((i+1) < pt->nb_members) && (pt->members[i].type == pt->members[i+1].type)
2095           && (!pt->members[i].nb_dims) && (!pt->members[i+1].nb_dims)))
2096           return FALSE;
2097       }
2098     }
2099   }
2100
2101   return TRUE;
2102 }
2103
2104 static BOOL parse_object_parts(parse_buffer * buf, BOOL allow_optional)
2105 {
2106   if (!parse_object_members_list(buf))
2107     return FALSE;
2108
2109   if (allow_optional)
2110   {
2111     buf->pxo->size = buf->cur_pdata - buf->pxo->pdata;
2112
2113     /* Skip trailing semicolon */
2114     while (check_TOKEN(buf) == TOKEN_SEMICOLON)
2115       get_TOKEN(buf);
2116
2117     while (1)
2118     {
2119       if (check_TOKEN(buf) == TOKEN_OBRACE)
2120       {
2121         int i, j;
2122         get_TOKEN(buf);
2123         if (get_TOKEN(buf) != TOKEN_NAME)
2124           return FALSE;
2125         if (get_TOKEN(buf) != TOKEN_CBRACE)
2126           return FALSE;
2127         TRACE("Found optional reference %s\n", (char*)buf->value);
2128         for (i = 0; i < buf->nb_pxo_globals; i++)
2129         {
2130           for (j = 0; j < (buf->pxo_globals[i])[0].nb_subobjects; j++)
2131           {
2132             if (!strcmp((buf->pxo_globals[i])[j].name, (char*)buf->value))
2133               goto _exit;
2134           }
2135         }
2136 _exit:
2137         if (i == buf->nb_pxo_globals)
2138         {
2139           ERR("Reference to unknown object %s\n", (char*)buf->value);
2140           return FALSE;
2141         }
2142         buf->pxo->childs[buf->pxo->nb_childs] = &buf->pxo_tab[buf->cur_subobject++];
2143         buf->pxo->childs[buf->pxo->nb_childs]->ptarget = &(buf->pxo_globals[i])[j];
2144         buf->pxo->nb_childs++;
2145       }
2146       else if (check_TOKEN(buf) == TOKEN_NAME)
2147       {
2148         xobject* pxo = buf->pxo;
2149         buf->pxo = buf->pxo->childs[buf->pxo->nb_childs] = &buf->pxo_tab[buf->cur_subobject++];
2150
2151         TRACE("Enter optional %s\n", (char*)buf->value);
2152         buf->level++;
2153         if (!parse_object(buf))
2154         {
2155           buf->level--;
2156           return FALSE;
2157         }
2158         buf->level--;
2159         buf->pxo = pxo;
2160         buf->pxo->nb_childs++;
2161       }
2162       else
2163         break;
2164     }
2165   }
2166
2167   if (buf->pxo->nb_childs > MAX_CHILDS)
2168   {
2169     FIXME("Too many childs %d\n", buf->pxo->nb_childs);
2170     return FALSE;
2171   }
2172
2173   return TRUE;
2174 }
2175
2176 static BOOL parse_object(parse_buffer * buf)
2177 {
2178   int i;
2179
2180   buf->pxo->pdata = buf->cur_pdata;
2181   buf->pxo->ptarget = NULL;
2182
2183   if (get_TOKEN(buf) != TOKEN_NAME)
2184     return FALSE;
2185
2186   /* To do template lookup */
2187   for (i = 0; i < buf->pdxf->nb_xtemplates; i++)
2188   {
2189     if (!strcasecmp((char*)buf->value, buf->pdxf->xtemplates[i].name))
2190     {
2191       buf->pxt[buf->level] = &buf->pdxf->xtemplates[i];
2192       memcpy(&buf->pxo->type, &buf->pdxf->xtemplates[i].class_id, 16);
2193       break;
2194     }
2195   }
2196   if (i == buf->pdxf->nb_xtemplates)
2197   {
2198     ERR("Unknown template %s\n", (char*)buf->value);
2199     return FALSE;
2200   }
2201
2202   if (check_TOKEN(buf) == TOKEN_NAME)
2203   {
2204     get_TOKEN(buf);
2205     strcpy(buf->pxo->name, (char*)buf->value);
2206   }
2207   else
2208     buf->pxo->name[0] = 0;
2209
2210   if (get_TOKEN(buf) != TOKEN_OBRACE)
2211     return FALSE;
2212   if (check_TOKEN(buf) == TOKEN_GUID)
2213   {
2214     get_TOKEN(buf);
2215     memcpy(&buf->pxo->class_id, buf->value, 16);
2216   }
2217   else
2218     memset(&buf->pxo->class_id, 0, 16);
2219
2220   if (!parse_object_parts(buf, TRUE))
2221     return FALSE;
2222   if (get_TOKEN(buf) != TOKEN_CBRACE)
2223     return FALSE;
2224
2225   if (buf->txt)
2226   {
2227     /* Go to the next object */
2228     go_to_next_definition(buf);
2229   }
2230
2231   return TRUE;
2232 }
2233
2234 /*** IDirectXFileEnumObject methods ***/
2235 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetNextDataObject(IDirectXFileEnumObject* iface, LPDIRECTXFILEDATA* ppDataObj)
2236 {
2237   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
2238   IDirectXFileDataImpl* object;
2239   HRESULT hr;
2240   LPBYTE pdata = NULL;
2241   LPBYTE pstrings = NULL;
2242
2243   TRACE("(%p/%p)->(%p)\n", This, iface, ppDataObj);
2244
2245   if (This->nb_xobjects >= MAX_OBJECTS)
2246   {
2247     ERR("Too many objects\n");
2248     return DXFILEERR_NOMOREOBJECTS;
2249   }
2250
2251   if (!This->buf.rem_bytes)
2252     return DXFILEERR_NOMOREOBJECTS;
2253
2254   hr = IDirectXFileDataImpl_Create(&object);
2255   if (FAILED(hr))
2256     return hr;
2257
2258   This->buf.pxo_globals = This->xobjects;
2259   This->buf.nb_pxo_globals = This->nb_xobjects;
2260   This->buf.cur_subobject = 1;
2261   This->buf.level = 0;
2262
2263   This->buf.pxo_tab = HeapAlloc(GetProcessHeap(), 0, sizeof(xobject)*MAX_SUBOBJECTS);
2264   if (!This->buf.pxo_tab)
2265   {
2266     ERR("Out of memory\n");
2267     hr = DXFILEERR_BADALLOC;
2268     goto error;
2269   }
2270   This->buf.pxo = This->xobjects[This->nb_xobjects] = This->buf.pxo_tab;
2271
2272   pdata = HeapAlloc(GetProcessHeap(), 0, MAX_DATA_SIZE);
2273   if (!pdata)
2274   {
2275     ERR("Out of memory\n");
2276     hr = DXFILEERR_BADALLOC;
2277     goto error;
2278   }
2279   This->buf.cur_pdata = This->buf.pdata = object->pdata = pdata;
2280
2281   pstrings = HeapAlloc(GetProcessHeap(), 0, MAX_STRINGS_BUFFER);
2282   if (!pstrings)
2283   {
2284     ERR("Out of memory\n");
2285     hr = DXFILEERR_BADALLOC;
2286     goto error;
2287   }
2288   This->buf.cur_pstrings = This->buf.pstrings = object->pstrings = pstrings;
2289
2290   if (!parse_object(&This->buf))
2291   {
2292     TRACE("Object is not correct\n");
2293     hr = DXFILEERR_PARSEERROR;
2294     goto error;
2295   }
2296
2297   This->buf.pxo->nb_subobjects = This->buf.cur_subobject;
2298   if (This->buf.cur_subobject > MAX_SUBOBJECTS)
2299   {
2300     FIXME("Too many suobjects %d\n", This->buf.cur_subobject);
2301     hr = DXFILEERR_BADALLOC;
2302     goto error;
2303   }
2304
2305   object->pstrings = pstrings;
2306   object->pobj = This->buf.pxo;
2307   object->cur_enum_object = 0;
2308   object->level = 0;
2309   object->from_ref = FALSE;
2310
2311   *ppDataObj = (LPDIRECTXFILEDATA)object;
2312
2313   /* Get a reference to created object */
2314   This->pRefObjects[This->nb_xobjects] = (LPDIRECTXFILEDATA)object;
2315   IDirectXFileData_AddRef(This->pRefObjects[This->nb_xobjects]);
2316
2317   This->nb_xobjects++;
2318
2319   return DXFILE_OK;
2320
2321 error:
2322
2323   HeapFree(GetProcessHeap(), 0, This->buf.pxo_tab);
2324   HeapFree(GetProcessHeap(), 0, pdata);
2325   HeapFree(GetProcessHeap(), 0, pstrings);
2326
2327   return hr;
2328 }
2329
2330 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetDataObjectById(IDirectXFileEnumObject* iface, REFGUID rguid, LPDIRECTXFILEDATA* ppDataObj)
2331 {
2332   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
2333
2334   FIXME("(%p/%p)->(%p,%p) stub!\n", This, iface, rguid, ppDataObj);
2335
2336   return DXFILEERR_BADVALUE;
2337 }
2338
2339 static HRESULT WINAPI IDirectXFileEnumObjectImpl_GetDataObjectByName(IDirectXFileEnumObject* iface, LPCSTR szName, LPDIRECTXFILEDATA* ppDataObj)
2340 {
2341   IDirectXFileEnumObjectImpl *This = (IDirectXFileEnumObjectImpl *)iface;
2342
2343   FIXME("(%p/%p)->(%s,%p) stub!\n", This, iface, szName, ppDataObj);
2344
2345   return DXFILEERR_BADVALUE;
2346 }
2347
2348 static const IDirectXFileEnumObjectVtbl IDirectXFileEnumObject_Vtbl =
2349 {
2350     IDirectXFileEnumObjectImpl_QueryInterface,
2351     IDirectXFileEnumObjectImpl_AddRef,
2352     IDirectXFileEnumObjectImpl_Release,
2353     IDirectXFileEnumObjectImpl_GetNextDataObject,
2354     IDirectXFileEnumObjectImpl_GetDataObjectById,
2355     IDirectXFileEnumObjectImpl_GetDataObjectByName
2356 };
2357
2358 static HRESULT IDirectXFileSaveObjectImpl_Create(IDirectXFileSaveObjectImpl** ppObj)
2359 {
2360     IDirectXFileSaveObjectImpl* object;
2361
2362     TRACE("(%p)\n", ppObj);
2363
2364     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectXFileSaveObjectImpl));
2365     if (!object)
2366     {
2367         ERR("Out of memory\n");
2368         return DXFILEERR_BADALLOC;
2369     }
2370
2371     object->lpVtbl.lpVtbl = &IDirectXFileSaveObject_Vtbl;
2372     object->ref = 1;
2373
2374     *ppObj = object;
2375
2376     return S_OK;
2377 }
2378
2379 /*** IUnknown methods ***/
2380 static HRESULT WINAPI IDirectXFileSaveObjectImpl_QueryInterface(IDirectXFileSaveObject* iface, REFIID riid, void** ppvObject)
2381 {
2382   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
2383
2384   TRACE("(%p/%p)->(%s,%p)\n", iface, This, debugstr_guid(riid), ppvObject);
2385
2386   if (IsEqualGUID(riid, &IID_IUnknown)
2387       || IsEqualGUID(riid, &IID_IDirectXFileSaveObject))
2388   {
2389     IClassFactory_AddRef(iface);
2390     *ppvObject = This;
2391     return S_OK;
2392   }
2393
2394   ERR("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppvObject);
2395   return E_NOINTERFACE;
2396 }
2397
2398 static ULONG WINAPI IDirectXFileSaveObjectImpl_AddRef(IDirectXFileSaveObject* iface)
2399 {
2400   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
2401   ULONG ref = InterlockedIncrement(&This->ref);
2402
2403   TRACE("(%p/%p): AddRef from %d\n", iface, This, ref - 1);
2404
2405   return ref;
2406 }
2407
2408 static ULONG WINAPI IDirectXFileSaveObjectImpl_Release(IDirectXFileSaveObject* iface)
2409 {
2410   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
2411   ULONG ref = InterlockedDecrement(&This->ref);
2412
2413   TRACE("(%p/%p): ReleaseRef to %d\n", iface, This, ref);
2414
2415   if (!ref)
2416     HeapFree(GetProcessHeap(), 0, This);
2417
2418   return ref;
2419 }
2420
2421 static HRESULT WINAPI IDirectXFileSaveObjectImpl_SaveTemplates(IDirectXFileSaveObject* iface, DWORD cTemplates, const GUID** ppguidTemplates)
2422 {
2423   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
2424
2425   FIXME("(%p/%p)->(%d,%p) stub!\n", This, iface, cTemplates, ppguidTemplates);
2426
2427   return DXFILEERR_BADVALUE;
2428 }
2429
2430 static HRESULT WINAPI IDirectXFileSaveObjectImpl_CreateDataObject(IDirectXFileSaveObject* iface, REFGUID rguidTemplate, LPCSTR szName, const GUID* pguid, DWORD cbSize, LPVOID pvData, LPDIRECTXFILEDATA* ppDataObj)
2431 {
2432   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
2433
2434   FIXME("(%p/%p)->(%p,%s,%p,%d,%p,%p) stub!\n", This, iface, rguidTemplate, szName, pguid, cbSize, pvData, ppDataObj);
2435
2436   return DXFILEERR_BADVALUE;
2437 }
2438
2439 static HRESULT WINAPI IDirectXFileSaveObjectImpl_SaveData(IDirectXFileSaveObject* iface, LPDIRECTXFILEDATA ppDataObj)
2440 {
2441   IDirectXFileSaveObjectImpl *This = (IDirectXFileSaveObjectImpl *)iface;
2442
2443   FIXME("(%p/%p)->(%p) stub!\n", This, iface, ppDataObj);
2444
2445   return DXFILEERR_BADVALUE;
2446 }
2447
2448 static const IDirectXFileSaveObjectVtbl IDirectXFileSaveObject_Vtbl =
2449 {
2450     IDirectXFileSaveObjectImpl_QueryInterface,
2451     IDirectXFileSaveObjectImpl_AddRef,
2452     IDirectXFileSaveObjectImpl_Release,
2453     IDirectXFileSaveObjectImpl_SaveTemplates,
2454     IDirectXFileSaveObjectImpl_CreateDataObject,
2455     IDirectXFileSaveObjectImpl_SaveData
2456 };