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