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 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 <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33
  34 #include "winbase.h"
  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 * const TypeNames[TYPE_NBTYPES] =
  45 {
  46     "variable",     /* TYPE_VARIABLE */
  47     "pascal16",     /* TYPE_PASCAL_16 */
  48     "pascal",       /* TYPE_PASCAL */
  49     "equate",       /* TYPE_ABS */
  50     "stub",         /* TYPE_STUB */
  51     "stdcall",      /* TYPE_STDCALL */
  52     "cdecl",        /* TYPE_CDECL */
  53     "varargs",      /* TYPE_VARARGS */
  54     "extern",       /* TYPE_EXTERN */
  55     "forward"       /* TYPE_FORWARD */
  56 };
  57
  58 static const char * const FlagNames[] =
  59 {
  60     "noimport",    /* FLAG_NOIMPORT */
  61     "norelay",     /* FLAG_NORELAY */
  62     "noname",      /* FLAG_NONAME */
  63     "ret64",       /* FLAG_RET64 */
  64     "i386",        /* FLAG_I386 */
  65     "register",    /* FLAG_REGISTER */
  66     "interrupt",   /* FLAG_INTERRUPT */
  67     NULL
  68 };
  69
  70 static int IsNumberString(const char *s)
  71 {
  72     while (*s) if (!isdigit(*s++)) return 0;
  73     return 1;
  74 }
  75
  76 inline static int is_token_separator( char ch )
  77 {
  78     return (ch == '(' || ch == ')' || ch == '-');
  79 }
  80
  81 static const char * GetTokenInLine(void)
  82 {
  83     char *p = ParseNext;
  84     char *token = TokenBuffer;
  85
  86     /*
  87      * Remove initial white space.
  88      */
  89     while (isspace(*p)) p++;
  90
  91     if ((*p == '\0') || (*p == '#')) return NULL;
  92
  93     /*
  94      * Find end of token.
  95      */
  96     if (is_token_separator(*p))
  97     {
  98         /* a separator is always a complete token */
  99         *token++ = *p++;
 100     }
 101     else while (*p != '\0' && !is_token_separator(*p) && !isspace(*p))
 102     {
 103         if (*p == '\\') p++;
 104         if (*p) *token++ = *p++;
 105     }
 106     *token = '\0';
 107     ParseNext = p;
 108     return TokenBuffer;
 109 }
 110
 111 static const char * GetToken( int allow_eof )
 112 {
 113     const char *token;
 114
 115     while ((token = GetTokenInLine()) == NULL)
 116     {
 117         ParseNext = ParseBuffer;
 118         current_line++;
 119         if (fgets(ParseBuffer, sizeof(ParseBuffer), input_file) == NULL)
 120         {
 121             if (!allow_eof) fatal_error( "Unexpected end of file\n" );
 122             return NULL;
 123         }
 124     }
 125     return token;
 126 }
 127
 128
 129 /*******************************************************************
 130  *         ParseIgnore
 131  *
 132  * Parse an 'ignore' definition.
 133  */
 134 static void ParseIgnore(void)
 135 {
 136     const char *token = GetToken(0);
 137     if (*token != '(') fatal_error( "Expected '(' got '%s'\n", token );
 138     for (;;)
 139     {
 140         token = GetToken(0);
 141         if (*token == ')') break;
 142         add_ignore_symbol( token );
 143     }
 144 }
 145
 146
 147 /*******************************************************************
 148  *         ParseVariable
 149  *
 150  * Parse a variable definition.
 151  */
 152 static void ParseVariable( ORDDEF *odp )
 153 {
 154     char *endptr;
 155     int *value_array;
 156     int n_values;
 157     int value_array_size;
 158
 159     const char *token = GetToken(0);
 160     if (*token != '(') fatal_error( "Expected '(' got '%s'\n", token );
 161
 162     n_values = 0;
 163     value_array_size = 25;
 164     value_array = xmalloc(sizeof(*value_array) * value_array_size);
 165
 166     for (;;)
 167     {
 168         token = GetToken(0);
 169         if (*token == ')')
 170             break;
 171
 172         value_array[n_values++] = strtol(token, &endptr, 0);
 173         if (n_values == value_array_size)
 174         {
 175             value_array_size += 25;
 176             value_array = xrealloc(value_array,
 177                                    sizeof(*value_array) * value_array_size);
 178         }
 179
 180         if (endptr == NULL || *endptr != '\0')
 181             fatal_error( "Expected number value, got '%s'\n", token );
 182     }
 183
 184     odp->u.var.n_values = n_values;
 185     odp->u.var.values = xrealloc(value_array, sizeof(*value_array) * n_values);
 186 }
 187
 188
 189 /*******************************************************************
 190  *         ParseExportFunction
 191  *
 192  * Parse a function definition.
 193  */
 194 static void ParseExportFunction( ORDDEF *odp )
 195 {
 196     const char *token;
 197     unsigned int i;
 198
 199     switch(SpecType)
 200     {
 201     case SPEC_WIN16:
 202         if (odp->type == TYPE_STDCALL)
 203             fatal_error( "'stdcall' not supported for Win16\n" );
 204         if (odp->type == TYPE_VARARGS)
 205             fatal_error( "'varargs' not supported for Win16\n" );
 206         break;
 207     case SPEC_WIN32:
 208         if ((odp->type == TYPE_PASCAL) || (odp->type == TYPE_PASCAL_16))
 209             fatal_error( "'pascal' not supported for Win32\n" );
 210         if (odp->flags & FLAG_INTERRUPT)
 211             fatal_error( "'interrupt' not supported for Win32\n" );
 212         break;
 213     default:
 214         break;
 215     }
 216
 217     token = GetToken(0);
 218     if (*token != '(') fatal_error( "Expected '(' got '%s'\n", token );
 219
 220     for (i = 0; i < sizeof(odp->u.func.arg_types); i++)
 221     {
 222         token = GetToken(0);
 223         if (*token == ')')
 224             break;
 225
 226         if (!strcmp(token, "word"))
 227             odp->u.func.arg_types[i] = 'w';
 228         else if (!strcmp(token, "s_word"))
 229             odp->u.func.arg_types[i] = 's';
 230         else if (!strcmp(token, "long") || !strcmp(token, "segptr"))
 231             odp->u.func.arg_types[i] = 'l';
 232         else if (!strcmp(token, "ptr"))
 233             odp->u.func.arg_types[i] = 'p';
 234         else if (!strcmp(token, "str"))
 235             odp->u.func.arg_types[i] = 't';
 236         else if (!strcmp(token, "wstr"))
 237             odp->u.func.arg_types[i] = 'W';
 238         else if (!strcmp(token, "segstr"))
 239             odp->u.func.arg_types[i] = 'T';
 240         else if (!strcmp(token, "double"))
 241         {
 242             odp->u.func.arg_types[i++] = 'l';
 243             if (i < sizeof(odp->u.func.arg_types)) odp->u.func.arg_types[i] = 'l';
 244         }
 245         else fatal_error( "Unknown variable type '%s'\n", token );
 246
 247         if (SpecType == SPEC_WIN32)
 248         {
 249             if (strcmp(token, "long") &&
 250                 strcmp(token, "ptr") &&
 251                 strcmp(token, "str") &&
 252                 strcmp(token, "wstr") &&
 253                 strcmp(token, "double"))
 254             {
 255                 fatal_error( "Type '%s' not supported for Win32\n", token );
 256             }
 257         }
 258     }
 259     if ((*token != ')') || (i >= sizeof(odp->u.func.arg_types)))
 260         fatal_error( "Too many arguments\n" );
 261
 262     odp->u.func.arg_types[i] = '\0';
 263     if (odp->type == TYPE_VARARGS)
 264         odp->flags |= FLAG_NORELAY;  /* no relay debug possible for varags entry point */
 265     odp->link_name = xstrdup( GetToken(0) );
 266 }
 267
 268
 269 /*******************************************************************
 270  *         ParseEquate
 271  *
 272  * Parse an 'equate' definition.
 273  */
 274 static void ParseEquate( ORDDEF *odp )
 275 {
 276     char *endptr;
 277
 278     const char *token = GetToken(0);
 279     int value = strtol(token, &endptr, 0);
 280     if (endptr == NULL || *endptr != '\0')
 281         fatal_error( "Expected number value, got '%s'\n", token );
 282     if (SpecType == SPEC_WIN32)
 283         fatal_error( "'equate' not supported for Win32\n" );
 284     odp->u.abs.value = value;
 285 }
 286
 287
 288 /*******************************************************************
 289  *         ParseStub
 290  *
 291  * Parse a 'stub' definition.
 292  */
 293 static void ParseStub( ORDDEF *odp )
 294 {
 295     odp->u.func.arg_types[0] = '\0';
 296     odp->link_name = xstrdup("");
 297 }
 298
 299
 300 /*******************************************************************
 301  *         ParseExtern
 302  *
 303  * Parse an 'extern' definition.
 304  */
 305 static void ParseExtern( ORDDEF *odp )
 306 {
 307     if (SpecType == SPEC_WIN16) fatal_error( "'extern' not supported for Win16\n" );
 308     odp->link_name = xstrdup( GetToken(0) );
 309     /* 'extern' definitions are not available for implicit import */
 310     odp->flags |= FLAG_NOIMPORT;
 311 }
 312
 313
 314 /*******************************************************************
 315  *         ParseForward
 316  *
 317  * Parse a 'forward' definition.
 318  */
 319 static void ParseForward( ORDDEF *odp )
 320 {
 321     if (SpecType == SPEC_WIN16) fatal_error( "'forward' not supported for Win16\n" );
 322     odp->link_name = xstrdup( GetToken(0) );
 323 }
 324
 325
 326 /*******************************************************************
 327  *         ParseFlags
 328  *
 329  * Parse the optional flags for an entry point
 330  */
 331 static const char *ParseFlags( ORDDEF *odp )
 332 {
 333     unsigned int i;
 334     const char *token;
 335
 336     do
 337     {
 338         token = GetToken(0);
 339         for (i = 0; FlagNames[i]; i++)
 340             if (!strcmp( FlagNames[i], token )) break;
 341         if (!FlagNames[i]) fatal_error( "Unknown flag '%s'\n", token );
 342         odp->flags |= 1 << i;
 343         token = GetToken(0);
 344     } while (*token == '-');
 345
 346     return token;
 347 }
 348
 349 /*******************************************************************
 350  *         fix_export_name
 351  *
 352  * Fix an exported function name by removing a possible @xx suffix
 353  */
 354 static void fix_export_name( char *name )
 355 {
 356     char *p, *end = strrchr( name, '@' );
 357     if (!end || !end[1] || end == name) return;
 358     /* make sure all the rest is digits */
 359     for (p = end + 1; *p; p++) if (!isdigit(*p)) return;
 360     *end = 0;
 361 }
 362
 363 /*******************************************************************
 364  *         ParseOrdinal
 365  *
 366  * Parse an ordinal definition.
 367  */
 368 static void ParseOrdinal(int ordinal)
 369 {
 370     const char *token;
 371
 372     ORDDEF *odp = xmalloc( sizeof(*odp) );
 373     memset( odp, 0, sizeof(*odp) );
 374     EntryPoints[nb_entry_points++] = odp;
 375
 376     token = GetToken(0);
 377
 378     for (odp->type = 0; odp->type < TYPE_NBTYPES; odp->type++)
 379         if (TypeNames[odp->type] && !strcmp( token, TypeNames[odp->type] ))
 380             break;
 381
 382     if (odp->type >= TYPE_NBTYPES)
 383         fatal_error( "Expected type after ordinal, found '%s' instead\n", token );
 384
 385     token = GetToken(0);
 386     if (*token == '-') token = ParseFlags( odp );
 387
 388     odp->name = xstrdup( token );
 389     fix_export_name( odp->name );
 390     odp->lineno = current_line;
 391     odp->ordinal = ordinal;
 392
 393     switch(odp->type)
 394     {
 395     case TYPE_VARIABLE:
 396         ParseVariable( odp );
 397         break;
 398     case TYPE_PASCAL_16:
 399     case TYPE_PASCAL:
 400     case TYPE_STDCALL:
 401     case TYPE_VARARGS:
 402     case TYPE_CDECL:
 403         ParseExportFunction( odp );
 404         break;
 405     case TYPE_ABS:
 406         ParseEquate( odp );
 407         break;
 408     case TYPE_STUB:
 409         ParseStub( odp );
 410         break;
 411     case TYPE_EXTERN:
 412         ParseExtern( odp );
 413         break;
 414     case TYPE_FORWARD:
 415         ParseForward( odp );
 416         break;
 417     default:
 418         assert( 0 );
 419     }
 420
 421 #ifndef __i386__
 422     if (odp->flags & FLAG_I386)
 423     {
 424         /* ignore this entry point on non-Intel archs */
 425         EntryPoints[--nb_entry_points] = NULL;
 426         free( odp );
 427         return;
 428     }
 429 #endif
 430
 431     if (ordinal != -1)
 432     {
 433         if (!ordinal) fatal_error( "Ordinal 0 is not valid\n" );
 434         if (ordinal >= MAX_ORDINALS) fatal_error( "Ordinal number %d too large\n", ordinal );
 435         if (ordinal > Limit) Limit = ordinal;
 436         if (ordinal < Base) Base = ordinal;
 437         odp->ordinal = ordinal;
 438         Ordinals[ordinal] = odp;
 439     }
 440
 441     if (!strcmp( odp->name, "@" ) || odp->flags & FLAG_NONAME)
 442     {
 443         if (ordinal == -1)
 444             fatal_error( "Nameless function needs an explicit ordinal number\n" );
 445         if (SpecType != SPEC_WIN32)
 446             fatal_error( "Nameless functions not supported for Win16\n" );
 447         if (!strcmp( odp->name, "@" )) free( odp->name );
 448         else odp->export_name = odp->name;
 449         odp->name = NULL;
 450     }
 451     else Names[nb_names++] = odp;
 452 }
 453
 454
 455 static int name_compare( const void *name1, const void *name2 )
 456 {
 457     ORDDEF *odp1 = *(ORDDEF **)name1;
 458     ORDDEF *odp2 = *(ORDDEF **)name2;
 459     return strcmp( odp1->name, odp2->name );
 460 }
 461
 462 /*******************************************************************
 463  *         sort_names
 464  *
 465  * Sort the name array and catch duplicates.
 466  */
 467 static void sort_names(void)
 468 {
 469     int i;
 470
 471     if (!nb_names) return;
 472
 473     /* sort the list of names */
 474     qsort( Names, nb_names, sizeof(Names[0]), name_compare );
 475
 476     /* check for duplicate names */
 477     for (i = 0; i < nb_names - 1; i++)
 478     {
 479         if (!strcmp( Names[i]->name, Names[i+1]->name ))
 480         {
 481             current_line = max( Names[i]->lineno, Names[i+1]->lineno );
 482             fatal_error( "'%s' redefined\n%s:%d: First defined here\n",
 483                          Names[i]->name, input_file_name,
 484                          min( Names[i]->lineno, Names[i+1]->lineno ) );
 485         }
 486     }
 487 }
 488
 489
 490 /*******************************************************************
 491  *         ParseTopLevel
 492  *
 493  * Parse a spec file.
 494  */
 495 void ParseTopLevel( FILE *file )
 496 {
 497     const char *token;
 498
 499     input_file = file;
 500     current_line = 0;
 501
 502     while ((token = GetToken(1)) != NULL)
 503     {
 504         if (strcmp(token, "ignore") == 0)
 505         {
 506             if (SpecType != SPEC_WIN32)
 507                 fatal_error( "'ignore' only supported for Win32 spec files\n" );
 508             ParseIgnore();
 509         }
 510         else if (strcmp(token, "@") == 0)
 511         {
 512             if (SpecType != SPEC_WIN32)
 513                 fatal_error( "'@' ordinals not supported for Win16\n" );
 514             ParseOrdinal( -1 );
 515         }
 516         else if (IsNumberString(token))
 517         {
 518             ParseOrdinal( atoi(token) );
 519         }
 520         else
 521             fatal_error( "Expected ordinal declaration\n" );
 522     }
 523
 524     current_line = 0;  /* no longer parsing the input file */
 525     sort_names();
 526 }
 527
 528
 529 /*******************************************************************
 530  *         add_debug_channel
 531  */
 532 static void add_debug_channel( const char *name )
 533 {
 534     int i;
 535
 536     for (i = 0; i < nb_debug_channels; i++)
 537         if (!strcmp( debug_channels[i], name )) return;
 538
 539     debug_channels = xrealloc( debug_channels, (nb_debug_channels + 1) * sizeof(*debug_channels));
 540     debug_channels[nb_debug_channels++] = xstrdup(name);
 541 }
 542
 543
 544 /*******************************************************************
 545  *         parse_debug_channels
 546  *
 547  * Parse a source file and extract the debug channel definitions.
 548  */
 549 void parse_debug_channels( const char *srcdir, const char *filename )
 550 {
 551     FILE *file;
 552     int eol_seen = 1;
 553
 554     file = open_input_file( srcdir, filename );
 555     while (fgets( ParseBuffer, sizeof(ParseBuffer), file ))
 556     {
 557         char *channel, *end, *p = ParseBuffer;
 558
 559         p = ParseBuffer + strlen(ParseBuffer) - 1;
 560         if (!eol_seen)  /* continuation line */
 561         {
 562             eol_seen = (*p == '\n');
 563             continue;
 564         }
 565         if ((eol_seen = (*p == '\n'))) *p = 0;
 566
 567         p = ParseBuffer;
 568         while (isspace(*p)) p++;
 569         if (!memcmp( p, "WINE_DECLARE_DEBUG_CHANNEL", 26 ) ||
 570             !memcmp( p, "WINE_DEFAULT_DEBUG_CHANNEL", 26 ))
 571         {
 572             p += 26;
 573             while (isspace(*p)) p++;
 574             if (*p != '(')
 575                 fatal_error( "invalid debug channel specification '%s'\n", ParseBuffer );
 576             p++;
 577             while (isspace(*p)) p++;
 578             if (!isalpha(*p))
 579                 fatal_error( "invalid debug channel specification '%s'\n", ParseBuffer );
 580             channel = p;
 581             while (isalnum(*p) || *p == '_') p++;
 582             end = p;
 583             while (isspace(*p)) p++;
 584             if (*p != ')')
 585                 fatal_error( "invalid debug channel specification '%s'\n", ParseBuffer );
 586             *end = 0;
 587             add_debug_channel( channel );
 588         }
 589         current_line++;
 590     }
 591     close_input_file( file );
 592 }