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