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