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