tools/winebuild/parser.c

   1 /*
   2  * Spec file parser
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 1995 Martin von Loewis
   6  * Copyright 1995, 1996, 1997, 2004 Alexandre Julliard
   7  * Copyright 1997 Eric Youngdale
   8  * Copyright 1999 Ulrich Weigand
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  28 #include <assert.h>
  29 #include <ctype.h>
  30 #include <stdarg.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include "windef.h"
  36 #include "winbase.h"
  37 #include "build.h"
  38
  39 int current_line = 0;
  40
  41 static char ParseBuffer[512];
  42 static char TokenBuffer[512];
  43 static char *ParseNext = ParseBuffer;
  44 static FILE *input_file;
  45
  46 static const char *separator_chars;
  47 static const char *comment_chars;
  48
  49 static const char * const TypeNames[TYPE_NBTYPES] =
  50 {
  51     "variable",     /* TYPE_VARIABLE */
  52     "pascal",       /* TYPE_PASCAL */
  53     "equate",       /* TYPE_ABS */
  54     "stub",         /* TYPE_STUB */
  55     "stdcall",      /* TYPE_STDCALL */
  56     "cdecl",        /* TYPE_CDECL */
  57     "varargs",      /* TYPE_VARARGS */
  58     "extern"        /* TYPE_EXTERN */
  59 };
  60
  61 static const char * const FlagNames[] =
  62 {
  63     "norelay",     /* FLAG_NORELAY */
  64     "noname",      /* FLAG_NONAME */
  65     "ret16",       /* FLAG_RET16 */
  66     "ret64",       /* FLAG_RET64 */
  67     "i386",        /* FLAG_I386 */
  68     "register",    /* FLAG_REGISTER */
  69     "private",     /* FLAG_PRIVATE */
  70     NULL
  71 };
  72
  73 static int IsNumberString(const char *s)
  74 {
  75     while (*s) if (!isdigit(*s++)) return 0;
  76     return 1;
  77 }
  78
  79 inline static int is_token_separator( char ch )
  80 {
  81     return strchr( separator_chars, ch ) != NULL;
  82 }
  83
  84 inline static int is_token_comment( char ch )
  85 {
  86     return strchr( comment_chars, ch ) != NULL;
  87 }
  88
  89 /* get the next line from the input file, or return 0 if at eof */
  90 static int get_next_line(void)
  91 {
  92     ParseNext = ParseBuffer;
  93     current_line++;
  94     return (fgets(ParseBuffer, sizeof(ParseBuffer), input_file) != NULL);
  95 }
  96
  97 static const char * GetToken( int allow_eol )
  98 {
  99     char *p = ParseNext;
 100     char *token = TokenBuffer;
 101
 102     for (;;)
 103     {
 104         /* remove initial white space */
 105         p = ParseNext;
 106         while (isspace(*p)) p++;
 107
 108         if (*p == '\\' && p[1] == '\n')  /* line continuation */
 109         {
 110             if (!get_next_line())
 111             {
 112                 if (!allow_eol) error( "Unexpected end of file\n" );
 113                 return NULL;
 114             }
 115         }
 116         else break;
 117     }
 118
 119     if ((*p == '\0') || is_token_comment(*p))
 120     {
 121         if (!allow_eol) error( "Declaration not terminated properly\n" );
 122         return NULL;
 123     }
 124
 125     /*
 126      * Find end of token.
 127      */
 128     if (is_token_separator(*p))
 129     {
 130         /* a separator is always a complete token */
 131         *token++ = *p++;
 132     }
 133     else while (*p != '\0' && !is_token_separator(*p) && !isspace(*p))
 134     {
 135         if (*p == '\\') p++;
 136         if (*p) *token++ = *p++;
 137     }
 138     *token = '\0';
 139     ParseNext = p;
 140     return TokenBuffer;
 141 }
 142
 143
 144 static ORDDEF *add_entry_point( DLLSPEC *spec )
 145 {
 146     if (spec->nb_entry_points == spec->alloc_entry_points)
 147     {
 148         spec->alloc_entry_points += 128;
 149         spec->entry_points = xrealloc( spec->entry_points,
 150                                        spec->alloc_entry_points * sizeof(*spec->entry_points) );
 151     }
 152     return &spec->entry_points[spec->nb_entry_points++];
 153 }
 154
 155 /*******************************************************************
 156  *         parse_spec_variable
 157  *
 158  * Parse a variable definition in a .spec file.
 159  */
 160 static int parse_spec_variable( ORDDEF *odp, DLLSPEC *spec )
 161 {
 162     char *endptr;
 163     int *value_array;
 164     int n_values;
 165     int value_array_size;
 166     const char *token;
 167
 168     if (spec->type == SPEC_WIN32)
 169     {
 170         error( "'variable' not supported in Win32, use 'extern' instead\n" );
 171         return 0;
 172     }
 173
 174     if (!(token = GetToken(0))) return 0;
 175     if (*token != '(')
 176     {
 177         error( "Expected '(' got '%s'\n", token );
 178         return 0;
 179     }
 180
 181     n_values = 0;
 182     value_array_size = 25;
 183     value_array = xmalloc(sizeof(*value_array) * value_array_size);
 184
 185     for (;;)
 186     {
 187         if (!(token = GetToken(0)))
 188         {
 189             free( value_array );
 190             return 0;
 191         }
 192         if (*token == ')')
 193             break;
 194
 195         value_array[n_values++] = strtol(token, &endptr, 0);
 196         if (n_values == value_array_size)
 197         {
 198             value_array_size += 25;
 199             value_array = xrealloc(value_array,
 200                                    sizeof(*value_array) * value_array_size);
 201         }
 202
 203         if (endptr == NULL || *endptr != '\0')
 204         {
 205             error( "Expected number value, got '%s'\n", token );
 206             free( value_array );
 207             return 0;
 208         }
 209     }
 210
 211     odp->u.var.n_values = n_values;
 212     odp->u.var.values = xrealloc(value_array, sizeof(*value_array) * n_values);
 213     return 1;
 214 }
 215
 216
 217 /*******************************************************************
 218  *         parse_spec_export
 219  *
 220  * Parse an exported function definition in a .spec file.
 221  */
 222 static int parse_spec_export( ORDDEF *odp, DLLSPEC *spec )
 223 {
 224     const char *token;
 225     unsigned int i;
 226
 227     switch(spec->type)
 228     {
 229     case SPEC_WIN16:
 230         if (odp->type == TYPE_STDCALL)
 231         {
 232             error( "'stdcall' not supported for Win16\n" );
 233             return 0;
 234         }
 235         break;
 236     case SPEC_WIN32:
 237         if (odp->type == TYPE_PASCAL)
 238         {
 239             error( "'pascal' not supported for Win32\n" );
 240             return 0;
 241         }
 242         break;
 243     default:
 244         break;
 245     }
 246
 247     if (!(token = GetToken(0))) return 0;
 248     if (*token != '(')
 249     {
 250         error( "Expected '(' got '%s'\n", token );
 251         return 0;
 252     }
 253
 254     for (i = 0; i < sizeof(odp->u.func.arg_types); i++)
 255     {
 256         if (!(token = GetToken(0))) return 0;
 257         if (*token == ')')
 258             break;
 259
 260         if (!strcmp(token, "word"))
 261             odp->u.func.arg_types[i] = 'w';
 262         else if (!strcmp(token, "s_word"))
 263             odp->u.func.arg_types[i] = 's';
 264         else if (!strcmp(token, "long") || !strcmp(token, "segptr"))
 265             odp->u.func.arg_types[i] = 'l';
 266         else if (!strcmp(token, "ptr"))
 267             odp->u.func.arg_types[i] = 'p';
 268         else if (!strcmp(token, "str"))
 269             odp->u.func.arg_types[i] = 't';
 270         else if (!strcmp(token, "wstr"))
 271             odp->u.func.arg_types[i] = 'W';
 272         else if (!strcmp(token, "segstr"))
 273             odp->u.func.arg_types[i] = 'T';
 274         else if (!strcmp(token, "double"))
 275         {
 276             odp->u.func.arg_types[i++] = 'l';
 277             if (i < sizeof(odp->u.func.arg_types)) odp->u.func.arg_types[i] = 'l';
 278         }
 279         else
 280         {
 281             error( "Unknown argument type '%s'\n", token );
 282             return 0;
 283         }
 284
 285         if (spec->type == SPEC_WIN32)
 286         {
 287             if (strcmp(token, "long") &&
 288                 strcmp(token, "ptr") &&
 289                 strcmp(token, "str") &&
 290                 strcmp(token, "wstr") &&
 291                 strcmp(token, "double"))
 292             {
 293                 error( "Type '%s' not supported for Win32\n", token );
 294                 return 0;
 295             }
 296         }
 297     }
 298     if ((*token != ')') || (i >= sizeof(odp->u.func.arg_types)))
 299     {
 300         error( "Too many arguments\n" );
 301         return 0;
 302     }
 303
 304     odp->u.func.arg_types[i] = '\0';
 305     if (odp->type == TYPE_VARARGS)
 306         odp->flags |= FLAG_NORELAY;  /* no relay debug possible for varags entry point */
 307
 308     if (!(token = GetToken(1)))
 309     {
 310         if (!strcmp( odp->name, "@" ))
 311         {
 312             error( "Missing handler name for anonymous function\n" );
 313             return 0;
 314         }
 315         odp->link_name = xstrdup( odp->name );
 316     }
 317     else
 318     {
 319         odp->link_name = xstrdup( token );
 320         if (strchr( odp->link_name, '.' ))
 321         {
 322             if (spec->type == SPEC_WIN16)
 323             {
 324                 error( "Forwarded functions not supported for Win16\n" );
 325                 return 0;
 326             }
 327             odp->flags |= FLAG_FORWARD;
 328         }
 329     }
 330     return 1;
 331 }
 332
 333
 334 /*******************************************************************
 335  *         parse_spec_equate
 336  *
 337  * Parse an 'equate' definition in a .spec file.
 338  */
 339 static int parse_spec_equate( ORDDEF *odp, DLLSPEC *spec )
 340 {
 341     char *endptr;
 342     int value;
 343     const char *token;
 344
 345     if (spec->type == SPEC_WIN32)
 346     {
 347         error( "'equate' not supported for Win32\n" );
 348         return 0;
 349     }
 350     if (!(token = GetToken(0))) return 0;
 351     value = strtol(token, &endptr, 0);
 352     if (endptr == NULL || *endptr != '\0')
 353     {
 354         error( "Expected number value, got '%s'\n", token );
 355         return 0;
 356     }
 357     odp->u.abs.value = value;
 358     return 1;
 359 }
 360
 361
 362 /*******************************************************************
 363  *         parse_spec_stub
 364  *
 365  * Parse a 'stub' definition in a .spec file
 366  */
 367 static int parse_spec_stub( ORDDEF *odp, DLLSPEC *spec )
 368 {
 369     odp->u.func.arg_types[0] = '\0';
 370     odp->link_name = xstrdup("");
 371     return 1;
 372 }
 373
 374
 375 /*******************************************************************
 376  *         parse_spec_extern
 377  *
 378  * Parse an 'extern' definition in a .spec file.
 379  */
 380 static int parse_spec_extern( ORDDEF *odp, DLLSPEC *spec )
 381 {
 382     const char *token;
 383
 384     if (spec->type == SPEC_WIN16)
 385     {
 386         error( "'extern' not supported for Win16, use 'variable' instead\n" );
 387         return 0;
 388     }
 389     if (!(token = GetToken(1)))
 390     {
 391         if (!strcmp( odp->name, "@" ))
 392         {
 393             error( "Missing handler name for anonymous extern\n" );
 394             return 0;
 395         }
 396         odp->link_name = xstrdup( odp->name );
 397     }
 398     else
 399     {
 400         odp->link_name = xstrdup( token );
 401         if (strchr( odp->link_name, '.' )) odp->flags |= FLAG_FORWARD;
 402     }
 403     return 1;
 404 }
 405
 406
 407 /*******************************************************************
 408  *         parse_spec_flags
 409  *
 410  * Parse the optional flags for an entry point in a .spec file.
 411  */
 412 static const char *parse_spec_flags( ORDDEF *odp )
 413 {
 414     unsigned int i;
 415     const char *token;
 416
 417     do
 418     {
 419         if (!(token = GetToken(0))) break;
 420         for (i = 0; FlagNames[i]; i++)
 421             if (!strcmp( FlagNames[i], token )) break;
 422         if (!FlagNames[i])
 423         {
 424             error( "Unknown flag '%s'\n", token );
 425             return NULL;
 426         }
 427         odp->flags |= 1 << i;
 428         token = GetToken(0);
 429     } while (token && *token == '-');
 430
 431     return token;
 432 }
 433
 434
 435 /*******************************************************************
 436  *         parse_spec_ordinal
 437  *
 438  * Parse an ordinal definition in a .spec file.
 439  */
 440 static int parse_spec_ordinal( int ordinal, DLLSPEC *spec )
 441 {
 442     const char *token;
 443
 444     ORDDEF *odp = add_entry_point( spec );
 445     memset( odp, 0, sizeof(*odp) );
 446
 447     if (!(token = GetToken(0))) goto error;
 448
 449     for (odp->type = 0; odp->type < TYPE_NBTYPES; odp->type++)
 450         if (TypeNames[odp->type] && !strcmp( token, TypeNames[odp->type] ))
 451             break;
 452
 453     if (odp->type >= TYPE_NBTYPES)
 454     {
 455         error( "Expected type after ordinal, found '%s' instead\n", token );
 456         goto error;
 457     }
 458
 459     if (!(token = GetToken(0))) goto error;
 460     if (*token == '-' && !(token = parse_spec_flags( odp ))) goto error;
 461
 462     odp->name = xstrdup( token );
 463     odp->lineno = current_line;
 464     odp->ordinal = ordinal;
 465
 466     switch(odp->type)
 467     {
 468     case TYPE_VARIABLE:
 469         if (!parse_spec_variable( odp, spec )) goto error;
 470         break;
 471     case TYPE_PASCAL:
 472     case TYPE_STDCALL:
 473     case TYPE_VARARGS:
 474     case TYPE_CDECL:
 475         if (!parse_spec_export( odp, spec )) goto error;
 476         break;
 477     case TYPE_ABS:
 478         if (!parse_spec_equate( odp, spec )) goto error;
 479         break;
 480     case TYPE_STUB:
 481         if (!parse_spec_stub( odp, spec )) goto error;
 482         break;
 483     case TYPE_EXTERN:
 484         if (!parse_spec_extern( odp, spec )) goto error;
 485         break;
 486     default:
 487         assert( 0 );
 488     }
 489
 490     if ((target_cpu != CPU_x86) && (odp->flags & FLAG_I386))
 491     {
 492         /* ignore this entry point on non-Intel archs */
 493         spec->nb_entry_points--;
 494         return 1;
 495     }
 496
 497     if (ordinal != -1)
 498     {
 499         if (!ordinal)
 500         {
 501             error( "Ordinal 0 is not valid\n" );
 502             goto error;
 503         }
 504         if (ordinal >= MAX_ORDINALS)
 505         {
 506             error( "Ordinal number %d too large\n", ordinal );
 507             goto error;
 508         }
 509         if (ordinal > spec->limit) spec->limit = ordinal;
 510         if (ordinal < spec->base) spec->base = ordinal;
 511         odp->ordinal = ordinal;
 512     }
 513
 514     if (spec->type == SPEC_WIN32 && odp->flags & FLAG_REGISTER)
 515     {
 516         error( "-register flag not supported for Win32 entry points\n" );
 517         goto error;
 518     }
 519
 520     if (odp->type == TYPE_STDCALL && !(odp->flags & FLAG_PRIVATE))
 521     {
 522         if (!strcmp( odp->name, "DllRegisterServer" ) ||
 523             !strcmp( odp->name, "DllUnregisterServer" ) ||
 524             !strcmp( odp->name, "DllGetClassObject" ) ||
 525             !strcmp( odp->name, "DllGetVersion" ) ||
 526             !strcmp( odp->name, "DllInstall" ) ||
 527             !strcmp( odp->name, "DllCanUnloadNow" ))
 528         {
 529             warning( "Function %s should be marked private\n", odp->name );
 530             if (strcmp( odp->name, odp->link_name ))
 531                 warning( "Function %s should not use a different internal name (%s)\n",
 532                          odp->name, odp->link_name );
 533         }
 534     }
 535
 536     if (!strcmp( odp->name, "@" ) || odp->flags & FLAG_NONAME)
 537     {
 538         if (ordinal == -1)
 539         {
 540             error( "Nameless function needs an explicit ordinal number\n" );
 541             goto error;
 542         }
 543         if (spec->type != SPEC_WIN32)
 544         {
 545             error( "Nameless functions not supported for Win16\n" );
 546             goto error;
 547         }
 548         if (!strcmp( odp->name, "@" )) free( odp->name );
 549         else odp->export_name = odp->name;
 550         odp->name = NULL;
 551     }
 552     return 1;
 553
 554 error:
 555     spec->nb_entry_points--;
 556     free( odp->name );
 557     return 0;
 558 }
 559
 560
 561 static int name_compare( const void *name1, const void *name2 )
 562 {
 563     const ORDDEF *odp1 = *(const ORDDEF * const *)name1;
 564     const ORDDEF *odp2 = *(const ORDDEF * const *)name2;
 565     return strcmp( odp1->name, odp2->name );
 566 }
 567
 568 /*******************************************************************
 569  *         assign_names
 570  *
 571  * Build the name array and catch duplicates.
 572  */
 573 static void assign_names( DLLSPEC *spec )
 574 {
 575     int i, j;
 576
 577     spec->nb_names = 0;
 578     for (i = 0; i < spec->nb_entry_points; i++)
 579         if (spec->entry_points[i].name) spec->nb_names++;
 580     if (!spec->nb_names) return;
 581
 582     spec->names = xmalloc( spec->nb_names * sizeof(spec->names[0]) );
 583     for (i = j = 0; i < spec->nb_entry_points; i++)
 584         if (spec->entry_points[i].name) spec->names[j++] = &spec->entry_points[i];
 585
 586     /* sort the list of names */
 587     qsort( spec->names, spec->nb_names, sizeof(spec->names[0]), name_compare );
 588
 589     /* check for duplicate names */
 590     for (i = 0; i < spec->nb_names - 1; i++)
 591     {
 592         if (!strcmp( spec->names[i]->name, spec->names[i+1]->name ))
 593         {
 594             current_line = max( spec->names[i]->lineno, spec->names[i+1]->lineno );
 595             error( "'%s' redefined\n%s:%d: First defined here\n",
 596                    spec->names[i]->name, input_file_name,
 597                    min( spec->names[i]->lineno, spec->names[i+1]->lineno ) );
 598         }
 599     }
 600 }
 601
 602 /*******************************************************************
 603  *         assign_ordinals
 604  *
 605  * Build the ordinal array.
 606  */
 607 static void assign_ordinals( DLLSPEC *spec )
 608 {
 609     int i, count, ordinal;
 610
 611     /* start assigning from base, or from 1 if no ordinal defined yet */
 612
 613     spec->base = MAX_ORDINALS;
 614     spec->limit = 0;
 615     for (i = 0; i < spec->nb_entry_points; i++)
 616     {
 617         ordinal = spec->entry_points[i].ordinal;
 618         if (ordinal == -1) continue;
 619         if (ordinal > spec->limit) spec->limit = ordinal;
 620         if (ordinal < spec->base) spec->base = ordinal;
 621     }
 622     if (spec->base == MAX_ORDINALS) spec->base = 1;
 623     if (spec->limit < spec->base) spec->limit = spec->base;
 624
 625     count = max( spec->limit + 1, spec->base + spec->nb_entry_points );
 626     spec->ordinals = xmalloc( count * sizeof(spec->ordinals[0]) );
 627     memset( spec->ordinals, 0, count * sizeof(spec->ordinals[0]) );
 628
 629     /* fill in all explicitly specified ordinals */
 630     for (i = 0; i < spec->nb_entry_points; i++)
 631     {
 632         ordinal = spec->entry_points[i].ordinal;
 633         if (ordinal == -1) continue;
 634         if (spec->ordinals[ordinal])
 635         {
 636             current_line = max( spec->entry_points[i].lineno, spec->ordinals[ordinal]->lineno );
 637             error( "ordinal %d redefined\n%s:%d: First defined here\n",
 638                    ordinal, input_file_name,
 639                    min( spec->entry_points[i].lineno, spec->ordinals[ordinal]->lineno ) );
 640         }
 641         else spec->ordinals[ordinal] = &spec->entry_points[i];
 642     }
 643
 644     /* now assign ordinals to the rest */
 645     for (i = 0, ordinal = spec->base; i < spec->nb_entry_points; i++)
 646     {
 647         if (spec->entry_points[i].ordinal != -1) continue;
 648         while (spec->ordinals[ordinal]) ordinal++;
 649         if (ordinal >= MAX_ORDINALS)
 650         {
 651             current_line = spec->entry_points[i].lineno;
 652             fatal_error( "Too many functions defined (max %d)\n", MAX_ORDINALS );
 653         }
 654         spec->entry_points[i].ordinal = ordinal;
 655         spec->ordinals[ordinal] = &spec->entry_points[i];
 656     }
 657     if (ordinal > spec->limit) spec->limit = ordinal;
 658 }
 659
 660
 661 /*******************************************************************
 662  *         parse_spec_file
 663  *
 664  * Parse a .spec file.
 665  */
 666 int parse_spec_file( FILE *file, DLLSPEC *spec )
 667 {
 668     const char *token;
 669
 670     input_file = file;
 671     current_line = 0;
 672
 673     comment_chars = "#;";
 674     separator_chars = "()-";
 675
 676     while (get_next_line())
 677     {
 678         if (!(token = GetToken(1))) continue;
 679         if (strcmp(token, "@") == 0)
 680         {
 681             if (spec->type != SPEC_WIN32)
 682             {
 683                 error( "'@' ordinals not supported for Win16\n" );
 684                 continue;
 685             }
 686             if (!parse_spec_ordinal( -1, spec )) continue;
 687         }
 688         else if (IsNumberString(token))
 689         {
 690             if (!parse_spec_ordinal( atoi(token), spec )) continue;
 691         }
 692         else
 693         {
 694             error( "Expected ordinal declaration, got '%s'\n", token );
 695             continue;
 696         }
 697         if ((token = GetToken(1))) error( "Syntax error near '%s'\n", token );
 698     }
 699
 700     current_line = 0;  /* no longer parsing the input file */
 701     assign_names( spec );
 702     assign_ordinals( spec );
 703     return !nb_errors;
 704 }
 705
 706
 707 /*******************************************************************
 708  *         parse_def_library
 709  *
 710  * Parse a LIBRARY declaration in a .def file.
 711  */
 712 static int parse_def_library( DLLSPEC *spec )
 713 {
 714     const char *token = GetToken(1);
 715
 716     if (!token) return 1;
 717     if (strcmp( token, "BASE" ))
 718     {
 719         free( spec->file_name );
 720         spec->file_name = xstrdup( token );
 721         if (!(token = GetToken(1))) return 1;
 722     }
 723     if (strcmp( token, "BASE" ))
 724     {
 725         error( "Expected library name or BASE= declaration, got '%s'\n", token );
 726         return 0;
 727     }
 728     if (!(token = GetToken(0))) return 0;
 729     if (strcmp( token, "=" ))
 730     {
 731         error( "Expected '=' after BASE, got '%s'\n", token );
 732         return 0;
 733     }
 734     if (!(token = GetToken(0))) return 0;
 735     /* FIXME: do something with base address */
 736
 737     return 1;
 738 }
 739
 740
 741 /*******************************************************************
 742  *         parse_def_stack_heap_size
 743  *
 744  * Parse a STACKSIZE or HEAPSIZE declaration in a .def file.
 745  */
 746 static int parse_def_stack_heap_size( int is_stack, DLLSPEC *spec )
 747 {
 748     const char *token = GetToken(0);
 749     char *end;
 750     unsigned long size;
 751
 752     if (!token) return 0;
 753     size = strtoul( token, &end, 0 );
 754     if (*end)
 755     {
 756         error( "Invalid number '%s'\n", token );
 757         return 0;
 758     }
 759     if (is_stack) spec->stack_size = size / 1024;
 760     else spec->heap_size = size / 1024;
 761     if (!(token = GetToken(1))) return 1;
 762     if (strcmp( token, "," ))
 763     {
 764         error( "Expected ',' after size, got '%s'\n", token );
 765         return 0;
 766     }
 767     if (!(token = GetToken(0))) return 0;
 768     /* FIXME: do something with reserve size */
 769     return 1;
 770 }
 771
 772
 773 /*******************************************************************
 774  *         parse_def_export
 775  *
 776  * Parse an export declaration in a .def file.
 777  */
 778 static int parse_def_export( char *name, DLLSPEC *spec )
 779 {
 780     int i, args;
 781     const char *token = GetToken(1);
 782
 783     ORDDEF *odp = add_entry_point( spec );
 784     memset( odp, 0, sizeof(*odp) );
 785
 786     odp->lineno = current_line;
 787     odp->ordinal = -1;
 788     odp->name = name;
 789     args = remove_stdcall_decoration( odp->name );
 790     if (args == -1) odp->type = TYPE_CDECL;
 791     else
 792     {
 793         odp->type = TYPE_STDCALL;
 794         args /= sizeof(int);
 795         if (args >= sizeof(odp->u.func.arg_types))
 796         {
 797             error( "Too many arguments in stdcall function '%s'\n", odp->name );
 798             return 0;
 799         }
 800         for (i = 0; i < args; i++) odp->u.func.arg_types[i] = 'l';
 801     }
 802
 803     /* check for optional internal name */
 804
 805     if (token && !strcmp( token, "=" ))
 806     {
 807         if (!(token = GetToken(0))) goto error;
 808         odp->link_name = xstrdup( token );
 809         remove_stdcall_decoration( odp->link_name );
 810         token = GetToken(1);
 811     }
 812     else
 813     {
 814       odp->link_name = xstrdup( name );
 815     }
 816
 817     /* check for optional ordinal */
 818
 819     if (token && token[0] == '@')
 820     {
 821         int ordinal;
 822
 823         if (!IsNumberString( token+1 ))
 824         {
 825             error( "Expected number after '@', got '%s'\n", token+1 );
 826             goto error;
 827         }
 828         ordinal = atoi( token+1 );
 829         if (!ordinal)
 830         {
 831             error( "Ordinal 0 is not valid\n" );
 832             goto error;
 833         }
 834         if (ordinal >= MAX_ORDINALS)
 835         {
 836             error( "Ordinal number %d too large\n", ordinal );
 837             goto error;
 838         }
 839         odp->ordinal = ordinal;
 840         token = GetToken(1);
 841     }
 842
 843     /* check for other optional keywords */
 844
 845     if (token && !strcmp( token, "NONAME" ))
 846     {
 847         if (odp->ordinal == -1)
 848         {
 849             error( "NONAME requires an ordinal\n" );
 850             goto error;
 851         }
 852         odp->export_name = odp->name;
 853         odp->name = NULL;
 854         odp->flags |= FLAG_NONAME;
 855         token = GetToken(1);
 856     }
 857     if (token && !strcmp( token, "PRIVATE" ))
 858     {
 859         odp->flags |= FLAG_PRIVATE;
 860         token = GetToken(1);
 861     }
 862     if (token && !strcmp( token, "DATA" ))
 863     {
 864         odp->type = TYPE_EXTERN;
 865         token = GetToken(1);
 866     }
 867     if (token)
 868     {
 869         error( "Garbage text '%s' found at end of export declaration\n", token );
 870         goto error;
 871     }
 872     return 1;
 873
 874 error:
 875     spec->nb_entry_points--;
 876     free( odp->name );
 877     return 0;
 878 }
 879
 880
 881 /*******************************************************************
 882  *         parse_def_file
 883  *
 884  * Parse a .def file.
 885  */
 886 int parse_def_file( FILE *file, DLLSPEC *spec )
 887 {
 888     const char *token;
 889     int in_exports = 0;
 890
 891     input_file = file;
 892     current_line = 0;
 893
 894     comment_chars = ";";
 895     separator_chars = ",=";
 896
 897     while (get_next_line())
 898     {
 899         if (!(token = GetToken(1))) continue;
 900
 901         if (!strcmp( token, "LIBRARY" ) || !strcmp( token, "NAME" ))
 902         {
 903             if (!parse_def_library( spec )) continue;
 904             goto end_of_line;
 905         }
 906         else if (!strcmp( token, "STACKSIZE" ))
 907         {
 908             if (!parse_def_stack_heap_size( 1, spec )) continue;
 909             goto end_of_line;
 910         }
 911         else if (!strcmp( token, "HEAPSIZE" ))
 912         {
 913             if (!parse_def_stack_heap_size( 0, spec )) continue;
 914             goto end_of_line;
 915         }
 916         else if (!strcmp( token, "EXPORTS" ))
 917         {
 918             in_exports = 1;
 919             if (!(token = GetToken(1))) continue;
 920         }
 921         else if (!strcmp( token, "IMPORTS" ))
 922         {
 923             in_exports = 0;
 924             if (!(token = GetToken(1))) continue;
 925         }
 926         else if (!strcmp( token, "SECTIONS" ))
 927         {
 928             in_exports = 0;
 929             if (!(token = GetToken(1))) continue;
 930         }
 931
 932         if (!in_exports) continue;  /* ignore this line */
 933         if (!parse_def_export( xstrdup(token), spec )) continue;
 934
 935     end_of_line:
 936         if ((token = GetToken(1))) error( "Syntax error near '%s'\n", token );
 937     }
 938
 939     current_line = 0;  /* no longer parsing the input file */
 940     assign_names( spec );
 941     assign_ordinals( spec );
 942     return !nb_errors;
 943 }
 944
 945
 946 /*******************************************************************
 947  *         add_debug_channel
 948  */
 949 static void add_debug_channel( const char *name )
 950 {
 951     int i;
 952
 953     for (i = 0; i < nb_debug_channels; i++)
 954         if (!strcmp( debug_channels[i], name )) return;
 955
 956     debug_channels = xrealloc( debug_channels, (nb_debug_channels + 1) * sizeof(*debug_channels));
 957     debug_channels[nb_debug_channels++] = xstrdup(name);
 958 }
 959
 960
 961 /*******************************************************************
 962  *         parse_debug_channels
 963  *
 964  * Parse a source file and extract the debug channel definitions.
 965  */
 966 int parse_debug_channels( const char *srcdir, const char *filename )
 967 {
 968     FILE *file;
 969     int eol_seen = 1;
 970
 971     file = open_input_file( srcdir, filename );
 972     while (fgets( ParseBuffer, sizeof(ParseBuffer), file ))
 973     {
 974         char *channel, *end, *p = ParseBuffer;
 975
 976         p = ParseBuffer + strlen(ParseBuffer) - 1;
 977         if (!eol_seen)  /* continuation line */
 978         {
 979             eol_seen = (*p == '\n');
 980             continue;
 981         }
 982         if ((eol_seen = (*p == '\n'))) *p = 0;
 983
 984         p = ParseBuffer;
 985         while (isspace(*p)) p++;
 986         if (!memcmp( p, "WINE_DECLARE_DEBUG_CHANNEL", 26 ) ||
 987             !memcmp( p, "WINE_DEFAULT_DEBUG_CHANNEL", 26 ))
 988         {
 989             p += 26;
 990             while (isspace(*p)) p++;
 991             if (*p != '(')
 992             {
 993                 error( "invalid debug channel specification '%s'\n", ParseBuffer );
 994                 goto next;
 995             }
 996             p++;
 997             while (isspace(*p)) p++;
 998             if (!isalpha(*p))
 999             {
1000                 error( "invalid debug channel specification '%s'\n", ParseBuffer );
1001                 goto next;
1002             }
1003             channel = p;
1004             while (isalnum(*p) || *p == '_') p++;
1005             end = p;
1006             while (isspace(*p)) p++;
1007             if (*p != ')')
1008             {
1009                 error( "invalid debug channel specification '%s'\n", ParseBuffer );
1010                 goto next;
1011             }
1012             *end = 0;
1013             add_debug_channel( channel );
1014         }
1015     next:
1016         current_line++;
1017     }
1018     close_input_file( file );
1019     return !nb_errors;
1020 }