dlls/d3dxof/parsing.c

   1 /*
   2  * X Files parsing
   3  *
   4  * Copyright 2008 Christian Costa
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/debug.h"
  23
  24 #define COBJMACROS
  25
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28
  29 #include "d3dxof_private.h"
  30 #include "dxfile.h"
  31
  32 #include <stdio.h>
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(d3dxof_parsing);
  35
  36 #define MAKEFOUR(a,b,c,d) ((DWORD)a + ((DWORD)b << 8) + ((DWORD)c << 16) + ((DWORD)d << 24))
  37 #define XOFFILE_FORMAT_MAGIC         MAKEFOUR('x','o','f',' ')
  38 #define XOFFILE_FORMAT_VERSION_302   MAKEFOUR('0','3','0','2')
  39 #define XOFFILE_FORMAT_VERSION_303   MAKEFOUR('0','3','0','3')
  40 #define XOFFILE_FORMAT_BINARY        MAKEFOUR('b','i','n',' ')
  41 #define XOFFILE_FORMAT_TEXT          MAKEFOUR('t','x','t',' ')
  42 #define XOFFILE_FORMAT_BINARY_MSZIP  MAKEFOUR('b','z','i','p')
  43 #define XOFFILE_FORMAT_TEXT_MSZIP    MAKEFOUR('t','z','i','p')
  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_ERROR   0xffff
  49 #define TOKEN_NONE         0
  50 #define TOKEN_NAME         1
  51 #define TOKEN_STRING       2
  52 #define TOKEN_INTEGER      3
  53 #define TOKEN_GUID         5
  54 #define TOKEN_INTEGER_LIST 6
  55 #define TOKEN_FLOAT_LIST   7
  56 #define TOKEN_OBRACE      10
  57 #define TOKEN_CBRACE      11
  58 #define TOKEN_OPAREN      12
  59 #define TOKEN_CPAREN      13
  60 #define TOKEN_OBRACKET    14
  61 #define TOKEN_CBRACKET    15
  62 #define TOKEN_OANGLE      16
  63 #define TOKEN_CANGLE      17
  64 #define TOKEN_DOT         18
  65 #define TOKEN_COMMA       19
  66 #define TOKEN_SEMICOLON   20
  67 #define TOKEN_TEMPLATE    31
  68 #define TOKEN_WORD        40
  69 #define TOKEN_DWORD       41
  70 #define TOKEN_FLOAT       42
  71 #define TOKEN_DOUBLE      43
  72 #define TOKEN_CHAR        44
  73 #define TOKEN_UCHAR       45
  74 #define TOKEN_SWORD       46
  75 #define TOKEN_SDWORD      47
  76 #define TOKEN_VOID        48
  77 #define TOKEN_LPSTR       49
  78 #define TOKEN_UNICODE     50
  79 #define TOKEN_CSTRING     51
  80 #define TOKEN_ARRAY       52
  81
  82 #define CLSIDFMT "<%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X>"
  83
  84 /* FOURCC to string conversion for debug messages */
  85 static const char *debugstr_fourcc(DWORD fourcc)
  86 {
  87     if (!fourcc) return "'null'";
  88     return wine_dbg_sprintf ("\'%c%c%c%c\'",
  89         (char)(fourcc), (char)(fourcc >> 8),
  90         (char)(fourcc >> 16), (char)(fourcc >> 24));
  91 }
  92
  93 static const char* get_primitive_string(WORD token)
  94 {
  95   switch(token)
  96   {
  97     case TOKEN_WORD:
  98       return "WORD";
  99     case TOKEN_DWORD:
 100       return "DWORD";
 101     case TOKEN_FLOAT:
 102       return "FLOAT";
 103     case TOKEN_DOUBLE:
 104       return "DOUBLE";
 105     case TOKEN_CHAR:
 106       return "CHAR";
 107     case TOKEN_UCHAR:
 108       return "UCHAR";
 109     case TOKEN_SWORD:
 110       return "SWORD";
 111     case TOKEN_SDWORD:
 112       return "SDWORD";
 113     case TOKEN_VOID:
 114       return "VOID";
 115     case TOKEN_LPSTR:
 116       return "STRING";
 117     case TOKEN_UNICODE:
 118       return "UNICODE";
 119     case TOKEN_CSTRING:
 120       return "CSTRING ";
 121     default:
 122       break;
 123   }
 124   return NULL;
 125 }
 126
 127 static void dump_template(xtemplate* templates_array, xtemplate* ptemplate)
 128 {
 129   ULONG j, k;
 130   GUID* clsid;
 131
 132   clsid = &ptemplate->class_id;
 133
 134   DPRINTF("template %s\n", ptemplate->name);
 135   DPRINTF("{\n");
 136   DPRINTF(CLSIDFMT "\n", clsid->Data1, clsid->Data2, clsid->Data3, clsid->Data4[0],
 137   clsid->Data4[1], clsid->Data4[2], clsid->Data4[3], clsid->Data4[4], clsid->Data4[5], clsid->Data4[6], clsid->Data4[7]);
 138   for (j = 0; j < ptemplate->nb_members; j++)
 139   {
 140     if (ptemplate->members[j].nb_dims)
 141       DPRINTF("array ");
 142     if (ptemplate->members[j].type == TOKEN_NAME)
 143       DPRINTF("%s ", templates_array[ptemplate->members[j].idx_template].name);
 144     else
 145       DPRINTF("%s ", get_primitive_string(ptemplate->members[j].type));
 146     DPRINTF("%s", ptemplate->members[j].name);
 147     for (k = 0; k < ptemplate->members[j].nb_dims; k++)
 148     {
 149       if (ptemplate->members[j].dim_fixed[k])
 150         DPRINTF("[%d]", ptemplate->members[j].dim_value[k]);
 151       else
 152         DPRINTF("[%s]", ptemplate->members[ptemplate->members[j].dim_value[k]].name);
 153     }
 154     DPRINTF(";\n");
 155   }
 156   if (ptemplate->open)
 157     DPRINTF("[...]\n");
 158   else if (ptemplate->nb_children)
 159   {
 160     DPRINTF("[%s", ptemplate->children[0]);
 161     for (j = 1; j < ptemplate->nb_children; j++)
 162       DPRINTF(",%s", ptemplate->children[j]);
 163     DPRINTF("]\n");
 164   }
 165   DPRINTF("}\n");
 166 }
 167
 168 static BOOL read_bytes(parse_buffer * buf, LPVOID data, DWORD size)
 169 {
 170   if (buf->rem_bytes < size)
 171     return FALSE;
 172   memcpy(data, buf->buffer, size);
 173   buf->buffer += size;
 174   buf->rem_bytes -= size;
 175   return TRUE;
 176 }
 177
 178 static void rewind_bytes(parse_buffer * buf, DWORD size)
 179 {
 180   buf->buffer -= size;
 181   buf->rem_bytes += size;
 182 }
 183
 184 HRESULT parse_header(parse_buffer * buf, BYTE ** decomp_buffer_ptr)
 185 {
 186   /* X File common header:
 187    *  0-3  -> Magic Number (format identifier)
 188    *  4-7  -> Format Version
 189    *  8-11 -> Format Type (text or binary, decompressed or compressed)
 190    * 12-15 -> Float Size (32 or 64 bits) */
 191   DWORD header[4];
 192
 193   if (!read_bytes(buf, header, sizeof(header)))
 194     return DXFILEERR_BADFILETYPE;
 195
 196   if (TRACE_ON(d3dxof_parsing))
 197   {
 198     char string[17];
 199     memcpy(string, header, 16);
 200     string[16] = 0;
 201     TRACE("header = '%s'\n", string);
 202   }
 203
 204   if (header[0] != XOFFILE_FORMAT_MAGIC)
 205     return DXFILEERR_BADFILETYPE;
 206
 207   if (header[1] != XOFFILE_FORMAT_VERSION_302 && header[1] != XOFFILE_FORMAT_VERSION_303)
 208     return DXFILEERR_BADFILEVERSION;
 209
 210   if (header[2] != XOFFILE_FORMAT_BINARY && header[2] != XOFFILE_FORMAT_TEXT &&
 211       header[2] != XOFFILE_FORMAT_BINARY_MSZIP && header[2] != XOFFILE_FORMAT_TEXT_MSZIP)
 212   {
 213     WARN("File type %s unknown\n", debugstr_fourcc(header[2]));
 214     return DXFILEERR_BADFILETYPE;
 215   }
 216
 217   if (header[3] != XOFFILE_FORMAT_FLOAT_BITS_32 && header[3] != XOFFILE_FORMAT_FLOAT_BITS_64)
 218     return DXFILEERR_BADFILEFLOATSIZE;
 219
 220   buf->txt = header[2] == XOFFILE_FORMAT_TEXT || header[2] == XOFFILE_FORMAT_TEXT_MSZIP;
 221
 222   if (header[2] == XOFFILE_FORMAT_BINARY_MSZIP || header[2] == XOFFILE_FORMAT_TEXT_MSZIP)
 223   {
 224     /* Extended header for compressed data:
 225      * 16-19 -> size of decompressed file including xof header,
 226      * 20-21 -> size of first decompressed MSZIP chunk, 22-23 -> size of first compressed MSZIP chunk
 227      * 24-xx -> compressed MSZIP data chunk
 228      * xx-xx -> size of next decompressed MSZIP chunk, xx-xx -> size of next compressed MSZIP chunk
 229      * xx-xx -> compressed MSZIP data chunk
 230      * .............................................................................................. */
 231     int err;
 232     DWORD decomp_file_size;
 233     WORD decomp_chunk_size;
 234     WORD comp_chunk_size;
 235     LPBYTE decomp_buffer;
 236
 237     if (!read_bytes(buf, &decomp_file_size, sizeof(decomp_file_size)))
 238       return DXFILEERR_BADFILETYPE;
 239
 240     TRACE("Compressed format %s detected: decompressed file size with xof header = %d\n",
 241           debugstr_fourcc(header[2]), decomp_file_size);
 242
 243     /* Does not take xof header into account */
 244     decomp_file_size -= 16;
 245
 246     decomp_buffer = HeapAlloc(GetProcessHeap(), 0, decomp_file_size);
 247     if (!decomp_buffer)
 248     {
 249         ERR("Out of memory\n");
 250         return DXFILEERR_BADALLOC;
 251     }
 252     *decomp_buffer_ptr = decomp_buffer;
 253
 254     while (buf->rem_bytes)
 255     {
 256       if (!read_bytes(buf, &decomp_chunk_size, sizeof(decomp_chunk_size)))
 257         return DXFILEERR_BADFILETYPE;
 258       if (!read_bytes(buf, &comp_chunk_size, sizeof(comp_chunk_size)))
 259         return DXFILEERR_BADFILETYPE;
 260
 261       TRACE("Process chunk: compressed_size = %d, decompressed_size = %d\n",
 262             comp_chunk_size, decomp_chunk_size);
 263
 264       err = mszip_decompress(comp_chunk_size, decomp_chunk_size, (char*)buf->buffer, (char*)decomp_buffer);
 265       if (err)
 266       {
 267         WARN("Error while decompressing MSZIP chunk %d\n", err);
 268         HeapFree(GetProcessHeap(), 0, decomp_buffer);
 269         return DXFILEERR_BADALLOC;
 270       }
 271       buf->rem_bytes -= comp_chunk_size;
 272       buf->buffer += comp_chunk_size;
 273       decomp_buffer += decomp_chunk_size;
 274     }
 275
 276     if ((decomp_buffer - *decomp_buffer_ptr) != decomp_file_size)
 277       ERR("Size of all decompressed chunks (%u) does not match decompressed file size (%u)\n",
 278           (DWORD)(decomp_buffer - *decomp_buffer_ptr), decomp_file_size);
 279
 280     /* Use decompressed data */
 281     buf->buffer = *decomp_buffer_ptr;
 282     buf->rem_bytes = decomp_file_size;
 283   }
 284
 285   TRACE("Header is correct\n");
 286
 287   return S_OK;
 288 }
 289
 290 static void dump_TOKEN(WORD token)
 291 {
 292 #define DUMP_TOKEN(t) case t: TRACE(#t "\n"); break
 293   switch(token)
 294   {
 295     DUMP_TOKEN(TOKEN_NAME);
 296     DUMP_TOKEN(TOKEN_STRING);
 297     DUMP_TOKEN(TOKEN_INTEGER);
 298     DUMP_TOKEN(TOKEN_GUID);
 299     DUMP_TOKEN(TOKEN_INTEGER_LIST);
 300     DUMP_TOKEN(TOKEN_FLOAT_LIST);
 301     DUMP_TOKEN(TOKEN_OBRACE);
 302     DUMP_TOKEN(TOKEN_CBRACE);
 303     DUMP_TOKEN(TOKEN_OPAREN);
 304     DUMP_TOKEN(TOKEN_CPAREN);
 305     DUMP_TOKEN(TOKEN_OBRACKET);
 306     DUMP_TOKEN(TOKEN_CBRACKET);
 307     DUMP_TOKEN(TOKEN_OANGLE);
 308     DUMP_TOKEN(TOKEN_CANGLE);
 309     DUMP_TOKEN(TOKEN_DOT);
 310     DUMP_TOKEN(TOKEN_COMMA);
 311     DUMP_TOKEN(TOKEN_SEMICOLON);
 312     DUMP_TOKEN(TOKEN_TEMPLATE);
 313     DUMP_TOKEN(TOKEN_WORD);
 314     DUMP_TOKEN(TOKEN_DWORD);
 315     DUMP_TOKEN(TOKEN_FLOAT);
 316     DUMP_TOKEN(TOKEN_DOUBLE);
 317     DUMP_TOKEN(TOKEN_CHAR);
 318     DUMP_TOKEN(TOKEN_UCHAR);
 319     DUMP_TOKEN(TOKEN_SWORD);
 320     DUMP_TOKEN(TOKEN_SDWORD);
 321     DUMP_TOKEN(TOKEN_VOID);
 322     DUMP_TOKEN(TOKEN_LPSTR);
 323     DUMP_TOKEN(TOKEN_UNICODE);
 324     DUMP_TOKEN(TOKEN_CSTRING);
 325     DUMP_TOKEN(TOKEN_ARRAY);
 326     default:
 327       if (0)
 328         TRACE("Unknown token %d\n", token);
 329       break;
 330   }
 331 #undef DUMP_TOKEN
 332 }
 333
 334 static BOOL is_space(char c)
 335 {
 336   switch (c)
 337   {
 338     case 0x00:
 339     case 0x0D:
 340     case 0x0A:
 341     case ' ':
 342     case '\t':
 343       return TRUE;
 344   }
 345   return FALSE;
 346 }
 347
 348 static BOOL is_operator(char c)
 349 {
 350   switch(c)
 351   {
 352     case '{':
 353     case '}':
 354     case '[':
 355     case ']':
 356     case '(':
 357     case ')':
 358     case '<':
 359     case '>':
 360     case ',':
 361     case ';':
 362       return TRUE;
 363   }
 364   return FALSE;
 365 }
 366
 367 static inline BOOL is_separator(char c)
 368 {
 369   return is_space(c) || is_operator(c);
 370 }
 371
 372 static WORD get_operator_token(char c)
 373 {
 374   switch(c)
 375   {
 376     case '{':
 377       return TOKEN_OBRACE;
 378     case '}':
 379       return TOKEN_CBRACE;
 380     case '[':
 381       return TOKEN_OBRACKET;
 382     case ']':
 383       return TOKEN_CBRACKET;
 384     case '(':
 385       return TOKEN_OPAREN;
 386     case ')':
 387       return TOKEN_CPAREN;
 388     case '<':
 389       return TOKEN_OANGLE;
 390     case '>':
 391       return TOKEN_CANGLE;
 392     case ',':
 393       return TOKEN_COMMA;
 394     case ';':
 395       return TOKEN_SEMICOLON;
 396   }
 397   return 0;
 398 }
 399
 400 static BOOL is_keyword(parse_buffer* buf, const char* keyword)
 401 {
 402   char tmp[8]; /* longest keyword size (template) */
 403   DWORD len = strlen(keyword);
 404
 405   if (!read_bytes(buf, tmp, len))
 406     return FALSE;
 407   if (strncasecmp(tmp, keyword, len))
 408   {
 409     rewind_bytes(buf, len);
 410     return FALSE;
 411   }
 412
 413   if (!read_bytes(buf, tmp, 1))
 414     return TRUE;
 415   if (is_separator(tmp[0]))
 416   {
 417     rewind_bytes(buf, 1);
 418     return TRUE;
 419   }
 420   rewind_bytes(buf, len+1);
 421   return FALSE;
 422 }
 423
 424 static WORD get_keyword_token(parse_buffer* buf)
 425 {
 426   if (is_keyword(buf, "template"))
 427     return TOKEN_TEMPLATE;
 428   if (is_keyword(buf, "WORD"))
 429     return TOKEN_WORD;
 430   if (is_keyword(buf, "DWORD"))
 431     return TOKEN_DWORD;
 432   if (is_keyword(buf, "FLOAT"))
 433     return TOKEN_FLOAT;
 434   if (is_keyword(buf, "DOUBLE"))
 435     return TOKEN_DOUBLE;
 436   if (is_keyword(buf, "CHAR"))
 437     return TOKEN_CHAR;
 438   if (is_keyword(buf, "UCHAR"))
 439     return TOKEN_UCHAR;
 440   if (is_keyword(buf, "SWORD"))
 441     return TOKEN_SWORD;
 442   if (is_keyword(buf, "SDWORD"))
 443     return TOKEN_SDWORD;
 444   if (is_keyword(buf, "VOID"))
 445     return TOKEN_VOID;
 446   if (is_keyword(buf, "STRING"))
 447     return TOKEN_LPSTR;
 448   if (is_keyword(buf, "UNICODE"))
 449     return TOKEN_UNICODE;
 450   if (is_keyword(buf, "CSTRING"))
 451     return TOKEN_CSTRING;
 452   if (is_keyword(buf, "array"))
 453     return TOKEN_ARRAY;
 454
 455   return 0;
 456 }
 457
 458 static BOOL is_guid(parse_buffer* buf)
 459 {
 460   char tmp[50];
 461   DWORD pos = 1;
 462   GUID class_id;
 463   DWORD tab[10];
 464   int ret;
 465
 466   if (buf->rem_bytes < 38 || *buf->buffer != '<')
 467     return FALSE;
 468   tmp[0] = '<';
 469   while (pos < sizeof(tmp) - 2 && *(buf->buffer+pos) != '>')
 470   {
 471     tmp[pos] = *(buf->buffer+pos);
 472     pos++;
 473   }
 474   tmp[pos++] = '>';
 475   tmp[pos] = 0;
 476   if (pos != 38 /* <+36+> */)
 477   {
 478     TRACE("Wrong guid %s (%d)\n", tmp, pos);
 479     return FALSE;
 480   }
 481   buf->buffer += pos;
 482   buf->rem_bytes -= pos;
 483
 484   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);
 485   if (ret != 11)
 486   {
 487     TRACE("Wrong guid %s (%d)\n", tmp, pos);
 488     return FALSE;
 489   }
 490   TRACE("Found guid %s (%d)\n", tmp, pos);
 491
 492   class_id.Data2 = tab[0];
 493   class_id.Data3 = tab[1];
 494   class_id.Data4[0] = tab[2];
 495   class_id.Data4[1] = tab[3];
 496   class_id.Data4[2] = tab[4];
 497   class_id.Data4[3] = tab[5];
 498   class_id.Data4[4] = tab[6];
 499   class_id.Data4[5] = tab[7];
 500   class_id.Data4[6] = tab[8];
 501   class_id.Data4[7] = tab[9];
 502
 503   *(GUID*)buf->value = class_id;
 504
 505   return TRUE;
 506 }
 507
 508 static BOOL is_name(parse_buffer* buf)
 509 {
 510   char tmp[512];
 511   DWORD pos = 0;
 512   char c;
 513   BOOL error = 0;
 514   while (pos < buf->rem_bytes && !is_separator(c = *(buf->buffer+pos)))
 515   {
 516     if (!(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) || ((c >= '0') && (c <= '9')) || (c == '_') || (c == '-')))
 517       error = 1;
 518     if (pos < sizeof(tmp))
 519         tmp[pos] = c;
 520     pos++;
 521   }
 522   tmp[min(pos, sizeof(tmp) - 1)] = 0;
 523
 524   if (error)
 525   {
 526     TRACE("Wrong name %s\n", tmp);
 527     return FALSE;
 528   }
 529
 530   buf->buffer += pos;
 531   buf->rem_bytes -= pos;
 532
 533   TRACE("Found name %s\n", tmp);
 534   strcpy((char*)buf->value, tmp);
 535
 536   return TRUE;
 537 }
 538
 539 static BOOL is_float(parse_buffer* buf)
 540 {
 541   char tmp[512];
 542   DWORD pos = 0;
 543   char c;
 544   float decimal;
 545   BOOL dot = 0;
 546
 547   while (pos < buf->rem_bytes && !is_separator(c = *(buf->buffer+pos)))
 548   {
 549     if (!((!pos && (c == '-')) || ((c >= '0') && (c <= '9')) || (!dot && (c == '.'))))
 550       return FALSE;
 551     if (c == '.')
 552       dot = TRUE;
 553     if (pos < sizeof(tmp))
 554         tmp[pos] = c;
 555     pos++;
 556   }
 557   tmp[min(pos, sizeof(tmp) - 1)] = 0;
 558
 559   buf->buffer += pos;
 560   buf->rem_bytes -= pos;
 561
 562   sscanf(tmp, "%f", &decimal);
 563
 564   TRACE("Found float %s - %f\n", tmp, decimal);
 565
 566   *(float*)buf->value = decimal;
 567
 568   return TRUE;
 569 }
 570
 571 static BOOL is_integer(parse_buffer* buf)
 572 {
 573   char tmp[512];
 574   DWORD pos = 0;
 575   char c;
 576   DWORD integer;
 577
 578   while (pos < buf->rem_bytes && !is_separator(c = *(buf->buffer+pos)))
 579   {
 580     if (!((c >= '0') && (c <= '9')))
 581       return FALSE;
 582     if (pos < sizeof(tmp))
 583         tmp[pos] = c;
 584     pos++;
 585   }
 586   tmp[min(pos, sizeof(tmp) - 1)] = 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 BOOL is_string(parse_buffer* buf)
 601 {
 602   char tmp[512];
 603   DWORD pos = 0;
 604   char c;
 605   BOOL ok = 0;
 606
 607   if (*buf->buffer != '"')
 608     return FALSE;
 609
 610   while ((pos+1) < buf->rem_bytes)
 611   {
 612     c = *(buf->buffer+pos+1);
 613     if (c == '"')
 614     {
 615       ok = 1;
 616       break;
 617     }
 618     if (pos < sizeof(tmp))
 619         tmp[pos] = c;
 620     pos++;
 621   }
 622   tmp[min(pos, sizeof(tmp) - 1)] = 0;
 623
 624   if (!ok)
 625   {
 626     TRACE("Wrong string %s\n", tmp);
 627     return FALSE;
 628   }
 629
 630   buf->buffer += pos + 2;
 631   buf->rem_bytes -= pos + 2;
 632
 633   TRACE("Found string %s\n", tmp);
 634   strcpy((char*)buf->value, tmp);
 635
 636   return TRUE;
 637 }
 638
 639 static WORD parse_TOKEN(parse_buffer * buf)
 640 {
 641   WORD token;
 642
 643   if (buf->txt)
 644   {
 645     while(1)
 646     {
 647       char c;
 648       if (!read_bytes(buf, &c, 1))
 649         return TOKEN_NONE;
 650       /*TRACE("char = '%c'\n", is_space(c) ? ' ' : c);*/
 651       if ((c == '#') || (c == '/'))
 652       {
 653         /* Handle comment (# or //) */
 654         if (c == '/')
 655         {
 656           if (!read_bytes(buf, &c, 1))
 657             return TOKEN_ERROR;
 658           if (c != '/')
 659             return TOKEN_ERROR;
 660         }
 661         c = 0;
 662         while (c != 0x0A)
 663         {
 664           if (!read_bytes(buf, &c, 1))
 665             return TOKEN_NONE;
 666         }
 667         continue;
 668       }
 669       if (is_space(c))
 670         continue;
 671       if (is_operator(c) && (c != '<'))
 672       {
 673         token = get_operator_token(c);
 674         break;
 675       }
 676       else if (c == '.')
 677       {
 678         token = TOKEN_DOT;
 679         break;
 680       }
 681       else
 682       {
 683         rewind_bytes(buf, 1);
 684
 685         if ((token = get_keyword_token(buf)))
 686           break;
 687
 688         if (is_guid(buf))
 689         {
 690           token = TOKEN_GUID;
 691           break;
 692         }
 693         if (is_integer(buf))
 694         {
 695           token = TOKEN_INTEGER;
 696           break;
 697         }
 698         if (is_float(buf))
 699         {
 700           token = TOKEN_FLOAT;
 701           break;
 702         }
 703         if (is_string(buf))
 704         {
 705           token = TOKEN_LPSTR;
 706           break;
 707         }
 708         if (is_name(buf))
 709         {
 710           token = TOKEN_NAME;
 711           break;
 712         }
 713
 714         FIXME("Unrecognize element\n");
 715         return TOKEN_ERROR;
 716       }
 717     }
 718   }
 719   else
 720   {
 721     static int nb_elem;
 722     static int is_float;
 723
 724     if (!nb_elem)
 725     {
 726       if (!read_bytes(buf, &token, 2))
 727         return TOKEN_NONE;
 728
 729       /* Convert integer and float list into separate elements */
 730       if (token == TOKEN_INTEGER_LIST)
 731       {
 732         if (!read_bytes(buf, &nb_elem, 4))
 733           return TOKEN_ERROR;
 734         token = TOKEN_INTEGER;
 735         is_float = FALSE;
 736         TRACE("Integer list (TOKEN_INTEGER_LIST) of size %d\n", nb_elem);
 737       }
 738       else if (token == TOKEN_FLOAT_LIST)
 739       {
 740         if (!read_bytes(buf, &nb_elem, 4))
 741           return TOKEN_ERROR;
 742         token = TOKEN_FLOAT;
 743         is_float = TRUE;
 744         TRACE("Float list (TOKEN_FLOAT_LIST) of size %d\n", nb_elem);
 745       }
 746     }
 747
 748     if (nb_elem)
 749     {
 750       token = is_float ? TOKEN_FLOAT : TOKEN_INTEGER;
 751       nb_elem--;
 752         {
 753           DWORD integer;
 754
 755           if (!read_bytes(buf, &integer, 4))
 756             return TOKEN_ERROR;
 757
 758           *(DWORD*)buf->value = integer;
 759         }
 760       dump_TOKEN(token);
 761       return token;
 762     }
 763
 764     switch (token)
 765     {
 766       case TOKEN_NAME:
 767         {
 768           DWORD count;
 769           char strname[100];
 770
 771           if (!read_bytes(buf, &count, 4))
 772             return TOKEN_ERROR;
 773           if (!read_bytes(buf, strname, count))
 774             return TOKEN_ERROR;
 775           strname[count] = 0;
 776           /*TRACE("name = %s\n", strname);*/
 777
 778           strcpy((char*)buf->value, strname);
 779         }
 780         break;
 781       case TOKEN_INTEGER:
 782         {
 783           DWORD integer;
 784
 785           if (!read_bytes(buf, &integer, 4))
 786             return TOKEN_ERROR;
 787           /*TRACE("integer = %ld\n", integer);*/
 788
 789           *(DWORD*)buf->value = integer;
 790         }
 791         break;
 792       case TOKEN_GUID:
 793         {
 794           char strguid[39];
 795           GUID class_id;
 796
 797           if (!read_bytes(buf, &class_id, 16))
 798             return TOKEN_ERROR;
 799           sprintf(strguid, CLSIDFMT, class_id.Data1, class_id.Data2, class_id.Data3, class_id.Data4[0],
 800             class_id.Data4[1], class_id.Data4[2], class_id.Data4[3], class_id.Data4[4], class_id.Data4[5],
 801             class_id.Data4[6], class_id.Data4[7]);
 802           /*TRACE("guid = {%s}\n", strguid);*/
 803
 804           *(GUID*)buf->value = class_id;
 805         }
 806         break;
 807       case TOKEN_STRING:
 808         {
 809           DWORD count;
 810           WORD tmp_token;
 811           char strname[100];
 812           if (!read_bytes(buf, &count, 4))
 813             return TOKEN_ERROR;
 814           if (!read_bytes(buf, strname, count))
 815             return TOKEN_ERROR;
 816           strname[count] = 0;
 817           if (!read_bytes(buf, &tmp_token, 2))
 818             return TOKEN_ERROR;
 819           if ((tmp_token != TOKEN_COMMA) && (tmp_token != TOKEN_SEMICOLON))
 820             ERR("No comma or semicolon (got %d)\n", tmp_token);
 821           /*TRACE("name = %s\n", strname);*/
 822
 823           strcpy((char*)buf->value, strname);
 824           token = TOKEN_LPSTR;
 825         }
 826         break;
 827       case TOKEN_OBRACE:
 828       case TOKEN_CBRACE:
 829       case TOKEN_OPAREN:
 830       case TOKEN_CPAREN:
 831       case TOKEN_OBRACKET:
 832       case TOKEN_CBRACKET:
 833       case TOKEN_OANGLE:
 834       case TOKEN_CANGLE:
 835       case TOKEN_DOT:
 836       case TOKEN_COMMA:
 837       case TOKEN_SEMICOLON:
 838       case TOKEN_TEMPLATE:
 839       case TOKEN_WORD:
 840       case TOKEN_DWORD:
 841       case TOKEN_FLOAT:
 842       case TOKEN_DOUBLE:
 843       case TOKEN_CHAR:
 844       case TOKEN_UCHAR:
 845       case TOKEN_SWORD:
 846       case TOKEN_SDWORD:
 847       case TOKEN_VOID:
 848       case TOKEN_LPSTR:
 849       case TOKEN_UNICODE:
 850       case TOKEN_CSTRING:
 851       case TOKEN_ARRAY:
 852         break;
 853       default:
 854         return TOKEN_ERROR;
 855     }
 856   }
 857
 858   dump_TOKEN(token);
 859
 860   return token;
 861 }
 862
 863 static WORD get_TOKEN(parse_buffer * buf)
 864 {
 865   if (buf->token_present)
 866   {
 867     buf->token_present = FALSE;
 868     return buf->current_token;
 869   }
 870
 871   buf->current_token = parse_TOKEN(buf);
 872
 873   return buf->current_token;
 874 }
 875
 876 static WORD check_TOKEN(parse_buffer * buf)
 877 {
 878   if (buf->token_present)
 879     return buf->current_token;
 880
 881   buf->current_token = parse_TOKEN(buf);
 882   buf->token_present = TRUE;
 883
 884   return buf->current_token;
 885 }
 886
 887 static inline BOOL is_primitive_type(WORD token)
 888 {
 889   BOOL ret;
 890   switch(token)
 891   {
 892     case TOKEN_WORD:
 893     case TOKEN_DWORD:
 894     case TOKEN_FLOAT:
 895     case TOKEN_DOUBLE:
 896     case TOKEN_CHAR:
 897     case TOKEN_UCHAR:
 898     case TOKEN_SWORD:
 899     case TOKEN_SDWORD:
 900     case TOKEN_LPSTR:
 901     case TOKEN_UNICODE:
 902     case TOKEN_CSTRING:
 903       ret = 1;
 904       break;
 905     default:
 906       ret = 0;
 907       break;
 908   }
 909   return ret;
 910 }
 911
 912 static BOOL parse_template_option_info(parse_buffer * buf)
 913 {
 914   xtemplate* cur_template = &buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates];
 915
 916   if (check_TOKEN(buf) == TOKEN_DOT)
 917   {
 918     get_TOKEN(buf);
 919     if (get_TOKEN(buf) != TOKEN_DOT)
 920       return FALSE;
 921     if (get_TOKEN(buf) != TOKEN_DOT)
 922       return FALSE;
 923     cur_template->open = TRUE;
 924   }
 925   else
 926   {
 927     while (1)
 928     {
 929       if (get_TOKEN(buf) != TOKEN_NAME)
 930         return FALSE;
 931       strcpy(cur_template->children[cur_template->nb_children], (char*)buf->value);
 932       if (check_TOKEN(buf) == TOKEN_GUID)
 933         get_TOKEN(buf);
 934       cur_template->nb_children++;
 935       if (check_TOKEN(buf) != TOKEN_COMMA)
 936         break;
 937       get_TOKEN(buf);
 938     }
 939     cur_template->open = FALSE;
 940   }
 941
 942   return TRUE;
 943 }
 944
 945 static BOOL parse_template_members_list(parse_buffer * buf)
 946 {
 947   int idx_member = 0;
 948   member* cur_member;
 949
 950   while (1)
 951   {
 952     BOOL array = 0;
 953     int nb_dims = 0;
 954     cur_member = &buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].members[idx_member];
 955
 956     if (check_TOKEN(buf) == TOKEN_ARRAY)
 957     {
 958       get_TOKEN(buf);
 959       array = 1;
 960     }
 961
 962     if (check_TOKEN(buf) == TOKEN_NAME)
 963     {
 964       cur_member->type = get_TOKEN(buf);
 965       cur_member->idx_template = 0;
 966       while (cur_member->idx_template < buf->pdxf->nb_xtemplates)
 967       {
 968         if (!strcasecmp((char*)buf->value, buf->pdxf->xtemplates[cur_member->idx_template].name))
 969           break;
 970         cur_member->idx_template++;
 971       }
 972       if (cur_member->idx_template == buf->pdxf->nb_xtemplates)
 973       {
 974         ERR("Reference to a nonexistent template '%s'\n", (char*)buf->value);
 975         return FALSE;
 976       }
 977     }
 978     else if (is_primitive_type(check_TOKEN(buf)))
 979       cur_member->type = get_TOKEN(buf);
 980     else
 981       break;
 982
 983     if (get_TOKEN(buf) != TOKEN_NAME)
 984       return FALSE;
 985     strcpy(cur_member->name, (char*)buf->value);
 986
 987     if (array)
 988     {
 989       while (check_TOKEN(buf) == TOKEN_OBRACKET)
 990       {
 991         if (nb_dims >= MAX_ARRAY_DIM)
 992         {
 993           FIXME("Too many dimensions (%d) for multi-dimensional array\n", nb_dims + 1);
 994           return FALSE;
 995         }
 996         get_TOKEN(buf);
 997         if (check_TOKEN(buf) == TOKEN_INTEGER)
 998         {
 999           get_TOKEN(buf);
1000           cur_member->dim_fixed[nb_dims] = TRUE;
1001           cur_member->dim_value[nb_dims] = *(DWORD*)buf->value;
1002         }
1003         else
1004         {
1005           int i;
1006           if (get_TOKEN(buf) != TOKEN_NAME)
1007             return FALSE;
1008           for (i = 0; i < idx_member; i++)
1009           {
1010             if (!strcmp((char*)buf->value, buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].members[i].name))
1011             {
1012               if (buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].members[i].nb_dims)
1013               {
1014                 ERR("Array cannot be used to specify variable array size\n");
1015                 return FALSE;
1016               }
1017               if (buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].members[i].type != TOKEN_DWORD)
1018               {
1019                 FIXME("Only DWORD supported to specify variable array size\n");
1020                 return FALSE;
1021               }
1022               break;
1023             }
1024           }
1025           if (i == idx_member)
1026           {
1027             ERR("Reference to unknown member %s\n", (char*)buf->value);
1028             return FALSE;
1029           }
1030           cur_member->dim_fixed[nb_dims] = FALSE;
1031           cur_member->dim_value[nb_dims] = i;
1032         }
1033         if (get_TOKEN(buf) != TOKEN_CBRACKET)
1034           return FALSE;
1035         nb_dims++;
1036       }
1037       if (!nb_dims)
1038         return FALSE;
1039       cur_member->nb_dims = nb_dims;
1040     }
1041     if (get_TOKEN(buf) != TOKEN_SEMICOLON)
1042       return FALSE;
1043
1044     idx_member++;
1045   }
1046
1047   buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].nb_members = idx_member;
1048
1049   return TRUE;
1050 }
1051
1052 static BOOL parse_template_parts(parse_buffer * buf)
1053 {
1054   if (!parse_template_members_list(buf))
1055     return FALSE;
1056   if (check_TOKEN(buf) == TOKEN_OBRACKET)
1057   {
1058     get_TOKEN(buf);
1059     if (!parse_template_option_info(buf))
1060       return FALSE;
1061     if (get_TOKEN(buf) != TOKEN_CBRACKET)
1062      return FALSE;
1063   }
1064
1065   return TRUE;
1066 }
1067
1068 static void go_to_next_definition(parse_buffer * buf)
1069 {
1070   char c;
1071   while (buf->rem_bytes)
1072   {
1073     if (!read_bytes(buf, &c, 1))
1074       return;
1075     if ((c == '#') || (c == '/'))
1076     {
1077       /* Handle comment (# or //) */
1078       if (c == '/')
1079       {
1080         if (!read_bytes(buf, &c, 1))
1081           return;
1082         if (c != '/')
1083           return;
1084       }
1085       c = 0;
1086       while (c != 0x0A)
1087       {
1088         if (!read_bytes(buf, &c, 1))
1089           return;
1090       }
1091       continue;
1092     }
1093     else if (!is_space(c))
1094     {
1095       rewind_bytes(buf, 1);
1096       break;
1097     }
1098   }
1099 }
1100
1101 static BOOL parse_template(parse_buffer * buf)
1102 {
1103   if (get_TOKEN(buf) != TOKEN_TEMPLATE)
1104     return FALSE;
1105   if (get_TOKEN(buf) != TOKEN_NAME)
1106     return FALSE;
1107   strcpy(buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].name, (char*)buf->value);
1108   if (get_TOKEN(buf) != TOKEN_OBRACE)
1109     return FALSE;
1110   if (get_TOKEN(buf) != TOKEN_GUID)
1111     return FALSE;
1112   buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates].class_id = *(GUID*)buf->value;
1113   if (!parse_template_parts(buf))
1114     return FALSE;
1115   if (get_TOKEN(buf) != TOKEN_CBRACE)
1116     return FALSE;
1117   if (buf->txt)
1118   {
1119     /* Go to the next template */
1120     go_to_next_definition(buf);
1121   }
1122
1123   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));
1124   buf->pdxf->nb_xtemplates++;
1125
1126   return TRUE;
1127 }
1128
1129 BOOL parse_templates(parse_buffer * buf)
1130 {
1131   while (buf->rem_bytes && (check_TOKEN(buf) == TOKEN_TEMPLATE))
1132   {
1133     if (!parse_template(buf))
1134     {
1135       WARN("Template is not correct\n");
1136       return FALSE;
1137     }
1138     else
1139     {
1140       TRACE("Template successfully parsed:\n");
1141       if (TRACE_ON(d3dxof_parsing))
1142         dump_template(buf->pdxf->xtemplates, &buf->pdxf->xtemplates[buf->pdxf->nb_xtemplates - 1]);
1143     }
1144   }
1145   return TRUE;
1146 }
1147
1148 static BOOL check_buffer(parse_buffer * buf, ULONG size)
1149 {
1150   if ((buf->cur_pos_data + size) > buf->capacity)
1151   {
1152     LPBYTE pdata;
1153     ULONG new_capacity = buf->capacity ? 2 * buf->capacity : 100000;
1154
1155     pdata = HeapAlloc(GetProcessHeap(), 0, new_capacity);
1156     if (!pdata)
1157       return FALSE;
1158     memcpy(pdata, buf->pdata, buf->cur_pos_data);
1159     HeapFree(GetProcessHeap(), 0, buf->pdata);
1160     buf->capacity = new_capacity;
1161     buf->pdata = pdata;
1162     buf->pxo->root->pdata = pdata;
1163   }
1164   return TRUE;
1165 }
1166
1167 static BOOL parse_object_parts(parse_buffer * buf, BOOL allow_optional);
1168 static BOOL parse_object_members_list(parse_buffer * buf)
1169 {
1170   DWORD token;
1171   ULONG i;
1172   xtemplate* pt = buf->pxt[buf->level];
1173
1174   buf->pxo->nb_members = pt->nb_members;
1175
1176   for (i = 0; i < pt->nb_members; i++)
1177   {
1178     ULONG k;
1179     ULONG nb_elems = 1;
1180
1181     buf->pxo->members[i].name = pt->members[i].name;
1182     buf->pxo->members[i].start = buf->cur_pos_data;
1183
1184     for (k = 0; k < pt->members[i].nb_dims; k++)
1185     {
1186       if (pt->members[i].dim_fixed[k])
1187         nb_elems *= pt->members[i].dim_value[k];
1188       else
1189         nb_elems *= *(DWORD*)(buf->pxo->root->pdata + buf->pxo->members[pt->members[i].dim_value[k]].start);
1190     }
1191
1192     TRACE("Elements to consider: %u\n", nb_elems);
1193
1194     for (k = 0; k < nb_elems; k++)
1195     {
1196       if (buf->txt && k)
1197       {
1198         token = check_TOKEN(buf);
1199         if (token == TOKEN_COMMA)
1200         {
1201           get_TOKEN(buf);
1202         }
1203         else
1204         {
1205           /* Allow comma omission */
1206           if (!((token == TOKEN_FLOAT) || (token == TOKEN_INTEGER)))
1207             return FALSE;
1208         }
1209       }
1210
1211       if (pt->members[i].type == TOKEN_NAME)
1212       {
1213         ULONG j;
1214
1215         TRACE("Found sub-object %s\n", buf->pdxf->xtemplates[pt->members[i].idx_template].name);
1216         buf->level++;
1217         /* To do template lookup */
1218         for (j = 0; j < buf->pdxf->nb_xtemplates; j++)
1219         {
1220           if (!strcasecmp(buf->pdxf->xtemplates[pt->members[i].idx_template].name, buf->pdxf->xtemplates[j].name))
1221           {
1222             buf->pxt[buf->level] = &buf->pdxf->xtemplates[j];
1223             break;
1224           }
1225         }
1226         if (j == buf->pdxf->nb_xtemplates)
1227         {
1228           ERR("Unknown template %s\n", (char*)buf->value);
1229           buf->level--;
1230           return FALSE;
1231         }
1232         TRACE("Enter %s\n", buf->pdxf->xtemplates[pt->members[i].idx_template].name);
1233         if (!parse_object_parts(buf, FALSE))
1234         {
1235           buf->level--;
1236           return FALSE;
1237         }
1238         buf->level--;
1239       }
1240       else
1241       {
1242         token = check_TOKEN(buf);
1243         if (token == TOKEN_INTEGER)
1244         {
1245           get_TOKEN(buf);
1246           TRACE("%s = %d\n", pt->members[i].name, *(DWORD*)buf->value);
1247           /* Assume larger size */
1248           if (!check_buffer(buf, 4))
1249             return FALSE;
1250           if (pt->members[i].type == TOKEN_WORD)
1251           {
1252             *(((WORD*)(buf->pdata + buf->cur_pos_data))) = (WORD)(*(DWORD*)buf->value);
1253             buf->cur_pos_data += 2;
1254           }
1255           else if (pt->members[i].type == TOKEN_DWORD)
1256           {
1257             *(((DWORD*)(buf->pdata + buf->cur_pos_data))) = (DWORD)(*(DWORD*)buf->value);
1258             buf->cur_pos_data += 4;
1259           }
1260           else
1261           {
1262             FIXME("Token %d not supported\n", pt->members[i].type);
1263             return FALSE;
1264           }
1265         }
1266         else if (token == TOKEN_FLOAT)
1267         {
1268           get_TOKEN(buf);
1269           TRACE("%s = %f\n", pt->members[i].name, *(float*)buf->value);
1270           if (!check_buffer(buf, 4))
1271             return FALSE;
1272           if (pt->members[i].type == TOKEN_FLOAT)
1273           {
1274             *(((float*)(buf->pdata + buf->cur_pos_data))) = (float)(*(float*)buf->value);
1275             buf->cur_pos_data += 4;
1276           }
1277           else
1278           {
1279             FIXME("Token %d not supported\n", pt->members[i].type);
1280             return FALSE;
1281           }
1282         }
1283         else if (token == TOKEN_LPSTR)
1284         {
1285           get_TOKEN(buf);
1286           TRACE("%s = %s\n", pt->members[i].name, (char*)buf->value);
1287           if (!check_buffer(buf, sizeof(LPSTR)))
1288             return FALSE;
1289           if (pt->members[i].type == TOKEN_LPSTR)
1290           {
1291             int len = strlen((char*)buf->value) + 1;
1292             if ((buf->cur_pstrings - buf->pstrings + len) > MAX_STRINGS_BUFFER)
1293             {
1294               FIXME("Buffer too small %p %p %d\n", buf->cur_pstrings, buf->pstrings, len);
1295               return FALSE;
1296             }
1297             strcpy((char*)buf->cur_pstrings, (char*)buf->value);
1298             *(((LPCSTR*)(buf->pdata + buf->cur_pos_data))) = (char*)buf->cur_pstrings;
1299             buf->cur_pstrings += len;
1300             buf->cur_pos_data += sizeof(LPSTR);
1301           }
1302           else
1303           {
1304             FIXME("Token %d not supported\n", pt->members[i].type);
1305             return FALSE;
1306           }
1307         }
1308         else
1309         {
1310           FIXME("Unexpected token %d\n", token);
1311           return FALSE;
1312         }
1313       }
1314     }
1315
1316     /* Empty arrays can have the semicolon at the end or not so remove it if any and skip next check */
1317     if (!nb_elems && (check_TOKEN(buf) == TOKEN_SEMICOLON))
1318       get_TOKEN(buf);
1319
1320     if (nb_elems && buf->txt && (check_TOKEN(buf) != TOKEN_CBRACE) && (check_TOKEN(buf) != TOKEN_NAME))
1321     {
1322       token = get_TOKEN(buf);
1323       if ((token != TOKEN_SEMICOLON) && (token != TOKEN_COMMA))
1324         return FALSE;
1325     }
1326     buf->pxo->members[i].size = buf->cur_pos_data - buf->pxo->members[i].start;
1327   }
1328
1329   return TRUE;
1330 }
1331
1332 static BOOL parse_object_parts(parse_buffer * buf, BOOL allow_optional)
1333 {
1334   buf->pxo->nb_children = 0;
1335
1336   if (!parse_object_members_list(buf))
1337     return FALSE;
1338
1339   if (allow_optional)
1340   {
1341     buf->pxo->size = buf->cur_pos_data - buf->pxo->pos_data;
1342
1343     /* Skip trailing semicolon */
1344     while (check_TOKEN(buf) == TOKEN_SEMICOLON)
1345       get_TOKEN(buf);
1346
1347     while (1)
1348     {
1349       if (check_TOKEN(buf) == TOKEN_OBRACE)
1350       {
1351         ULONG i, j;
1352         get_TOKEN(buf);
1353         if (get_TOKEN(buf) != TOKEN_NAME)
1354           return FALSE;
1355         if (get_TOKEN(buf) != TOKEN_CBRACE)
1356           return FALSE;
1357         TRACE("Found optional reference %s\n", (char*)buf->value);
1358         for (i = 0; i < (buf->nb_pxo_globals+1); i++)
1359         {
1360           for (j = 0; j < (buf->pxo_globals[i])[0].nb_subobjects; j++)
1361           {
1362             if (!strcmp((buf->pxo_globals[i])[j].name, (char*)buf->value))
1363               goto _exit;
1364           }
1365         }
1366 _exit:
1367         if (i == (buf->nb_pxo_globals+1))
1368         {
1369           ERR("Reference to unknown object %s\n", (char*)buf->value);
1370           return FALSE;
1371         }
1372
1373         if (buf->pxo->root->nb_subobjects >= MAX_SUBOBJECTS)
1374         {
1375             FIXME("Too many sub-objects\n");
1376             return FALSE;
1377         }
1378
1379         buf->pxo->children[buf->pxo->nb_children] = &buf->pxo_tab[buf->pxo->root->nb_subobjects++];
1380         buf->pxo->children[buf->pxo->nb_children]->ptarget = &(buf->pxo_globals[i])[j];
1381         buf->pxo->children[buf->pxo->nb_children]->binary = FALSE;
1382         buf->pxo->nb_children++;
1383       }
1384       else if (check_TOKEN(buf) == TOKEN_NAME)
1385       {
1386         xobject* pxo = buf->pxo;
1387
1388         if (buf->pxo->root->nb_subobjects >= MAX_SUBOBJECTS)
1389         {
1390             FIXME("Too many sub-objects\n");
1391             return FALSE;
1392         }
1393
1394         buf->pxo = buf->pxo->children[buf->pxo->nb_children] = &buf->pxo_tab[buf->pxo->root->nb_subobjects++];
1395
1396         TRACE("Enter optional %s\n", (char*)buf->value);
1397         buf->level++;
1398         if (!parse_object(buf))
1399         {
1400           buf->level--;
1401           return FALSE;
1402         }
1403         buf->level--;
1404         buf->pxo = pxo;
1405         buf->pxo->nb_children++;
1406       }
1407       else
1408         break;
1409     }
1410   }
1411
1412   if (buf->pxo->nb_children > MAX_CHILDREN)
1413   {
1414     FIXME("Too many children %d\n", buf->pxo->nb_children);
1415     return FALSE;
1416   }
1417
1418   return TRUE;
1419 }
1420
1421 BOOL parse_object(parse_buffer * buf)
1422 {
1423   ULONG i;
1424
1425   buf->pxo->pos_data = buf->cur_pos_data;
1426   buf->pxo->ptarget = NULL;
1427   buf->pxo->binary = FALSE;
1428   buf->pxo->root = buf->pxo_tab;
1429
1430   if (get_TOKEN(buf) != TOKEN_NAME)
1431     return FALSE;
1432
1433   /* To do template lookup */
1434   for (i = 0; i < buf->pdxf->nb_xtemplates; i++)
1435   {
1436     if (!strcasecmp((char*)buf->value, buf->pdxf->xtemplates[i].name))
1437     {
1438       buf->pxt[buf->level] = &buf->pdxf->xtemplates[i];
1439       memcpy(&buf->pxo->type, &buf->pdxf->xtemplates[i].class_id, 16);
1440       break;
1441     }
1442   }
1443   if (i == buf->pdxf->nb_xtemplates)
1444   {
1445     ERR("Unknown template %s\n", (char*)buf->value);
1446     return FALSE;
1447   }
1448
1449   if (check_TOKEN(buf) == TOKEN_NAME)
1450   {
1451     get_TOKEN(buf);
1452     strcpy(buf->pxo->name, (char*)buf->value);
1453   }
1454   else
1455     buf->pxo->name[0] = 0;
1456
1457   if (get_TOKEN(buf) != TOKEN_OBRACE)
1458     return FALSE;
1459   if (check_TOKEN(buf) == TOKEN_GUID)
1460   {
1461     get_TOKEN(buf);
1462     memcpy(&buf->pxo->class_id, buf->value, 16);
1463   }
1464   else
1465     memset(&buf->pxo->class_id, 0, 16);
1466
1467   if (!parse_object_parts(buf, TRUE))
1468     return FALSE;
1469   if (get_TOKEN(buf) != TOKEN_CBRACE)
1470     return FALSE;
1471
1472   if (buf->txt)
1473   {
1474     /* Go to the next object */
1475     go_to_next_definition(buf);
1476   }
1477
1478   return TRUE;
1479 }