tools/winebuild/main.c

   1 /*
   2  * Main function
   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 <stdio.h>
  30 #include <errno.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33
  34 #include "build.h"
  35
  36 ORDDEF *EntryPoints[MAX_ORDINALS];
  37 ORDDEF *Ordinals[MAX_ORDINALS];
  38 ORDDEF *Names[MAX_ORDINALS];
  39
  40 SPEC_MODE SpecMode = SPEC_MODE_DLL;
  41 SPEC_TYPE SpecType = SPEC_WIN32;
  42
  43 int Base = MAX_ORDINALS;
  44 int Limit = 0;
  45 int DLLHeapSize = 0;
  46 int UsePIC = 0;
  47 int stack_size = 0;
  48 int nb_entry_points = 0;
  49 int nb_names = 0;
  50 int nb_debug_channels = 0;
  51 int nb_lib_paths = 0;
  52 int display_warnings = 0;
  53
  54 /* we only support relay debugging on i386 */
  55 #if defined(__i386__) && !defined(NO_TRACE_MSGS)
  56 int debugging = 1;
  57 #else
  58 int debugging = 0;
  59 #endif
  60
  61 char DLLName[80];
  62 char DLLFileName[80];
  63 char owner_name[80];
  64 char *init_func = NULL;
  65 char **debug_channels = NULL;
  66 char **lib_path = NULL;
  67
  68 char *input_file_name = NULL;
  69 const char *output_file_name = NULL;
  70
  71 static FILE *input_file;
  72 static FILE *output_file;
  73 static const char *current_src_dir;
  74 static int nb_res_files;
  75 static char **res_files;
  76
  77 /* execution mode */
  78 static enum
  79 {
  80     MODE_NONE,
  81     MODE_SPEC,
  82     MODE_EXE,
  83     MODE_GLUE,
  84     MODE_DEF,
  85     MODE_DEBUG,
  86     MODE_RELAY16,
  87     MODE_RELAY32
  88 } exec_mode = MODE_NONE;
  89
  90 /* set the dll file name from the input file name */
  91 static void set_dll_file_name( const char *name )
  92 {
  93     char *p;
  94
  95     if ((p = strrchr( name, '\\' ))) name = p + 1;
  96     if ((p = strrchr( name, '/' ))) name = p + 1;
  97     strcpy( DLLFileName, name );
  98     if ((p = strrchr( DLLFileName, '.' )) && !strcmp( p, ".spec" )) *p = 0;
  99     if (!strchr( DLLFileName, '.' )) strcat( DLLFileName, ".dll" );
 100 }
 101
 102 /* cleanup on program exit */
 103 static void cleanup(void)
 104 {
 105     if (output_file_name) unlink( output_file_name );
 106 }
 107
 108
 109 /*******************************************************************
 110  *         command-line option handling
 111  */
 112
 113 struct option_descr
 114 {
 115     const char *name;
 116     int         has_arg;
 117     void      (*func)();
 118     const char *usage;
 119 };
 120
 121 static void do_output( const char *arg );
 122 static void do_usage(void);
 123 static void do_warnings(void);
 124 static void do_f_flags( const char *arg );
 125 static void do_define( const char *arg );
 126 static void do_include( const char *arg );
 127 static void do_k_flags( const char *arg );
 128 static void do_exe_mode( const char *arg );
 129 static void do_module( const char *arg );
 130 static void do_heap( const char *arg );
 131 static void do_name( const char *arg );
 132 static void do_entry( const char *arg );
 133 static void do_spec( const char *arg );
 134 static void do_def( const char *arg );
 135 static void do_exe( const char *arg );
 136 static void do_glue(void);
 137 static void do_relay16(void);
 138 static void do_relay32(void);
 139 static void do_debug(void);
 140 static void do_chdir( const char *arg );
 141 static void do_lib( const char *arg );
 142 static void do_import( const char *arg );
 143 static void do_dimport( const char *arg );
 144 static void do_rsrc( const char *arg );
 145
 146 static const struct option_descr option_table[] =
 147 {
 148     { "-h",        0, do_usage,   "-h               Display this help message" },
 149     { "-w",        0, do_warnings,"-w               Turn on warnings" },
 150     { "-C",        1, do_chdir,   "-C dir           Change directory to <dir> before opening source files" },
 151     { "-f",        1, do_f_flags, "-f flags         Compiler flags (only -fPIC is supported)" },
 152     { "-D",        1, do_define,  "-D sym           Ignored for C flags compatibility" },
 153     { "-I",        1, do_include, "-I dir           Ignored for C flags compatibility" },
 154     { "-K",        1, do_k_flags, "-K flags         Compiler flags (only -KPIC is supported)" },
 155     { "-m",        1, do_exe_mode,"-m mode          Set the executable mode (cui|gui|cuiw|guiw)" },
 156     { "-M",        1, do_module,  "-M module        Set the name of the main (Win32) module for a Win16 dll" },
 157     { "-L",        1, do_lib,     "-L directory     Look for imports libraries in 'directory'" },
 158     { "-l",        1, do_import,  "-l lib.dll       Import the specified library" },
 159     { "-d",        1, do_dimport, "-d lib.dll       Delay-import the specified library" },
 160     { "-H",        1, do_heap,    "-H size          Set the heap size for a Win16 dll" },
 161     { "-N",        1, do_name,    "-N dllname       Set the DLL name (default: set from input file name)" },
 162     { "-e",        1, do_entry,   "-e function      Set the DLL entry point function (default: DllMain)" },
 163     { "-r",        1, do_rsrc,    "-r rsrc.res      Load resources from rsrc.res" },
 164     { "-res",      1, do_rsrc,    NULL },  /* for backwards compatibility, will disappear */
 165     { "-o",        1, do_output,  "-o name          Set the output file name (default: stdout)\n" },
 166     { "--spec",    1, do_spec,    "--spec file.spec Build a .c file from a spec file" },
 167     { "--def",     1, do_def,     "--def file.spec  Build a .def file from a spec file" },
 168     { "--exe",     1, do_exe,     "--exe name       Build a .c file for the named executable" },
 169     { "--debug",   0, do_debug,   "--debug [files]  Build a .c file containing debug channels declarations" },
 170     { "--glue",    0, do_glue,    "--glue [files]   Build the 16-bit glue for the source files" },
 171     { "--relay16", 0, do_relay16, "--relay16        Build the 16-bit relay assembly routines" },
 172     { "--relay32", 0, do_relay32, "--relay32        Build the 32-bit relay assembly routines" },
 173     { NULL,       0, NULL,      NULL }
 174 };
 175
 176 static void do_output( const char *arg )
 177 {
 178     if ( ( unlink ( arg ) ) == -1 && ( errno != ENOENT ) )
 179     {
 180         fprintf ( stderr, "Unable to create output file '%s'\n", arg );
 181         exit (1);
 182     }
 183     if (!(output_file = fopen( arg, "w" )))
 184     {
 185         fprintf( stderr, "Unable to create output file '%s'\n", arg );
 186         exit(1);
 187     }
 188     output_file_name = arg;
 189     atexit( cleanup );  /* make sure we remove the output file on exit */
 190 }
 191
 192 static void do_usage(void)
 193 {
 194     const struct option_descr *opt;
 195     fprintf( stderr, "Usage: winebuild [options]\n\n" );
 196     fprintf( stderr, "Options:\n" );
 197     for (opt = option_table; opt->name; opt++)
 198         if (opt->usage) fprintf( stderr, "   %s\n", opt->usage );
 199
 200     fprintf( stderr, "\nExactly one of --spec, --def, --exe, --debug, --glue, --relay16 or --relay32 must be specified.\n\n" );
 201     exit(1);
 202 }
 203
 204 static void do_warnings(void)
 205 {
 206     display_warnings = 1;
 207 }
 208
 209 static void do_f_flags( const char *arg )
 210 {
 211     if (!strcmp( arg, "PIC" )) UsePIC = 1;
 212     /* ignore all other flags */
 213 }
 214
 215 static void do_define( const char *arg )
 216 {
 217     /* nothing */
 218 }
 219
 220 static void do_include( const char *arg )
 221 {
 222     /* nothing */
 223 }
 224
 225 static void do_k_flags( const char *arg )
 226 {
 227     /* Ignored, because cc generates correct code. */
 228     /* if (!strcmp( arg, "PIC" )) UsePIC = 1; */
 229     /* ignore all other flags */
 230 }
 231
 232 static void do_heap( const char *arg )
 233 {
 234     if (!isdigit(arg[0]))
 235         fatal_error( "Expected number argument with -H option instead of '%s'\n", arg );
 236     DLLHeapSize = atoi(arg);
 237     if (DLLHeapSize > 65535) fatal_error( "Invalid heap size %d, maximum is 65535\n", DLLHeapSize );
 238 }
 239
 240 static void do_name( const char *arg )
 241 {
 242     strncpy( DLLName, arg, sizeof(DLLName) );
 243     DLLName[sizeof(DLLName) - 1] = 0;
 244 }
 245
 246 static void do_entry( const char *arg )
 247 {
 248     init_func = xstrdup( arg );
 249 }
 250
 251 static void do_spec( const char *arg )
 252 {
 253     if (exec_mode != MODE_NONE || !arg[0]) do_usage();
 254     exec_mode = MODE_SPEC;
 255     input_file = open_input_file( NULL, arg );
 256     set_dll_file_name( arg );
 257 }
 258
 259 static void do_def( const char *arg )
 260 {
 261     if (exec_mode != MODE_NONE || !arg[0]) do_usage();
 262     exec_mode = MODE_DEF;
 263     input_file = open_input_file( NULL, arg );
 264     set_dll_file_name( arg );
 265 }
 266
 267 static void do_exe( const char *arg )
 268 {
 269     const char *p;
 270
 271     if (exec_mode != MODE_NONE || !arg[0]) do_usage();
 272     exec_mode = MODE_EXE;
 273     if ((p = strrchr( arg, '/' ))) p++;
 274     else p = arg;
 275     strcpy( DLLFileName, p );
 276     if (!strchr( DLLFileName, '.' )) strcat( DLLFileName, ".exe" );
 277     if (SpecMode == SPEC_MODE_DLL) SpecMode = SPEC_MODE_GUIEXE;
 278 }
 279
 280 static void do_exe_mode( const char *arg )
 281 {
 282     if (!strcmp( arg, "gui" )) SpecMode = SPEC_MODE_GUIEXE;
 283     else if (!strcmp( arg, "cui" )) SpecMode = SPEC_MODE_CUIEXE;
 284     else if (!strcmp( arg, "guiw" )) SpecMode = SPEC_MODE_GUIEXE_UNICODE;
 285     else if (!strcmp( arg, "cuiw" )) SpecMode = SPEC_MODE_CUIEXE_UNICODE;
 286     else do_usage();
 287 }
 288
 289 static void do_module( const char *arg )
 290 {
 291     strcpy( owner_name, arg );
 292     SpecType = SPEC_WIN16;
 293 }
 294
 295 static void do_glue(void)
 296 {
 297     if (exec_mode != MODE_NONE) do_usage();
 298     exec_mode = MODE_GLUE;
 299 }
 300
 301 static void do_debug(void)
 302 {
 303     if (exec_mode != MODE_NONE) do_usage();
 304     exec_mode = MODE_DEBUG;
 305 }
 306
 307 static void do_chdir( const char *arg )
 308 {
 309     current_src_dir = arg;
 310 }
 311
 312 static void do_relay16(void)
 313 {
 314     if (exec_mode != MODE_NONE) do_usage();
 315     exec_mode = MODE_RELAY16;
 316 }
 317
 318 static void do_relay32(void)
 319 {
 320     if (exec_mode != MODE_NONE) do_usage();
 321     exec_mode = MODE_RELAY32;
 322 }
 323
 324 static void do_lib( const char *arg )
 325 {
 326     lib_path = xrealloc( lib_path, (nb_lib_paths+1) * sizeof(*lib_path) );
 327     lib_path[nb_lib_paths++] = xstrdup( arg );
 328 }
 329
 330 static void do_import( const char *arg )
 331 {
 332     add_import_dll( arg, 0 );
 333 }
 334
 335 static void do_dimport( const char *arg )
 336 {
 337     add_import_dll( arg, 1 );
 338 }
 339
 340 static void do_rsrc( const char *arg )
 341 {
 342     res_files = xrealloc( res_files, (nb_res_files+1) * sizeof(*res_files) );
 343     res_files[nb_res_files++] = xstrdup( arg );
 344 }
 345
 346 /* parse options from the argv array and remove all the recognized ones */
 347 static void parse_options( char *argv[] )
 348 {
 349     const struct option_descr *opt;
 350     char **ptr, **last;
 351     const char* arg=NULL;
 352
 353     for (ptr = last = argv; *ptr; ptr++)
 354     {
 355         /* first check the exact option name */
 356         for (opt = option_table; opt->name; opt++)
 357         {
 358             if (!strcmp( *ptr, opt->name ) ||
 359                 /* for long option check without the first dash too */
 360                 (opt->name[1] == '-' && !strcmp( *ptr, opt->name+1 )))
 361             {
 362                 if (opt->has_arg) arg = *(++ptr);
 363                 else arg = NULL;
 364                 break;
 365             }
 366         }
 367
 368         /* now check for option name concatenated with argument */
 369         if (!opt->name)
 370         {
 371             for (opt = option_table; opt->name; opt++)
 372             {
 373                 if (opt->has_arg && !strncmp( *ptr, opt->name, strlen(opt->name) ))
 374                 {
 375                     arg = *ptr + strlen(opt->name);
 376                     break;
 377                 }
 378             }
 379         }
 380
 381         if (opt->name)
 382         {
 383             if (opt->has_arg && arg != NULL) opt->func( arg );
 384             else opt->func( "" );
 385         }
 386         else  /* keep this argument */
 387         {
 388             if (last != ptr) *last = *ptr;
 389             last++;
 390         }
 391     }
 392     *last = NULL;
 393 }
 394
 395
 396 /* load all specified resource files */
 397 static void load_resources( char *argv[] )
 398 {
 399     int i;
 400     char **ptr, **last;
 401
 402     switch (SpecType)
 403     {
 404     case SPEC_WIN16:
 405         for (i = 0; i < nb_res_files; i++) load_res16_file( res_files[i] );
 406         break;
 407
 408     case SPEC_WIN32:
 409         for (i = 0; i < nb_res_files; i++)
 410         {
 411             if (!load_res32_file( res_files[i] ))
 412                 fatal_error( "%s is not a valid Win32 resource file\n", res_files[i] );
 413         }
 414
 415         /* load any resource file found in the remaining arguments */
 416         for (ptr = last = argv; *ptr; ptr++)
 417         {
 418             if (!load_res32_file( *ptr ))
 419                 *last++ = *ptr; /* not a resource file, keep it in the list */
 420         }
 421         *last = NULL;
 422         break;
 423     }
 424 }
 425
 426 /*******************************************************************
 427  *         main
 428  */
 429 int main(int argc, char **argv)
 430 {
 431     output_file = stdout;
 432     parse_options( argv + 1 );
 433
 434     switch(exec_mode)
 435     {
 436     case MODE_SPEC:
 437         load_resources( argv + 1 );
 438         ParseTopLevel( input_file );
 439         switch (SpecType)
 440         {
 441             case SPEC_WIN16:
 442                 if (argv[1])
 443                     fatal_error( "file argument '%s' not allowed in this mode\n", argv[1] );
 444                 BuildSpec16File( output_file );
 445                 break;
 446             case SPEC_WIN32:
 447                 read_undef_symbols( argv + 1 );
 448                 BuildSpec32File( output_file );
 449                 break;
 450             default: assert(0);
 451         }
 452         break;
 453     case MODE_EXE:
 454         if (SpecType == SPEC_WIN16) fatal_error( "Cannot build 16-bit exe files\n" );
 455         load_resources( argv + 1 );
 456         read_undef_symbols( argv + 1 );
 457         BuildSpec32File( output_file );
 458         break;
 459     case MODE_DEF:
 460         if (argv[1]) fatal_error( "file argument '%s' not allowed in this mode\n", argv[1] );
 461         if (SpecType == SPEC_WIN16) fatal_error( "Cannot yet build .def file for 16-bit dlls\n" );
 462         ParseTopLevel( input_file );
 463         BuildDef32File( output_file );
 464         break;
 465     case MODE_DEBUG:
 466         BuildDebugFile( output_file, current_src_dir, argv + 1 );
 467         break;
 468     case MODE_GLUE:
 469         BuildGlue( output_file, current_src_dir, argv + 1 );
 470         break;
 471     case MODE_RELAY16:
 472         if (argv[1]) fatal_error( "file argument '%s' not allowed in this mode\n", argv[1] );
 473         BuildRelays16( output_file );
 474         break;
 475     case MODE_RELAY32:
 476         if (argv[1]) fatal_error( "file argument '%s' not allowed in this mode\n", argv[1] );
 477         BuildRelays32( output_file );
 478         break;
 479     default:
 480         do_usage();
 481         break;
 482     }
 483     if (output_file_name)
 484     {
 485         fclose( output_file );
 486         output_file_name = NULL;
 487     }
 488     return 0;
 489 }