git.oblomov.eu Git - wine/blob - tools/winemaker

   1 #!/usr/bin/perl -w
   2
   3 # Copyright 2000 Francois Gouget for CodeWeavers
   4 # fgouget@codeweavers.com
   5 #
   6 my $version="0.5.1";
   7
   8 use Cwd;
   9 use File::Basename;
  10 use File::Copy;
  11
  12
  13
  14 #####
  15 #
  16 # Options
  17 #
  18 #####
  19
  20 # The following constants define what we do with the case of filenames
  21
  22 ##
  23 # Never rename a file to lowercase
  24 my $OPT_LOWER_NONE=0;
  25
  26 ##
  27 # Rename all files to lowercase
  28 my $OPT_LOWER_ALL=1;
  29
  30 ##
  31 # Rename only files that are all uppercase to lowercase
  32 my $OPT_LOWER_UPPERCASE=2;
  33
  34
  35 # The following constants define whether to ask questions or not
  36
  37 ##
  38 # No (synonym of never)
  39 my $OPT_ASK_NO=0;
  40
  41 ##
  42 # Yes (always)
  43 my $OPT_ASK_YES=1;
  44
  45 ##
  46 # Skip the questions till the end of this scope
  47 my $OPT_ASK_SKIP=-1;
  48
  49
  50 # General options
  51
  52 ##
  53 # Make a backup of the files
  54 my $opt_backup;
  55
  56 ##
  57 # Defines which files to rename
  58 my $opt_lower;
  59
  60
  61 # Options for the 'Source' method
  62
  63 ##
  64 # Specifies that we have only one target so that all sources relate
  65 # to this target. By default this variable is left undefined which
  66 # means winemaker should try to find out by itself what the targets
  67 # are. If not undefined then this contains the name of the default
  68 # target (without the extension).
  69 my $opt_single_target;
  70
  71 ##
  72 # If '$opt_single_target' has been specified then this is the type of
  73 # that target. Otherwise it specifies whether the default target type
  74 # is guiexe or cuiexe.
  75 my $opt_target_type;
  76
  77 ##
  78 # Contains the default set of flags to be used when creating a new target.
  79 my $opt_flags;
  80
  81 ##
  82 # If true then winemaker should ask questions to the user as it goes
  83 # along.
  84 my $opt_is_interactive;
  85 my $opt_ask_project_options;
  86 my $opt_ask_target_options;
  87
  88 ##
  89 # If true then winemaker should not generate any file (mostly
  90 # makefiles, thus the name, but also .spec files, configure.in, etc.)
  91 my $opt_no_makefile;
  92
  93 ##
  94 # Specifies not to print the banner if set.
  95 my $opt_no_banner;
  96
  97
  98
  99 #####
 100 #
 101 # Target modelization
 102 #
 103 #####
 104
 105 # The description of a target is stored in an array. The constants
 106 # below identify what is stored at each index of the array.
 107
 108 ##
 109 # This is the name of the target.
 110 my $T_NAME=0;
 111
 112 ##
 113 # Defines the type of target we want to build. See the TT_xxx
 114 # constants below
 115 my $T_TYPE=1;
 116
 117 ##
 118 # Defines the target's enty point, i.e. the function that is called
 119 # on startup.
 120 my $T_INIT=2;
 121
 122 ##
 123 # This is a bitfield containing flags refining the way the target
 124 # should be handled. See the TF_xxx constants below
 125 my $T_FLAGS=12;
 126
 127 ##
 128 # This is a reference to an array containing the list of the
 129 # resp. C, C++, RC, other (.h, .hxx, etc.) source files.
 130 my $T_SOURCES_C=3;
 131 my $T_SOURCES_CXX=4;
 132 my $T_SOURCES_RC=5;
 133 my $T_SOURCES_MISC=6;
 134
 135 ##
 136 # This is a reference to an array containing the list of macro
 137 # definitions
 138 my $T_DEFINES=7;
 139
 140 ##
 141 # This is a reference to an array containing the list of directory
 142 # names that constitute the include path
 143 my $T_INCLUDE_PATH=8;
 144
 145 ##
 146 # Same as T_INCLUDE_PATH but for the library search path
 147 my $T_LIBRARY_PATH=9;
 148
 149 ##
 150 # The list of libraries to link with
 151 my $T_IMPORTS=10;
 152
 153 ##
 154 # The list of dependencies between targets
 155 my $T_DEPENDS=11;
 156
 157
 158 # The following constants define the recognized types of target
 159
 160 ##
 161 # This is not a real target. This type of target is used to collect
 162 # the sources that don't seem to belong to any other target. Thus no
 163 # real target is generated for them, we just put the sources of the
 164 # fake target in the global source list.
 165 my $TT_SETTINGS=0;
 166
 167 ##
 168 # For executables in the windows subsystem
 169 my $TT_GUIEXE=1;
 170
 171 ##
 172 # For executables in the console subsystem
 173 my $TT_CUIEXE=2;
 174
 175 ##
 176 # For dynamically linked libraries
 177 my $TT_DLL=3;
 178
 179
 180 # The following constants further refine how the target should be handled
 181
 182 ##
 183 # This target needs a wrapper
 184 my $TF_WRAP=1;
 185
 186 ##
 187 # This target is a wrapper
 188 my $TF_WRAPPER=2;
 189
 190 ##
 191 # This target is an MFC-based target
 192 my $TF_MFC=4;
 193
 194 ##
 195 # Initialize a target:
 196 # - set the target type to TT_SETTINGS, i.e. no real target will
 197 #   be generated.
 198 sub target_init
 199 {
 200   my $target=$_[0];
 201
 202   @$target[$T_TYPE]=$TT_SETTINGS;
 203   # leaving $T_INIT undefined
 204   @$target[$T_FLAGS]=$opt_flags;
 205   @$target[$T_SOURCES_C]=[];
 206   @$target[$T_SOURCES_CXX]=[];
 207   @$target[$T_SOURCES_RC]=[];
 208   @$target[$T_SOURCES_MISC]=[];
 209   @$target[$T_DEFINES]=[];
 210   @$target[$T_INCLUDE_PATH]=[];
 211   @$target[$T_LIBRARY_PATH]=[];
 212   @$target[$T_IMPORTS]=[];
 213   @$target[$T_DEPENDS]=[];
 214 }
 215
 216 sub get_default_init
 217 {
 218   my $type=$_[0];
 219   if ($type == $TT_GUIEXE) {
 220     return "WinMain";
 221   } elsif ($type == $TT_CUIEXE) {
 222     return "main";
 223   } elsif ($type == $TT_DLL) {
 224     return "DllMain";
 225   }
 226 }
 227
 228
 229
 230 #####
 231 #
 232 # Project modelization
 233 #
 234 #####
 235
 236 # First we have the notion of project. A project is described by an
 237 # array (since we don't have structs in perl). The constants below
 238 # identify what is stored at each index of the array.
 239
 240 ##
 241 # This is the path in which this project is located. In other
 242 # words, this is the path to  the Makefile.
 243 my $P_PATH=0;
 244
 245 ##
 246 # This index contains a reference to an array containing the project-wide
 247 # settings. The structure of that arrray is actually identical to that of
 248 # a regular target since it can also contain extra sources.
 249 my $P_SETTINGS=1;
 250
 251 ##
 252 # This index contains a reference to an array of targets for this
 253 # project. Each target describes how an executable or library is to
 254 # be built. For each target this description takes the same form as
 255 # that of the project: an array. So this entry is an array of arrays.
 256 my $P_TARGETS=2;
 257
 258 ##
 259 # Initialize a project:
 260 # - set the project's path
 261 # - initialize the target list
 262 # - create a default target (will be removed later if unnecessary)
 263 sub project_init
 264 {
 265   my $project=$_[0];
 266   my $path=$_[1];
 267
 268   my $project_settings=[];
 269   target_init($project_settings);
 270
 271   @$project[$P_PATH]=$path;
 272   @$project[$P_SETTINGS]=$project_settings;
 273   @$project[$P_TARGETS]=[];
 274 }
 275
 276
 277
 278 #####
 279 #
 280 # Global variables
 281 #
 282 #####
 283
 284 my $usage;
 285 my %warnings;
 286
 287 my %templates;
 288
 289 ##
 290 # Contains the list of all projects. This list tells us what are
 291 # the subprojects of the main Makefile and where we have to generate
 292 # Makefiles.
 293 my @projects=();
 294
 295 ##
 296 # This is the main project, i.e. the one in the "." directory.
 297 # It may well be empty in which case the main Makefile will only
 298 # call out subprojects.
 299 my @main_project;
 300
 301 ##
 302 # Contains the defaults for the include path, etc.
 303 # We store the defaults as if this were a target except that we only
 304 # exploit the defines, include path, library path, library list and misc
 305 # sources fields.
 306 my @global_settings;
 307
 308 ##
 309 # If one of the projects requires the MFc then we set this global variable
 310 # to true so that configure asks the user to provide a path tothe MFC
 311 my $needs_mfc=0;
 312
 313
 314
 315 #####
 316 #
 317 # Utility functions
 318 #
 319 #####
 320
 321 ##
 322 # Cleans up a name to make it an acceptable Makefile
 323 # variable name.
 324 sub canonize
 325 {
 326   my $name=$_[0];
 327
 328   $name =~ tr/a-zA-Z0-9_/_/c;
 329   return $name;
 330 }
 331
 332 ##
 333 # Returns true is the specified pathname is absolute.
 334 # Note: pathnames that start with a variable '$' or
 335 # '~' are considered absolute.
 336 sub is_absolute
 337 {
 338   my $path=$_[0];
 339
 340   return ($path =~ /^[\/~\$]/);
 341 }
 342
 343 ##
 344 # Performs a binary search looking for the specified item
 345 sub bsearch
 346 {
 347   my $array=$_[0];
 348   my $item=$_[1];
 349   my $last=@{$array}-1;
 350   my $first=0;
 351
 352   while ($first<=$last) {
 353     my $index=int(($first+$last)/2);
 354     my $cmp=@$array[$index] cmp $item;
 355     if ($cmp<0) {
 356       $first=$index+1;
 357     } elsif ($cmp>0) {
 358       $last=$index-1;
 359     } else {
 360       return $index;
 361     }
 362   }
 363 }
 364
 365
 366
 367 #####
 368 #
 369 # 'Source'-based Project analysis
 370 #
 371 #####
 372
 373 ##
 374 # Allows the user to specify makefile and target specific options
 375 # - target: the structure in which to store the results
 376 # - options: the string containing the options
 377 sub source_set_options
 378 {
 379   my $target=$_[0];
 380   my $options=$_[1];
 381
 382   #FIXME: we must deal with escaping of stuff and all
 383   foreach $option (split / /,$options) {
 384     if (@$target[$T_TYPE] == $TT_SETTINGS and $option =~ /^-D/) {
 385       push @{@$target[$T_DEFINES]},$option;
 386     } elsif (@$target[$T_TYPE] == $TT_SETTINGS and $option =~ /^-I/) {
 387       push @{@$target[$T_INCLUDE_PATH]},$option;
 388     } elsif ($option =~ /^-L/) {
 389       push @{@$target[$T_LIBRARY_PATH]},$option;
 390     } elsif ($option =~ /^-l/) {
 391       push @{@$target[$T_IMPORTS]},$';
 392     } elsif (@$target[$T_TYPE] != $TT_SETTINGS and
 393              @$target[$T_TYPE] != $TT_DLL and
 394              $option =~ /^--wrap/) {
 395       @$target[$T_FLAGS]|=$TF_WRAP;
 396     } elsif (@$target[$T_TYPE] != $TT_SETTINGS and $option =~ /^--mfc/) {
 397       @$target[$T_FLAGS]|=$TF_MFC;
 398       if (@$target[$T_TYPE] != $TT_DLL) {
 399         @$target[$T_FLAGS]|=$TF_WRAP;
 400       }
 401     } else {
 402       print STDERR "warning: unknown option \"$option\", ignoring it\n";
 403     }
 404   }
 405 }
 406
 407 ##
 408 # Scans the specified directory to:
 409 # - see if we should create a Makefile in this directory. We normally do
 410 #   so if we find a project file and sources
 411 # - get a list of targets for this directory
 412 # - get the list of source files
 413 sub source_scan_directory
 414 {
 415   # a reference to the parent's project
 416   my $parent_project=$_[0];
 417   # the full relative path to the current directory, including a
 418   # trailing '/', or an empty string if this is the top level directory
 419   my $path=$_[1];
 420   # the name of this directory, including a trailing '/', or an empty
 421   # string if this is the top level directory
 422   my $dirname=$_[2];
 423
 424   # reference to the project for this directory. May not be used
 425   my $project;
 426   # list of targets found in the 'current' directory
 427   my %targets;
 428   # list of sources found in the current directory
 429   my @sources_c=();
 430   my @sources_cxx=();
 431   my @sources_rc=();
 432   my @sources_misc=();
 433   # true if this directory contains a Windows project
 434   my $has_win_project=0;
 435   # If we don't find any executable/library then we might make up targets
 436   # from the list of .dsp/.mak files we find since they usually have the
 437   # same name as their target.
 438   my @dsp_files=();
 439   my @mak_files=();
 440
 441   if (defined $opt_single_target or $dirname eq "") {
 442     # Either there is a single target and thus a single project,
 443     # or we are in the top level directory for which a project
 444     # already exists
 445     $project=$parent_project;
 446   } else {
 447     $project=[];
 448     project_init($project,$path);
 449   }
 450
 451   # First find out what this directory contains:
 452   # collect all sources, targets and subdirectories
 453   my $directory=get_directory_contents($path);
 454   foreach $dentry (@$directory) {
 455     if ($dentry =~ /^\./) {
 456       next;
 457     }
 458     my $fullentry="$path$dentry";
 459     if (-d "$fullentry") {
 460       if ($dentry =~ /^(Release|Debug)/i) {
 461         # These directories are often used to store the object files and the
 462         # resulting executable/library. They should not contain anything else.
 463         my @candidates=grep /\.(exe|dll)$/i, @{get_directory_contents("$fullentry")};
 464         foreach $candidate (@candidates) {
 465           if ($candidate =~ s/\.exe$//i) {
 466             $targets{$candidate}=1;
 467           } elsif ($candidate =~ s/^(.*)\.dll$/lib$1.so/i) {
 468             $targets{$candidate}=1;
 469           }
 470         }
 471       } else {
 472         # Recursively scan this directory. Any source file that cannot be
 473         # attributed to a project in one of the subdirectories will be attributed
 474         # to this project.
 475         source_scan_directory($project,"$fullentry/","$dentry/");
 476       }
 477     } elsif (-f "$fullentry") {
 478       if ($dentry =~ s/\.exe$//i) {
 479         $targets{$dentry}=1;
 480       } elsif ($dentry =~ s/^(.*)\.dll$/lib$1.so/i) {
 481         $targets{$dentry}=1;
 482       } elsif ($dentry =~ /\.c$/i and $dentry !~ /\.spec\.c$/) {
 483         push @sources_c,"$dentry";
 484       } elsif ($dentry =~ /\.(cpp|cxx)$/i) {
 485         push @sources_cxx,"$dentry";
 486       } elsif ($dentry =~ /\.rc$/i) {
 487         push @sources_rc,"$dentry";
 488       } elsif ($dentry =~ /\.(h|hxx|inl|rc2|dlg)$/i) {
 489         push @sources_misc,"$dentry";
 490       } elsif ($dentry =~ /\.dsp$/i) {
 491         push @dsp_files,"$dentry";
 492         $has_win_project=1;
 493       } elsif ($dentry =~ /\.mak$/i) {
 494         push @mak_files,"$dentry";
 495         $has_win_project=1;
 496       } elsif ($dentry =~ /^makefile/i) {
 497         $has_win_project=1;
 498       }
 499     }
 500   }
 501   closedir(DIRECTORY);
 502
 503   # If we have a single target then all we have to do is assign
 504   # all the sources to it and we're done
 505   # FIXME: does this play well with the --interactive mode?
 506   if ($opt_single_target) {
 507     my $target=@{@$project[$P_TARGETS]}[0];
 508     push @{@$target[$T_SOURCES_C]},map "$path$_",@sources_c;
 509     push @{@$target[$T_SOURCES_CXX]},map "$path$_",@sources_cxx;
 510     push @{@$target[$T_SOURCES_RC]},map "$path$_",@sources_rc;
 511     push @{@$target[$T_SOURCES_MISC]},map "$path$_",@sources_misc;
 512     return;
 513   }
 514
 515   my $project_settings=@$project[$P_SETTINGS];
 516   my $source_count=@sources_c+@sources_cxx+@sources_rc+
 517                    @{@$project_settings[$T_SOURCES_C]}+
 518                    @{@$project_settings[$T_SOURCES_CXX]}+
 519                    @{@$project_settings[$T_SOURCES_RC]};
 520   if ($source_count == 0) {
 521     # A project without real sources is not a project, get out!
 522     if ($project!=$parent_project) {
 523       $parent_settings=@$parent_project[$P_SETTINGS];
 524       push @{@$parent_settings[$T_SOURCES_MISC]},map "$dirname$_",@sources_misc;
 525       push @{@$parent_settings[$T_SOURCES_MISC]},map "$dirname$_",@{@$project_settings[$T_SOURCES_MISC]};
 526     }
 527     return;
 528   }
 529   #print "targets=",%targets,"\n";
 530   #print "target_count=$target_count\n";
 531   #print "has_win_project=$has_win_project\n";
 532   #print "dirname=$dirname\n";
 533
 534   my $target_count;
 535   if (($has_win_project != 0) or ($dirname eq "")) {
 536     # Deal with cases where we could not find any executable/library, and
 537     # thus have no target, although we did find some sort of windows project.
 538     $target_count=keys %targets;
 539     if ($target_count == 0) {
 540       # Try to come up with a target list based on .dsp/.mak files
 541       my $prj_list;
 542       if (@dsp_files > 0) {
 543         $prj_list=\@dsp_files;
 544       } else {
 545         $prj_list=\@mak_files;
 546       }
 547       foreach $filename (@$prj_list) {
 548         $filename =~ s/\.(dsp|mak)$//i;
 549         if ($opt_target_type == $TT_DLL) {
 550           $filename = "lib$filename.so";
 551         }
 552         $targets{$filename}=1;
 553       }
 554       $target_count=keys %targets;
 555       if ($target_count == 0) {
 556         # Still nothing, try the name of the directory
 557         my $name;
 558         if ($dirname eq "") {
 559           # Bad luck, this is the top level directory!
 560           $name=(split /\//, cwd)[-1];
 561         } else {
 562           $name=$dirname;
 563           # Remove the trailing '/'. Also eliminate whatever is after the last
 564           # '.' as it is likely to be meaningless (.orig, .new, ...)
 565           $name =~ s+(/|\.[^.]*)$++;
 566           if ($name eq "src") {
 567             # 'src' is probably a subdirectory of the real project directory.
 568             # Try again with the parent (if any).
 569             my $parent=$path;
 570             if ($parent =~ s+([^/]*)/[^/]*/$+$1+) {
 571               $name=$parent;
 572             } else {
 573               $name=(split /\//, cwd)[-1];
 574             }
 575           }
 576         }
 577         $name =~ s+(/|\.[^.]*)$++;
 578         if ($opt_target_type == $TT_DLL) {
 579           $name = "lib$name.so";
 580         }
 581         $targets{$name}=1;
 582       }
 583     }
 584
 585     # Ask confirmation to the user if he wishes so
 586     if ($opt_is_interactive == $OPT_ASK_YES) {
 587       my $target_list=join " ",keys %targets;
 588       print "\n*** In $path\n";
 589       print "winemaker found the following list of (potential) targets\n";
 590       print "$target_list\n";
 591       print "Type enter to use it as is, your own comma-separated list of\n";
 592       print "targets, 'none' to assign the source files to a parent directory,\n";
 593       print "or 'ignore' to ignore everything in this directory tree.\n";
 594       print "Target list:\n";
 595       $target_list=<STDIN>;
 596       chomp $target_list;
 597       if ($target_list eq "") {
 598         # Keep the target list as is, i.e. do nothing
 599       } elsif ($target_list eq "none") {
 600         # Empty the target list
 601         undef %targets;
 602       } elsif ($target_list eq "ignore") {
 603         # Ignore this subtree altogether
 604         return;
 605       } else {
 606         undef %targets;
 607         foreach $target (split /,/,$target_list) {
 608           $target =~ s+^\s*++;
 609           $target =~ s+\s*$++;
 610           # Also accept .exe and .dll as a courtesy
 611           $target =~ s+(.*)\.dll$+lib$1.so+;
 612           $target =~ s+\.exe$++;
 613           $targets{$target}=1;
 614         }
 615       }
 616     }
 617   }
 618
 619   # If we have no project at this level, then transfer all
 620   # the sources to the parent project
 621   $target_count=keys %targets;
 622   if ($target_count == 0) {
 623     if ($project!=$parent_project) {
 624       my $parent_settings=@$parent_project[$P_SETTINGS];
 625       push @{@$parent_settings[$T_SOURCES_C]},map "$dirname$_",@sources_c;
 626       push @{@$parent_settings[$T_SOURCES_CXX]},map "$dirname$_",@sources_cxx;
 627       push @{@$parent_settings[$T_SOURCES_RC]},map "$dirname$_",@sources_rc;
 628       push @{@$parent_settings[$T_SOURCES_MISC]},map "$dirname$_",@sources_misc;
 629       push @{@$parent_settings[$T_SOURCES_MISC]},map "$dirname$_",@{@$project_settings[$T_SOURCES_MISC]};
 630     }
 631     return;
 632   }
 633
 634   # Otherwise add this project to the project list, except for
 635   # the main project which is already in the list.
 636   if ($dirname ne "") {
 637     push @projects,$project;
 638   }
 639
 640   # Ask for project-wide options
 641   if ($opt_ask_project_options == $OPT_ASK_YES) {
 642     print "Type any project-wide options (-D/-I/-L/-l),\n";
 643     print "or 'skip' to skip the target specific options, or 'never' to not be\n";
 644     print "asked this question again:\n";
 645     my $options=<STDIN>;
 646     chomp $options;
 647     if ($options eq "skip") {
 648       $opt_ask_target_options=$OPT_ASK_SKIP;
 649     } elsif ($options eq "never") {
 650       $opt_ask_project_options="never";
 651     } else {
 652       source_set_options($project_settings,$options);
 653     }
 654   }
 655
 656   # - Create the targets
 657   # - Check if we have both libraries and programs
 658   # - Match each target with source files (sort in reverse
 659   #   alphabetical order to get the longest matches first)
 660   my @local_imports=();
 661   my @local_depends=();
 662   my @program_list=();
 663   foreach $target_name (sort { $b cmp $a } keys %targets) {
 664     # Create the target...
 665     my $basename;
 666     my $target=[];
 667     target_init($target);
 668     @$target[$T_NAME]=$target_name;
 669     if ($target_name =~ /^lib(.*)\.so$/) {
 670       @$target[$T_TYPE]=$TT_DLL;
 671       @$target[$T_INIT]=get_default_init($TT_DLL);
 672       @$target[$T_FLAGS]&=~$TF_WRAP;
 673       $basename=$1;
 674       push @local_depends,$target_name;
 675       push @local_imports,$basename;
 676     } else {
 677       @$target[$T_TYPE]=$opt_target_type;
 678       @$target[$T_INIT]=get_default_init($opt_target_type);
 679       $basename=$target_name;
 680       push @program_list,$target;
 681     }
 682     push @{@$project[$P_TARGETS]},$target;
 683
 684     # Ask for target-specific options
 685     if ($opt_ask_target_options == $OPT_ASK_YES) {
 686       print "Specify any link option (-L/-l) specific to the target \"$target_name\"\n";
 687       print " or 'never' to not be asked this question again:\n";
 688       my $options=<STDIN>;
 689       chomp $options;
 690       if ($options eq "never") {
 691         $opt_ask_target_options=$OPT_ASK_NO;
 692       } else {
 693         source_set_options($target,$options);
 694       }
 695     }
 696     if (@$target[$T_FLAGS] & $TF_MFC) {
 697       @$project_settings[$T_FLAGS]|=$TF_MFC;
 698       push @{@$target[$T_LIBRARY_PATH]},"\$(MFC_LIBRARY_PATH)";
 699       push @{@$target[$T_IMPORTS]},"mfc";
 700     }
 701
 702     # Match sources...
 703     if ($target_count == 1) {
 704       push @{@$target[$T_SOURCES_C]},@sources_c;
 705       push @{@$target[$T_SOURCES_CXX]},@sources_cxx;
 706       push @{@$target[$T_SOURCES_RC]},@sources_rc;
 707       push @{@$target[$T_SOURCES_MISC]},@sources_misc;
 708       @sources_c=();
 709       @sources_cxx=();
 710       @sources_rc=();
 711       @sources_misc=();
 712     } else {
 713       foreach $source (@sources_c) {
 714         if ($source =~ /^$basename/i) {
 715           push @{@$target[$T_SOURCES_C]},$source;
 716           $source="";
 717         }
 718       }
 719       foreach $source (@sources_cxx) {
 720         if ($source =~ /^$basename/i) {
 721           push @{@$target[$T_SOURCES_CXX]},$source;
 722           $source="";
 723         }
 724       }
 725       foreach $source (@sources_rc) {
 726         if ($source =~ /^$basename/i) {
 727           push @{@$target[$T_SOURCES_RC]},$source;
 728           $source="";
 729         }
 730       }
 731       foreach $source (@sources_misc) {
 732         if ($source =~ /^$basename/i) {
 733           push @{@$target[$T_SOURCES_MISC]},$source;
 734           $source="";
 735         }
 736       }
 737     }
 738     @$target[$T_SOURCES_C]=[sort @{@$target[$T_SOURCES_C]}];
 739     @$target[$T_SOURCES_CXX]=[sort @{@$target[$T_SOURCES_CXX]}];
 740     @$target[$T_SOURCES_RC]=[sort @{@$target[$T_SOURCES_RC]}];
 741     @$target[$T_SOURCES_MISC]=[sort @{@$target[$T_SOURCES_MISC]}];
 742   }
 743   if ($opt_ask_target_options == $OPT_ASK_SKIP) {
 744     $opt_ask_target_options=$OPT_ASK_YES;
 745   }
 746
 747   if (@$project_settings[$T_FLAGS] & $TF_MFC) {
 748     push @{@$project_settings[$T_INCLUDE_PATH]},"\$(MFC_INCLUDE_PATH)";
 749   }
 750   # The sources that did not match, if any, go to the extra
 751   # source list of the project settings
 752   foreach $source (@sources_c) {
 753     if ($source ne "") {
 754       push @{@$project_settings[$T_SOURCES_C]},$source;
 755     }
 756   }
 757   @$project_settings[$T_SOURCES_C]=[sort @{@$project_settings[$T_SOURCES_C]}];
 758   foreach $source (@sources_cxx) {
 759     if ($source ne "") {
 760       push @{@$project_settings[$T_SOURCES_CXX]},$source;
 761     }
 762   }
 763   @$project_settings[$T_SOURCES_CXX]=[sort @{@$project_settings[$T_SOURCES_CXX]}];
 764   foreach $source (@sources_rc) {
 765     if ($source ne "") {
 766       push @{@$project_settings[$T_SOURCES_RC]},$source;
 767     }
 768   }
 769   @$project_settings[$T_SOURCES_RC]=[sort @{@$project_settings[$T_SOURCES_RC]}];
 770   foreach $source (@sources_misc) {
 771     if ($source ne "") {
 772       push @{@$project_settings[$T_SOURCES_MISC]},$source;
 773     }
 774   }
 775   @$project_settings[$T_SOURCES_MISC]=[sort @{@$project_settings[$T_SOURCES_MISC]}];
 776
 777   # Finally if we are building both libraries and programs in
 778   # this directory, then the programs should be linked with all
 779   # the libraries
 780   if (@local_imports > 0 and @program_list > 0) {
 781     foreach $target (@program_list) {
 782       push @{@$target[$T_LIBRARY_PATH]},".";
 783       push @{@$target[$T_IMPORTS]},@local_imports;
 784       push @{@$target[$T_DEPENDS]},@local_depends;
 785     }
 786   }
 787 }
 788
 789 ##
 790 # Scan the source directories in search of things to build
 791 sub source_scan
 792 {
 793   my $main_target=@{$main_project[$P_TARGETS]}[0];
 794
 795   # If there's a single target then this is going to be the default target
 796   if (defined $opt_single_target) {
 797     if ($opt_target_type == $TT_DLL) {
 798       @$main_target[$T_NAME]="lib$opt_single_target.so";
 799     } else {
 800       @$main_target[$T_NAME]="$opt_single_target";
 801     }
 802     @$main_target[$T_TYPE]=$opt_target_type;
 803   }
 804
 805   # The main directory is always going to be there
 806   push @projects,\@main_project;
 807
 808   # Now scan the directory tree looking for source files and, maybe, targets
 809   print "Scanning the source directories...\n";
 810   source_scan_directory(\@main_project,"","");
 811
 812   @projects=sort { @$a[$P_PATH] cmp @$b[$P_PATH] } @projects;
 813 }
 814
 815
 816
 817 #####
 818 #
 819 # 'vc.dsp'-based Project analysis
 820 #
 821 #####
 822
 823 #sub analyze_vc_dsp
 824 #{
 825 #
 826 #}
 827
 828
 829
 830 #####
 831 #
 832 # Creating the wrapper targets
 833 #
 834 #####
 835
 836 sub create_wrappers
 837 {
 838   foreach $project (@projects) {
 839     foreach $target (@{@$project[$P_TARGETS]}) {
 840       if ((@$target[$T_FLAGS] & $TF_WRAP) != 0) {
 841         my $wrapper=[];
 842         target_init($wrapper);
 843         @$wrapper[$T_NAME]=@$target[$T_NAME];
 844         @$wrapper[$T_TYPE]=@$target[$T_TYPE];
 845         @$wrapper[$T_INIT]=get_default_init(@$target[$T_TYPE]);
 846         @$wrapper[$T_FLAGS]=$TF_WRAPPER | (@$target[$T_FLAGS] & $TF_MFC);
 847         push @{@$wrapper[$T_SOURCES_C]},"@$wrapper[$T_NAME]_wrapper.c";
 848
 849         my $index=bsearch(@$target[$T_SOURCES_C],"@$wrapper[$T_NAME]_wrapper.c");
 850         if (defined $index) {
 851           splice(@{@$target[$T_SOURCES_C]},$index,1);
 852         }
 853         @$target[$T_NAME]="lib@$target[$T_NAME].so";
 854         @$target[$T_TYPE]=$TT_DLL;
 855
 856         push @{@$project[$P_TARGETS]},$wrapper;
 857       }
 858     }
 859   }
 860 }
 861
 862
 863
 864 #####
 865 #
 866 # Source search
 867 #
 868 #####
 869
 870 ##
 871 # Performs a directory traversal and renames the files so that:
 872 # - they have the case desired by the user
 873 # - their extension is of the appropriate case
 874 # - they don't contain annoying characters like ' ', '$', '#', ...
 875 sub fix_file_and_directory_names
 876 {
 877   my $dirname=$_[0];
 878
 879   if (opendir(DIRECTORY, "$dirname")) {
 880     foreach $dentry (readdir DIRECTORY) {
 881       if ($dentry =~ /^\./ or $dentry eq "CVS") {
 882         next;
 883       }
 884       # Set $warn to 1 if the user should be warned of the renaming
 885       my $warn=0;
 886
 887       # autoconf and make don't support these characters well
 888       my $new_name=$dentry;
 889       $new_name =~ s/[ \$]/_/g;
 890
 891       # Our Make.rules supports all-uppercase and all-lowercase extensions.
 892       # The others must be fixed.
 893       if (-f "$dirname/$new_name") {
 894         if ($new_name =~ /\.cpp/i and $new_name !~ /\.(cpp|CPP)/) {
 895           $new_name =~ s/\.cpp$/.cpp/i;
 896         }
 897         if ($new_name =~ s/\.cxx$/.cpp/i) {
 898           $warn=1;
 899         }
 900         if ($new_name =~ /\.rc/i and $new_name !~ /\.(rc|RC)/) {
 901           $new_name =~ s/\.rc$/.rc/i;
 902         }
 903         # And this last one is to avoid confusion then running make
 904         if ($new_name =~ s/^makefile$/makefile.win/) {
 905           $warn=1;
 906         }
 907       }
 908
 909       # Adjust the case to the user's preferences
 910       if (($opt_lower == $OPT_LOWER_ALL and $dentry =~ /[A-Z]/) or
 911           ($opt_lower == $OPT_LOWER_UPPERCASE and $dentry !~ /[a-z]/)
 912          ) {
 913         $new_name=lc $new_name;
 914       }
 915
 916       # And finally, perform the renaming
 917       if ($new_name ne $dentry) {
 918         if ($warn) {
 919           print STDERR "warning: in \"$dirname\", renaming \"$dentry\" to \"$new_name\"\n";
 920         }
 921         if (!rename("$dirname/$dentry","$dirname/$new_name")) {
 922           print STDERR "error: in \"$dirname\", unable to rename \"$dentry\" to \"$new_name\"\n";
 923           print STDERR "       $!\n";
 924           $new_name=$dentry;
 925         }
 926       }
 927       if (-d "$dirname/$new_name") {
 928         fix_file_and_directory_names("$dirname/$new_name");
 929       }
 930     }
 931     closedir(DIRECTORY);
 932   }
 933 }
 934
 935
 936
 937 #####
 938 #
 939 # Source fixup
 940 #
 941 #####
 942
 943 ##
 944 # This maps a directory name to a reference to an array listing
 945 # its contents (files and directories)
 946 my %directories;
 947
 948 ##
 949 # Retrieves the contents of the specified directory.
 950 # We either get it from the directories hashtable which acts as a
 951 # cache, or use opendir, readdir, closedir and store the result
 952 # in the hashtable.
 953 sub get_directory_contents
 954 {
 955   my $dirname=$_[0];
 956   my $directory;
 957
 958   #print "getting the contents of $dirname\n";
 959
 960   # check for a cached version
 961   $dirname =~ s+/$++;
 962   if ($dirname eq "") {
 963     $dirname=cwd;
 964   }
 965   $directory=$directories{$dirname};
 966   if (defined $directory) {
 967     #print "->@$directory\n";
 968     return $directory;
 969   }
 970
 971   # Read this directory
 972   if (opendir(DIRECTORY, "$dirname")) {
 973     my @files=readdir DIRECTORY;
 974     closedir(DIRECTORY);
 975     $directory=\@files;
 976   } else {
 977     # Return an empty list
 978     #print "error: cannot open $dirname\n";
 979     my @files;
 980     $directory=\@files;
 981   }
 982   #print "->@$directory\n";
 983   $directories{$dirname}=$directory;
 984   return $directory;
 985 }
 986
 987 ##
 988 # Try to find a file for the specified filename. The attempt is
 989 # case-insensitive which is why it's not trivial. If a match is
 990 # found then we return the pathname with the correct case.
 991 sub search_from
 992 {
 993   my $dirname=$_[0];
 994   my $path=$_[1];
 995   my $real_path="";
 996
 997   if ($dirname eq "" or $dirname eq ".") {
 998     $dirname=cwd;
 999   } elsif ($dirname =~ m+^[^/]+) {
1000     $dirname=cwd . "/" . $dirname;
1001   }
1002   if ($dirname !~ m+/$+) {
1003     $dirname.="/";
1004   }
1005
1006   foreach $component (@$path) {
1007     #print "    looking for $component in \"$dirname\"\n";
1008     if ($component eq ".") {
1009       # Pass it as is
1010       $real_path.="./";
1011     } elsif ($component eq "..") {
1012       # Go up one level
1013       $dirname=dirname($dirname) . "/";
1014       $real_path.="../";
1015     } else {
1016       my $directory=get_directory_contents $dirname;
1017       my $found;
1018       foreach $dentry (@$directory) {
1019         if ($dentry =~ /^$component$/i) {
1020           $dirname.="$dentry/";
1021           $real_path.="$dentry/";
1022           $found=1;
1023           last;
1024         }
1025       }
1026       if (!defined $found) {
1027         # Give up
1028         #print "    could not find $component in $dirname\n";
1029         return;
1030       }
1031     }
1032   }
1033   $real_path=~ s+/$++;
1034   #print "    -> found $real_path\n";
1035   return $real_path;
1036 }
1037
1038 ##
1039 # Performs a case-insensitive search for the specified file in the
1040 # include path.
1041 # $line is the line number that should be referenced when an error occurs
1042 # $filename is the file we are looking for
1043 # $dirname is the directory of the file containing the '#include' directive
1044 #    if '"' was used, it is an empty string otherwise
1045 # $project and $target specify part of the include path
1046 sub get_real_include_name
1047 {
1048   my $line=$_[0];
1049   my $filename=$_[1];
1050   my $dirname=$_[2];
1051   my $project=$_[3];
1052   my $target=$_[4];
1053
1054   if ($filename =~ /^([a-zA-Z]:)?[\/]/ or $filename =~ /^[a-zA-Z]:[\/]?/) {
1055     # This is not a relative path, we cannot make any check
1056     my $warning="path:$filename";
1057     if (!defined $warnings{$warning}) {
1058       $warnings{$warning}="1";
1059       print STDERR "warning: cannot check the case of absolute pathnames:\n";
1060       print STDERR "$line:   $filename\n";
1061     }
1062   } else {
1063     # Here's how we proceed:
1064     # - split the filename we look for into its components
1065     # - then for each directory in the include path
1066     #   - trace the directory components starting from that directory
1067     #   - if we fail to find a match at any point then continue with
1068     #     the next directory in the include path
1069     #   - otherwise, rejoice, our quest is over.
1070     my @file_components=split /[\/\\]+/, $filename;
1071     #print "  Searching for $filename from @$project[$P_PATH]\n";
1072
1073     my $real_filename;
1074     if ($dirname ne "") {
1075       # This is an 'include ""' -> look in dirname first.
1076       #print "    in $dirname (include \"\")\n";
1077       $real_filename=search_from($dirname,\@file_components);
1078       if (defined $real_filename) {
1079         return $real_filename;
1080       }
1081     }
1082     my $project_settings=@$project[$P_SETTINGS];
1083     foreach $include (@{@$target[$T_INCLUDE_PATH]}, @{@$project_settings[$T_INCLUDE_PATH]}) {
1084       my $dirname=$include;
1085       $dirname=~ s+^-I++;
1086       if (!is_absolute($dirname)) {
1087         $dirname="@$project[$P_PATH]$dirname";
1088       } else {
1089         $dirname=~ s+^\$\(TOPSRCDIR\)/++;
1090       }
1091       #print "    in $dirname\n";
1092       $real_filename=search_from("$dirname",\@file_components);
1093       if (defined $real_filename) {
1094         return $real_filename;
1095       }
1096     }
1097     my $dotdotpath=@$project[$P_PATH];
1098     $dotdotpath =~ s/[^\/]+/../g;
1099     foreach $include (@{$global_settings[$T_INCLUDE_PATH]}) {
1100       my $dirname=$include;
1101       $dirname=~ s+^-I++;
1102       $dirname=~ s+^\$\(TOPSRCDIR\)\/++;
1103       #print "    in $dirname  (global setting)\n";
1104       $real_filename=search_from("$dirname",\@file_components);
1105       if (defined $real_filename) {
1106         return $real_filename;
1107       }
1108     }
1109   }
1110   $filename =~ s+\\\\+/+g; # in include ""
1111   $filename =~ s+\\+/+g; # in include <> !
1112   if ($filename =~ /^[A-Z_.\/\\]*$/) {
1113     #FIXME: should this depend on --lower-uppercase & co???
1114     return lc "$filename";
1115   }
1116   return $filename;
1117 }
1118
1119 ##
1120 # 'Parses' a source file and fixes constructs that would not work with
1121 # Winelib. The parsing is rather simple and not all non-portable features
1122 # are corrected. The most important feature that is corrected is the case
1123 # and path separator of '#include' directives. This requires that each
1124 # source file be associated to a project & target so that the proper
1125 # include path is used.
1126 # Also note that the include path is relative to the directory in which the
1127 # compiler is run, i.e. that of the project, not to that of the file.
1128 sub fix_file
1129 {
1130   my $filename=$_[0];
1131   my $project=$_[1];
1132   my $target=$_[2];
1133   $filename="@$project[$P_PATH]$filename";
1134   if (! -e $filename) {
1135     return;
1136   }
1137
1138   my $is_rc=($filename =~ /\.(rc2?|dlg)$/i);
1139   my $dirname=dirname($filename);
1140   my $is_mfc=0;
1141   if (defined $target and (@$target[$T_FLAGS] & $TF_MFC)) {
1142     $is_mfc=1;
1143   }
1144
1145   print "  $filename\n";
1146   #FIXME:assuming that because there is a .bak file, this is what we want is
1147   #probably flawed. Or is it???
1148   if (! -e "$filename.bak") {
1149     if (!copy("$filename","$filename.bak")) {
1150       print STDERR "error: unable to make a backup of $filename:\n";
1151       print STDERR "       $!\n";
1152       return;
1153     }
1154   }
1155   if (!open(FILEI,"$filename.bak")) {
1156     print STDERR "error: unable to open $filename.bak for reading:\n";
1157     print STDERR "       $!\n";
1158     return;
1159   }
1160   if (!open(FILEO,">$filename")) {
1161     print STDERR "error: unable to open $filename for writing:\n";
1162     print STDERR "       $!\n";
1163     return;
1164   }
1165   my $line=0;
1166   my $modified=0;
1167   my $rc_block_depth=0;
1168   my $rc_textinclude_state=0;
1169   while (<FILEI>) {
1170     $line++;
1171     $_ =~ s/\r\n$/\n/;
1172     if ($is_rc and !$is_mfc and /^(\s*\#\s*include\s*)\"afxres\.h\"/) {
1173       # VC6 automatically includes 'afxres.h', an MFC specific header, in
1174       # the RC files it generates (even in non-MFC projects). So we replace
1175       # it with 'winres.h' its very close standard cousin so that non MFC
1176       # projects can compile in Wine without the MFC sources. This does not
1177       # harm VC but it will put 'afxres.h' back the next time the file is
1178       # edited.
1179       my $warning="mfc:afxres.h";
1180       if (!defined $warnings{$warning}) {
1181         $warnings{$warning}="1";
1182         print STDERR "warning: In non-MFC projects, winemaker replaces the MFC specific header 'afxres.h' with 'winres.h'\n";
1183         print STDERR "warning: the above warning is issued only once\n";
1184       }
1185       print FILEO "/* winemaker: $1\"afxres.h\" */\n";
1186       print FILEO "$1\"winres.h\"$'";
1187       $modified=1;
1188     } elsif (/^(\s*\#\s*include\s*)([\"<])([^\"]+)([\">])/) {
1189       my $from_file=($2 eq "<"?"":$dirname);
1190       my $real_include_name=get_real_include_name($line,$3,$from_file,$project,$target);
1191       print FILEO "$1$2$real_include_name$4$'";
1192       $modified|=($real_include_name ne $3);
1193     } elsif (/^(\s*\#\s*pragma\s*pack\s*\((\s*push\s*,?)?\s*)(\w*)(\s*\))/) {
1194       my $pragma_header=$1;
1195       my $size=$3;
1196       my $pragma_trailer=$4;
1197       #print "$pragma_header$size$pragma_trailer$'";
1198       #print "pragma push: size=$size\n";
1199       print FILEO "/* winemaker: $pragma_header$size$pragma_trailer */\n";
1200       $line++;
1201       if ($size eq "pop") {
1202         print FILEO "#include <poppack.h>$'";
1203       } elsif ($size eq "1") {
1204         print FILEO "#include <pshpack1.h>$'";
1205       } elsif ($size eq "2") {
1206         print FILEO "#include <pshpack2.h>$'";
1207       } elsif ($size eq "8") {
1208         print FILEO "#include <pshpack8.h>$'";
1209       } elsif ($size eq "4" or $size eq "") {
1210         print FILEO "#include <pshpack4.h>$'";
1211       } else {
1212         my $warning="pack:$size";
1213         if (!defined $warnings{$warning}) {
1214           $warnings{$warning}="1";
1215           print STDERR "warning: assuming that the value of $size is 4 in\n";
1216           print STDERR "$line:   $pragma_header$size$pragma_trailer\n";
1217           print STDERR "warning: the above warning is issued only once\n";
1218         }
1219         print FILEO "#include <pshpack4.h>$'";
1220         $modified=1;
1221       }
1222     } elsif ($is_rc) {
1223       if ($rc_block_depth == 0 and /^(\w+\s+(BITMAP|CURSOR|FONT|FONTDIR|ICON|MESSAGETABLE|TEXT)\s+((DISCARDABLE|FIXED|IMPURE|LOADONCALL|MOVEABLE|PRELOAD|PURE)\s+)*)([\"<]?)([^\">\r\n]+)([\">]?)/) {
1224         my $from_file=($5 eq "<"?"":$dirname);
1225         my $real_include_name=get_real_include_name($line,$6,$from_file,$project,$target);
1226         print FILEO "$1$5$real_include_name$7$'";
1227         $modified|=($real_include_name ne $6);
1228       } elsif (/^(\s*RCINCLUDE\s*)([\"<]?)([^\">\r\n]+)([\">]?)/) {
1229         my $from_file=($2 eq "<"?"":$dirname);
1230         my $real_include_name=get_real_include_name($line,$3,$from_file,$project,$target);
1231         print FILEO "$1$2$real_include_name$4$'";
1232         $modified|=($real_include_name ne $3);
1233       } elsif ($is_rc and !$is_mfc and $rc_block_depth == 0 and /^\s*\d+\s+TEXTINCLUDE\s*/) {
1234         $rc_textinclude_state=1;
1235         print FILEO;
1236       } elsif ($rc_textinclude_state == 3 and /^(\s*\"\#\s*include\s*\"\")afxres\.h(\"\"\\r\\n\")/) {
1237         print FILEO "$1winres.h$2$'";
1238         $modified=1;
1239       } elsif (/^\s*BEGIN(\W.*)?$/) {
1240         $rc_textinclude_state|=2;
1241         $rc_block_depth++;
1242         print FILEO;
1243       } elsif (/^\s*END(\W.*)?$/) {
1244         $rc_textinclude_state=0;
1245         if ($rc_block_depth>0) {
1246           $rc_block_depth--;
1247         }
1248         print FILEO;
1249       } else {
1250         print FILEO;
1251       }
1252     } else {
1253       print FILEO;
1254     }
1255   }
1256   close(FILEI);
1257   close(FILEO);
1258   if ($opt_backup == 0 or $modified == 0) {
1259     if (!unlink("$filename.bak")) {
1260       print STDERR "error: unable to delete $filename.bak:\n";
1261       print STDERR "       $!\n";
1262     }
1263   }
1264 }
1265
1266 ##
1267 # Analyzes each source file in turn to find and correct issues
1268 # that would cause it not to compile.
1269 sub fix_source
1270 {
1271   print "Fixing the source files...\n";
1272   foreach $project (@projects) {
1273     foreach $target (@$project[$P_SETTINGS],@{@$project[$P_TARGETS]}) {
1274       if (@$target[$T_FLAGS] & $TF_WRAPPER) {
1275         next;
1276       }
1277       foreach $source (@{@$target[$T_SOURCES_C]}, @{@$target[$T_SOURCES_CXX]}, @{@$target[$T_SOURCES_RC]}, @{@$target[$T_SOURCES_MISC]}) {
1278         fix_file($source,$project,$target);
1279       }
1280     }
1281   }
1282 }
1283
1284
1285
1286 #####
1287 #
1288 # File generation
1289 #
1290 #####
1291
1292 ##
1293 # Generates a target's .spec file
1294 sub generate_spec_file
1295 {
1296   my $path=$_[0];
1297   my $target=$_[1];
1298   my $project_settings=$_[2];
1299
1300   my $basename=@$target[$T_NAME];
1301   $basename =~ s+\.so$++;
1302   if (@$target[$T_FLAGS] & $TF_WRAP) {
1303     $basename =~ s+^lib++;
1304   } elsif (@$target[$T_FLAGS] & $TF_WRAPPER) {
1305     $basename.="_wrapper";
1306   }
1307
1308   if (!open(FILEO,">$path$basename.spec")) {
1309     print STDERR "error: could not open \"$path$basename.spec\" for writing\n";
1310     print STDERR "       $!\n";
1311     return;
1312   }
1313
1314   my $canon=canonize($basename);
1315   print FILEO "name    $canon\n";
1316   print FILEO "type    win32\n";
1317   if (@$target[$T_TYPE] == $TT_GUIEXE) {
1318     print FILEO "mode    guiexe\n";
1319   } elsif (@$target[$T_TYPE] == $TT_CUIEXE) {
1320     print FILEO "mode    cuiexe\n";
1321   } else {
1322     print FILEO "mode    dll\n";
1323   }
1324   if (defined @$target[$T_INIT] and ((@$target[$T_FLAGS] & $TF_WRAP) == 0)) {
1325     print FILEO "init    @$target[$T_INIT]\n";
1326   }
1327   if (@{@$target[$T_SOURCES_RC]} > 0) {
1328     if (@{@$target[$T_SOURCES_RC]} > 1) {
1329       print STDERR "warning: the target $basename has more than one RC file. Modify the Makefile.in to remove redundant RC files, and fix the spec file\n";
1330     }
1331     my $rcname=@{@$target[$T_SOURCES_RC]}[0];
1332     $rcname =~ s+\.rc$++i;
1333     print FILEO "rsrc    $rcname.res\n";
1334   }
1335   print FILEO "\n";
1336   # FIXME: we should try to remove duplicates in the import list
1337   foreach $library (@{$global_settings[$T_IMPORTS]}) {
1338     print FILEO "import $library\n";
1339   }
1340   if (defined $project_settings) {
1341     foreach $library (@{@$project_settings[$T_IMPORTS]}) {
1342       print FILEO "import $library\n";
1343     }
1344   }
1345   foreach $library (@{@$target[$T_IMPORTS]}) {
1346     print FILEO "import $library\n";
1347   }
1348
1349   # Don't forget to export the 'Main' function for wrapped executables,
1350   # except for MFC ones!
1351   if (@$target[$T_FLAGS] == $TF_WRAP) {
1352     if (@$target[$T_TYPE] == $TT_GUIEXE) {
1353       print FILEO "\n@ stdcall @$target[$T_INIT](long long ptr long) @$target[$T_INIT]\n";
1354     } elsif (@$target[$T_TYPE] == $TT_CUIEXE) {
1355       print FILEO "\n@ stdcall @$target[$T_INIT](long ptr ptr) @$target[$T_INIT]\n";
1356     } else {
1357       print FILEO "\n@ stdcall @$target[$T_INIT](ptr long ptr) @$target[$T_INIT]\n";
1358     }
1359   }
1360
1361   close(FILEO);
1362 }
1363
1364 ##
1365 # Generates a target's wrapper file
1366 sub generate_wrapper_file
1367 {
1368   my $path=$_[0];
1369   my $target=$_[1];
1370
1371   if (!defined $templates{"wrapper.c"}) {
1372     print STDERR "winemaker: internal error: No template called 'wrapper.c'\n";
1373     return;
1374   }
1375
1376   if (!open(FILEO,">$path@$target[$T_NAME]_wrapper.c")) {
1377     print STDERR "error: unable to open \"$path$basename.c\" for writing:\n";
1378     print STDERR "       $!\n";
1379     return;
1380   }
1381   my $app_name="\"@$target[$T_NAME]\"";
1382   my $app_type=(@$target[$T_TYPE]==$TT_GUIEXE?"GUIEXE":"CUIEXE");
1383   my $app_init=(@$target[$T_TYPE]==$TT_GUIEXE?"\"WinMain\"":"\"main\"");
1384   my $app_mfc=(@$target[$T_FLAGS] & $TF_MFC?"\"mfc\"":NULL);
1385   foreach $line (@{$templates{"wrapper.c"}}) {
1386     $line =~ s/\#\#WINEMAKER_APP_NAME\#\#/$app_name/;
1387     $line =~ s/\#\#WINEMAKER_APP_TYPE\#\#/$app_type/;
1388     $line =~ s/\#\#WINEMAKER_APP_INIT\#\#/$app_init/;
1389     $line =~ s/\#\#WINEMAKER_APP_MFC\#\#/$app_mfc/;
1390     print FILEO $line;
1391   }
1392   close(FILEO);
1393 }
1394
1395 ##
1396 # A convenience function to generate all the lists (defines,
1397 # C sources, C++ source, etc.) in the Makefile
1398 sub generate_list
1399 {
1400   my $name=$_[0];
1401   my $last=$_[1];
1402   my $list=$_[2];
1403   my $data=$_[3];
1404
1405   if ($name) {
1406     printf FILEO "%-9s =",$name;
1407   }
1408   if (defined $list and @$list > 0) {
1409     foreach $item (@$list) {
1410       my $value;
1411       if (defined $data) {
1412         $value=&$data($item);
1413       } else {
1414         $value=$item;
1415       }
1416       if ($value ne "") {
1417         print FILEO " \\\n\t$value";
1418       }
1419     }
1420   }
1421   if ($last) {
1422     print FILEO "\n\n";
1423   }
1424 }
1425
1426 ##
1427 # Generates a project's Makefile.in and all the target files
1428 sub generate_project_files
1429 {
1430   my $project=$_[0];
1431   my $project_settings=@$project[$P_SETTINGS];
1432   my @library_list=();
1433   my @program_list=();
1434
1435   # Then sort the targets and separate the libraries from the programs
1436   foreach $target (sort { @$a[$T_NAME] cmp @$b[$T_NAME] } @{@$project[$P_TARGETS]}) {
1437     if (@$target[$T_TYPE] == $TT_DLL) {
1438       push @library_list,$target;
1439     } else {
1440       push @program_list,$target;
1441     }
1442   }
1443   @$project[$P_TARGETS]=[];
1444   push @{@$project[$P_TARGETS]}, @library_list;
1445   push @{@$project[$P_TARGETS]}, @program_list;
1446
1447   if (!open(FILEO,">@$project[$P_PATH]Makefile.in")) {
1448     print STDERR "error: could not open \"@$project[$P_PATH]/Makefile.in\" for writing\n";
1449     print STDERR "       $!\n";
1450     return;
1451   }
1452
1453   print FILEO "### Generic autoconf variables\n\n";
1454   print FILEO "TOPSRCDIR = \@top_srcdir\@\n";
1455   print FILEO "TOPOBJDIR = .\n";
1456   print FILEO "SRCDIR    = \@srcdir\@\n";
1457   print FILEO "VPATH     = \@srcdir\@\n";
1458   print FILEO "\n";
1459   if (@$project[$P_PATH] eq "") {
1460     # This is the main project. It is also responsible for recursively
1461     # calling the other projects
1462     generate_list("SUBDIRS",1,\@projects,sub
1463                   {
1464                     if ($_[0] != \@main_project) {
1465                       my $subdir=@{$_[0]}[$P_PATH];
1466                       $subdir =~ s+/$++;
1467                       return $subdir;
1468                     }
1469                     # Eliminating the main project by returning undefined!
1470                   });
1471   }
1472   if (@{@$project[$P_TARGETS]} > 0) {
1473     generate_list("LIBRARIES",1,\@library_list,sub
1474                   {
1475                     return @{$_[0]}[$T_NAME];
1476                   });
1477     generate_list("PROGRAMS",1,\@program_list,sub
1478                   {
1479                     return @{$_[0]}[$T_NAME];
1480                   });
1481     print FILEO "\n\n";
1482
1483     print FILEO "### Global settings\n\n";
1484     # Make it so that the project-wide settings override the global settings
1485     generate_list("DEFINES",0,@$project_settings[$T_DEFINES],sub
1486                   {
1487                     return "$_[0]";
1488                   });
1489     generate_list("",1,$global_settings[$T_DEFINES],sub
1490                   {
1491                     return "$_[0]";
1492                   });
1493     generate_list("INCLUDE_PATH",$no_extra,@$project_settings[$T_INCLUDE_PATH],sub
1494                   {
1495                     return "$_[0]";
1496                   });
1497     generate_list("",1,$global_settings[$T_INCLUDE_PATH],sub
1498                   {
1499                     if ($_[0] !~ /^-I/) {
1500                       return "$_[0]";
1501                     }
1502                     if (is_absolute($')) {
1503                       return "$_[0]";
1504                     }
1505                     return "\$(TOPSRCDIR)/$_[0]";
1506                   });
1507     generate_list("LIBRARY_PATH",$no_extra,@$project_settings[$T_LIBRARY_PATH],sub
1508                   {
1509                     return "$_[0]";
1510                   });
1511     generate_list("",1,$global_settings[$T_LIBRARY_PATH],sub
1512                   {
1513                     if ($_[0] !~ /^-L/) {
1514                       return "$_[0]";
1515                     }
1516                     if (is_absolute($')) {
1517                       return "$_[0]";
1518                     }
1519                     return "\$(TOPSRCDIR)/$_[0]";
1520                   });
1521     generate_list("IMPORTS",$no_extra,@$project_settings[$T_IMPORTS],sub
1522                   {
1523                     return "$_[0]";
1524                   });
1525     generate_list("",1,$global_settings[$T_IMPORTS],sub
1526                   {
1527                     return "$_[0]";
1528                   });
1529     print FILEO "\n\n";
1530
1531     my $extra_source_count=@{@$project_settings[$T_SOURCES_C]}+
1532                            @{@$project_settings[$T_SOURCES_CXX]}+
1533                            @{@$project_settings[$T_SOURCES_RC]};
1534     my $no_extra=($extra_source_count == 0);
1535     if (!$no_extra) {
1536       print FILEO "### Extra source lists\n\n";
1537       generate_list("EXTRA_C_SRCS",1,@$project_settings[$T_SOURCES_C]);
1538       generate_list("EXTRA_CXX_SRCS",1,@$project_settings[$T_SOURCES_CXX]);
1539       generate_list("EXTRA_RC_SRCS",1,@$project_settings[$T_SOURCES_RC]);
1540       print FILEO "EXTRA_OBJS = \$(EXTRA_C_SRCS:.c=.o) \$(EXTRA_CXX_SRCS:.cpp=.o)\n";
1541       print FILEO "\n\n";
1542     }
1543
1544     # Iterate over all the targets...
1545     foreach $target (@{@$project[$P_TARGETS]}) {
1546       print FILEO "\n### @$target[$T_NAME] sources and settings\n\n";
1547       my $canon=canonize("@$target[$T_NAME]");
1548       $canon =~ s+_so$++;
1549       generate_list("${canon}_C_SRCS",1,@$target[$T_SOURCES_C]);
1550       generate_list("${canon}_CXX_SRCS",1,@$target[$T_SOURCES_CXX]);
1551       generate_list("${canon}_RC_SRCS",1,@$target[$T_SOURCES_RC]);
1552       my $basename=@$target[$T_NAME];
1553       $basename =~ s+\.so$++;
1554       if (@$target[$T_FLAGS] & $TF_WRAP) {
1555         $basename =~ s+^lib++;
1556       } elsif (@$target[$T_FLAGS] & $TF_WRAPPER) {
1557         $basename.="_wrapper";
1558       }
1559       generate_list("${canon}_SPEC_SRCS",1,[ "$basename.spec"]);
1560       generate_list("${canon}_LIBRARY_PATH",1,@$target[$T_LIBRARY_PATH],sub
1561                     {
1562                       return "$_[0]";
1563                     });
1564       generate_list("${canon}_IMPORTS",1,@$target[$T_IMPORTS],sub
1565                     {
1566                       return "$_[0]";
1567                     });
1568       generate_list("${canon}_DEPENDS",1,@$target[$T_DEPENDS],sub
1569                     {
1570                       return "$_[0]";
1571                     });
1572       print FILEO "${canon}_OBJS = \$(${canon}_SPEC_SRCS:.spec=.spec.o) \$(${canon}_C_SRCS:.c=.o) \$(${canon}_CXX_SRCS:.cpp=.o) \$(EXTRA_OBJS)\n";
1573       print FILEO "\n\n";
1574     }
1575     print FILEO "### Global source lists\n\n";
1576     generate_list("C_SRCS",$no_extra,@$project[$P_TARGETS],sub
1577                   {
1578                     my $canon=canonize(@{$_[0]}[$T_NAME]);
1579                     $canon =~ s+_so$++;
1580                     return "\$(${canon}_C_SRCS)";
1581                   });
1582     if (!$no_extra) {
1583       generate_list("",1,[ "\$(EXTRA_C_SRCS)" ]);
1584     }
1585     generate_list("CXX_SRCS",$no_extra,@$project[$P_TARGETS],sub
1586                   {
1587                     my $canon=canonize(@{$_[0]}[$T_NAME]);
1588                     $canon =~ s+_so$++;
1589                     return "\$(${canon}_CXX_SRCS)";
1590                   });
1591     if (!$no_extra) {
1592       generate_list("",1,[ "\$(EXTRA_CXX_SRCS)" ]);
1593     }
1594     generate_list("RC_SRCS",$no_extra,@$project[$P_TARGETS],sub
1595                   {
1596                     my $canon=canonize(@{$_[0]}[$T_NAME]);
1597                     $canon =~ s+_so$++;
1598                     return "\$(${canon}_RC_SRCS)";
1599                   });
1600     if (!$no_extra) {
1601       generate_list("",1,@$project_settings[$T_SOURCES_RC]);
1602     }
1603     generate_list("SPEC_SRCS",1,@$project[$P_TARGETS],sub
1604                   {
1605                     my $canon=canonize(@{$_[0]}[$T_NAME]);
1606                     $canon =~ s+_so$++;
1607                     return "\$(${canon}_SPEC_SRCS)";
1608                   });
1609     print FILEO "\n\n";
1610   }
1611
1612   print FILEO "### Generic autoconf targets\n\n";
1613   if (@$project[$P_PATH] eq "") {
1614     print FILEO "all: \$(SUBDIRS) \$(LIBRARIES) \$(PROGRAMS)\n";
1615   } else {
1616     print FILEO "all: \$(LIBRARIES) \$(PROGRAMS)\n";
1617   }
1618   print FILEO "\n";
1619   print FILEO "\@MAKE_RULES\@\n";
1620   print FILEO "\n";
1621   print FILEO "install::\n";
1622   if (@$project[$P_PATH] eq "") {
1623     # This is the main project. It is also responsible for recursively
1624     # calling the other projects
1625     print FILEO "\tfor i in \$(SUBDIRS); do (cd \$\$i; \$(MAKE) install) || exit 1; done\n";
1626   }
1627   if (@{@$project[$P_TARGETS]} > 0) {
1628     print FILEO "\tfor i in \$(PROGRAMS); do \$(INSTALL_PROGRAM) \$\$i \$(bindir); done\n";
1629     print FILEO "\tfor i in \$(LIBRARIES); do \$(INSTALL_LIBRARY) \$\$i \$(libdir); done\n";
1630   }
1631   print FILEO "\n";
1632   print FILEO "uninstall::\n";
1633   if (@$project[$P_PATH] eq "") {
1634     # This is the main project. It is also responsible for recursively
1635     # calling the other projects
1636     print FILEO "\tfor i in \$(SUBDIRS); do (cd \$\$i; \$(MAKE) uninstall) || exit 1; done\n";
1637   }
1638   if (@{@$project[$P_TARGETS]} > 0) {
1639     print FILEO "\tfor i in \$(PROGRAMS); do \$(RM) \$(bindir)/\$\$i;done\n";
1640     print FILEO "\tfor i in \$(LIBRARIES); do \$(RM) \$(libdir)/\$\$i;done\n";
1641   }
1642   print FILEO "\n\n\n";
1643
1644   if (@{@$project[$P_TARGETS]} > 0) {
1645     print FILEO "### Target specific build rules\n\n";
1646     foreach $target (@{@$project[$P_TARGETS]}) {
1647       my $canon=canonize("@$target[$T_NAME]");
1648       $canon =~ s/_so$//;
1649       print FILEO "\$(${canon}_SPEC_SRCS:.spec=.spec.c): \$(${canon}_RC_SRCS:.rc=.res)\n";
1650       print FILEO "\n";
1651       print FILEO "@$target[$T_NAME]: \$(${canon}_OBJS) \$(${canon}_DEPENDS) \n";
1652       if (@$target[$T_TYPE] eq $TT_DLL) {
1653         print FILEO "\t\$(LDSHARED) -shared -Wl,-soname,\$\@ -o \$\@ \$(${canon}_OBJS) \$(${canon}_LIBRARY_PATH) \$(${canon}_IMPORTS:%=-l%) \$(DLL_LINK) \$(LIBS)\n";
1654       } else {
1655         print FILEO "\t\$(CC) -o \$\@ \$(${canon}_OBJS) \$(${canon}_LIBRARY_PATH) \$(${canon}_IMPORTS:%=-l%) \$(DLL_LINK) \$(LIBS)\n";
1656       }
1657       print FILEO "\n";
1658     }
1659   }
1660   close(FILEO);
1661
1662   foreach $target (@{@$project[$P_TARGETS]}) {
1663     generate_spec_file(@$project[$P_PATH],$target,$project_settings);
1664     if (@$target[$T_FLAGS] & $TF_WRAPPER) {
1665       generate_wrapper_file(@$project[$P_PATH],$target);
1666     }
1667   }
1668 }
1669
1670 ##
1671 # Perform the replacements in the template configure files
1672 # Return 1 for success, 0 for failure
1673 sub generate_configure
1674 {
1675   my $filename=$_[0];
1676   my $a_source_file=$_[1];
1677
1678   if (!defined $templates{$filename}) {
1679     if ($filename ne "configure") {
1680       print STDERR "winemaker: internal error: No template called '$filename'\n";
1681     }
1682     return 0;
1683   }
1684
1685   if (!open(FILEO,">$filename")) {
1686     print STDERR "error: unable to open \"$filename\" for writing:\n";
1687     print STDERR "       $!\n";
1688     return 0;
1689   }
1690   foreach $line (@{$templates{$filename}}) {
1691     if ($line =~ /^\#\#WINEMAKER_PROJECTS\#\#$/) {
1692       foreach $project (@projects) {
1693         print FILEO "@$project[$P_PATH]Makefile\n";
1694       }
1695     } else {
1696       $line =~ s+\#\#WINEMAKER_SOURCE\#\#+$a_source_file+;
1697       $line =~ s+\#\#WINEMAKER_NEEDS_MFC\#\#+$needs_mfc+;
1698       print FILEO $line;
1699     }
1700   }
1701   close(FILEO);
1702   return 1;
1703 }
1704
1705 sub generate_generic
1706 {
1707   my $filename=$_[0];
1708
1709   if (!defined $templates{$filename}) {
1710     print STDERR "winemaker: internal error: No template called '$filename'\n";
1711     return;
1712   }
1713   if (!open(FILEO,">$filename")) {
1714     print STDERR "error: unable to open \"$filename\" for writing:\n";
1715     print STDERR "       $!\n";
1716     return;
1717   }
1718   foreach $line (@{$templates{$filename}}) {
1719     print FILEO $line;
1720   }
1721   close(FILEO);
1722 }
1723
1724 ##
1725 # Generates the global files:
1726 # configure
1727 # configure.in
1728 # Make.rules.in
1729 sub generate_global_files
1730 {
1731   generate_generic("Make.rules.in");
1732
1733   # Get the name of a source file for configure.in
1734   my $a_source_file;
1735   search_a_file: foreach $project (@projects) {
1736     foreach $target (@{@$project[$P_TARGETS]}) {
1737       $a_source_file=@{@$target[$T_SOURCES_C]}[0];
1738       if (!defined $a_source_file) {
1739         $a_source_file=@{@$target[$T_SOURCES_CXX]}[0];
1740       }
1741       if (!defined $a_source_file) {
1742         $a_source_file=@{@$target[$T_SOURCES_RC]}[0];
1743       }
1744       if (defined $a_source_file) {
1745         $a_source_file="@$project[$P_PATH]$a_source_file";
1746         last search_a_file;
1747       }
1748     }
1749   }
1750
1751   generate_configure("configure.in",$a_source_file);
1752   unlink("configure");
1753   if (generate_configure("configure",$a_source_file) == 0) {
1754     system("autoconf");
1755   }
1756   # Add execute permission to configure for whoever has the right to read it
1757   my @st=stat("configure");
1758   if (defined @st) {
1759     my $mode=$st[2];
1760     $mode|=($mode & 0444) >>2;
1761     chmod($mode,"configure");
1762   } else {
1763     print "warning: could not generate the configure script. You need to run autoconf\n";
1764   }
1765 }
1766
1767 ##
1768 #
1769 sub generate_read_templates
1770 {
1771   my $file;
1772
1773   while (<DATA>) {
1774     if (/^--- ((\w\.?)+) ---$/) {
1775       my $filename=$1;
1776       if (defined $templates{$filename}) {
1777         print STDERR "winemaker: internal error: There is more than one template for $filename\n";
1778         undef $file;
1779       } else {
1780         $file=[];
1781         $templates{$filename}=$file;
1782       }
1783     } elsif (defined $file) {
1784       push @$file, $_;
1785     }
1786   }
1787 }
1788
1789 ##
1790 # This is where we finally generate files. In fact this method does not
1791 # do anything itself but calls the methods that do the actual work.
1792 sub generate
1793 {
1794   print "Generating project files...\n";
1795   generate_read_templates();
1796   generate_global_files();
1797
1798   foreach $project (@projects) {
1799     my $path=@$project[$P_PATH];
1800     if ($path eq "") {
1801       $path=".";
1802     } else {
1803       $path =~ s+/$++;
1804     }
1805     print "  $path\n";
1806     generate_project_files($project);
1807   }
1808 }
1809
1810
1811
1812 #####
1813 #
1814 # Option defaults
1815 #
1816 #####
1817
1818 $opt_backup=1;
1819 $opt_lower=$OPT_LOWER_UPPERCASE;
1820
1821 # $opt_single_target=<undefined>
1822 $opt_target_type=$TT_GUIEXE;
1823 $opt_flags=0;
1824 $opt_is_interactive=$OPT_ASK_NO;
1825 $opt_ask_project_options=$OPT_ASK_NO;
1826 $opt_ask_target_options=$OPT_ASK_NO;
1827 $opt_no_makefile=0;
1828 $opt_no_banner=0;
1829
1830
1831
1832 #####
1833 #
1834 # Main
1835 #
1836 #####
1837
1838 project_init(\@main_project,"");
1839
1840 while (@ARGV>0) {
1841   my $arg=shift @ARGV;
1842   # General options
1843   if ($arg eq "--nobanner") {
1844     $opt_no_banner=1;
1845   } elsif ($arg eq "--backup") {
1846     $opt_backup=1;
1847   } elsif ($arg eq "--nobackup") {
1848     $opt_backup=0;
1849   } elsif ($arg eq "--single-target") {
1850     $opt_single_target=shift @ARGV;
1851   } elsif ($arg eq "--lower-none") {
1852     $opt_lower=$OPT_LOWER_NONE;
1853   } elsif ($arg eq "--lower-all") {
1854     $opt_lower=$OPT_LOWER_ALL;
1855   } elsif ($arg eq "--lower-uppercase") {
1856     $opt_lower=$OPT_LOWER_UPPERCASE;
1857   } elsif ($arg eq "--no-makefile") {
1858     $opt_no_makefile=1;
1859
1860   } elsif ($arg =~ /^-D/) {
1861     push @{$global_settings[$T_DEFINES]},$arg;
1862   } elsif ($arg =~ /^-I/) {
1863     push @{$global_settings[$T_INCLUDE_PATH]},$arg;
1864   } elsif ($arg =~ /^-L/) {
1865     push @{$global_settings[$T_LIBRARY_PATH]},$arg;
1866   } elsif ($arg =~ /^-l/) {
1867     push @{$global_settings[$T_IMPORTS]},$';
1868
1869   # 'Source'-based method options
1870   } elsif ($arg eq "--dll") {
1871     $opt_target_type=$TT_DLL;
1872   } elsif ($arg eq "--guiexe" or $arg eq "--windows") {
1873     $opt_target_type=$TT_GUIEXE;
1874   } elsif ($arg eq "--cuiexe" or $arg eq "--console") {
1875     $opt_target_type=$TT_CUIEXE;
1876   } elsif ($arg eq "--interactive") {
1877     $opt_is_interactive=$OPT_ASK_YES;
1878     $opt_ask_project_options=$OPT_ASK_YES;
1879     $opt_ask_target_options=$OPT_ASK_YES;
1880   } elsif ($arg eq "--wrap") {
1881     $opt_flags|=$TF_WRAP;
1882   } elsif ($arg eq "--nowrap") {
1883     $opt_flags&=~$TF_WRAP;
1884   } elsif ($arg eq "--mfc") {
1885     $opt_flags|=$TF_MFC|$TF_WRAP;
1886     $needs_mfc=1;
1887   } elsif ($arg eq "--nomfc") {
1888     $opt_flags&=~($TF_MFC|$TF_WRAP);
1889     $needs_mfc=0;
1890
1891   # Catch errors
1892   } else {
1893     if ($arg ne "--help" and $arg ne "-h" and $arg ne "-?") {
1894       print STDERR "Unknown option: $arg\n";
1895     }
1896     $usage=1;
1897     last;
1898   }
1899 }
1900
1901 if ($opt_no_banner == 0 or defined $usage) {
1902    print "Winemaker $version\n";
1903    print "Copyright 2000 Francois Gouget <fgouget\@codeweavers.com> for CodeWeavers\n";
1904 }
1905
1906 if (defined $usage) {
1907   print STDERR "Usage: winemaker [--nobanner] [--backup|--nobackup]\n";
1908   print STDERR "                 [--lower-none|--lower-all|--lower-uppercase]\n";
1909   print STDERR "                 [--guiexe|--windows|--cuiexe|--console|--dll]\n";
1910   print STDERR "                 [--wrap|--nowrap] [--mfc|--nomfc]\n";
1911   print STDERR "                 [-Dmacro[=defn]] [-Idir] [-Ldir] [-llibrary]\n";
1912   print STDERR "                 [--interactive] [--single-target name]\n";
1913   exit (2);
1914 }
1915
1916 # Fix the file and directory names
1917 fix_file_and_directory_names(".");
1918
1919 # Scan the sources to identify the projects and targets
1920 source_scan();
1921
1922 # Create targets for wrappers
1923 create_wrappers();
1924
1925 # Fix the source files
1926 fix_source();
1927
1928 # Generate the Makefile and the spec file
1929 if (! $opt_no_makefile) {
1930   generate();
1931 }
1932
1933
1934 __DATA__
1935 --- configure.in ---
1936 dnl Process this file with autoconf to produce a configure script.
1937 dnl Author: Michael Patra   <micky@marie.physik.tu-berlin.de>
1938 dnl                         <patra@itp1.physik.tu-berlin.de>
1939 dnl         Francois Gouget <fgouget@codeweavers.com> for CodeWeavers
1940
1941 AC_REVISION([configure.in 1.00])
1942 AC_INIT(##WINEMAKER_SOURCE##)
1943
1944 NEEDS_MFC=##WINEMAKER_NEEDS_MFC##
1945
1946 dnl **** Command-line arguments ****
1947
1948 AC_SUBST(OPTIONS)
1949
1950 dnl **** Check for some programs ****
1951
1952 AC_PROG_MAKE_SET
1953 AC_PROG_CC
1954 AC_PROG_CXX
1955 AC_PROG_CPP
1956 AC_PATH_XTRA
1957 AC_PROG_RANLIB
1958 AC_PROG_LN_S
1959 AC_PATH_PROG(LDCONFIG, ldconfig, true, /sbin:/usr/sbin:$PATH)
1960
1961 dnl **** Check for some libraries ****
1962
1963 dnl Check for -lm for BeOS
1964 AC_CHECK_LIB(m,sqrt)
1965 dnl Check for -li386 for NetBSD and OpenBSD
1966 AC_CHECK_LIB(i386,i386_set_ldt)
1967 dnl Check for -lossaudio for NetBSD
1968 AC_CHECK_LIB(ossaudio,_oss_ioctl)
1969 dnl Check for -lw for Solaris
1970 AC_CHECK_LIB(w,iswalnum)
1971 dnl Check for -lnsl for Solaris
1972 AC_CHECK_FUNCS(gethostbyname,, AC_CHECK_LIB(nsl, gethostbyname, X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl", AC_CHECK_LIB(socket, gethostbyname, X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl", , -lnsl), -lsocket))
1973 dnl Check for -lsocket for Solaris
1974 AC_CHECK_FUNCS(connect,,AC_CHECK_LIB(socket,connect))
1975 dnl Check for -lxpg4 for FreeBSD
1976 AC_CHECK_LIB(xpg4,setrunelocale)
1977 dnl Check for -lmmap for OS/2
1978 AC_CHECK_LIB(mmap,mmap)
1979 dnl Check for openpty
1980 AC_CHECK_FUNCS(openpty,,
1981         AC_CHECK_LIB(util,openpty,
1982                 AC_DEFINE(HAVE_OPENPTY)
1983                 LIBS="$LIBS -lutil"
1984         ))
1985
1986 AC_CHECK_HEADERS(dlfcn.h,
1987         AC_CHECK_FUNCS(dlopen,
1988                 AC_DEFINE(HAVE_DL_API),
1989                 AC_CHECK_LIB(dl,dlopen,
1990                         AC_DEFINE(HAVE_DL_API)
1991                         LIBS="$LIBS -ldl",
1992                 )
1993         ),
1994 )
1995 AC_SUBST(XLIB)
1996 AC_SUBST(X_DLLS)
1997 X_DLLS=""
1998 AC_SUBST(XFILES)
1999 XFILES=""
2000
2001 dnl **** Check which curses lib to use ***
2002 if test "$CURSES" = "yes"
2003 then
2004     AC_CHECK_HEADERS(ncurses.h)
2005     if test "$ac_cv_header_ncurses_h" = "yes"
2006     then
2007         AC_CHECK_LIB(ncurses,waddch)
2008     fi
2009     if test "$ac_cv_lib_ncurses_waddch" = "yes"
2010     then
2011         AC_CHECK_LIB(ncurses,resizeterm,AC_DEFINE(HAVE_RESIZETERM))
2012         AC_CHECK_LIB(ncurses,getbkgd,AC_DEFINE(HAVE_GETBKGD))
2013     else
2014         AC_CHECK_HEADERS(curses.h)
2015         if test "$ac_cv_header_curses_h" = "yes"
2016         then
2017             AC_CHECK_LIB(curses,waddch)
2018             if test "$ac_cv_lib_curses_waddch" = "yes"
2019             then
2020                 AC_CHECK_LIB(curses,resizeterm,AC_DEFINE(HAVE_RESIZETERM))
2021                 AC_CHECK_LIB(curses,getbkgd,AC_DEFINE(HAVE_GETBKGD))
2022             fi
2023         fi
2024     fi
2025 fi
2026
2027 dnl **** If ln -s doesn't work, use cp instead ****
2028 if test "$ac_cv_prog_LN_S" = "ln -s"; then : ; else LN_S=cp ; fi
2029
2030 dnl **** Check for gcc strength-reduce bug ****
2031
2032 if test "x${GCC}" = "xyes"
2033 then
2034   AC_CACHE_CHECK( "for gcc strength-reduce bug", ac_cv_c_gcc_strength_bug,
2035                   AC_TRY_RUN([
2036 int main(void) {
2037   static int Array[[3]];
2038   unsigned int B = 3;
2039   int i;
2040   for(i=0; i<B; i++) Array[[i]] = i - 3;
2041   exit( Array[[1]] != -2 );
2042 }],
2043     ac_cv_c_gcc_strength_bug="no",
2044     ac_cv_c_gcc_strength_bug="yes",
2045     ac_cv_c_gcc_strength_bug="yes") )
2046   if test "$ac_cv_c_gcc_strength_bug" = "yes"
2047   then
2048     CFLAGS="$CFLAGS -fno-strength-reduce"
2049   fi
2050 fi
2051
2052 dnl **** Check for underscore on external symbols ****
2053
2054 AC_CACHE_CHECK("whether external symbols need an underscore prefix",
2055                ac_cv_c_extern_prefix,
2056 [saved_libs=$LIBS
2057 LIBS="conftest_asm.s $LIBS"
2058 cat > conftest_asm.s <<EOF
2059         .globl _ac_test
2060 _ac_test:
2061         .long 0
2062 EOF
2063 AC_TRY_LINK([extern int ac_test;],[if (ac_test) return 1],
2064             ac_cv_c_extern_prefix="yes",ac_cv_c_extern_prefix="no")
2065 LIBS=$saved_libs])
2066 if test "$ac_cv_c_extern_prefix" = "yes"
2067 then
2068   AC_DEFINE(NEED_UNDERSCORE_PREFIX)
2069 fi
2070
2071 dnl **** Check for working dll ****
2072
2073 LDSHARED=""
2074 AC_CACHE_CHECK("whether we can build a Linux dll",
2075                ac_cv_c_dll_linux,
2076 [saved_cflags=$CFLAGS
2077 CFLAGS="$CFLAGS -fPIC -shared -Wl,-soname,conftest.so.1.0"
2078 AC_TRY_LINK(,[return 1],ac_cv_c_dll_linux="yes",ac_cv_c_dll_linux="no")
2079 CFLAGS=$saved_cflags
2080 ])
2081 if test "$ac_cv_c_dll_linux" = "yes"
2082 then
2083   LDSHARED="\$(CC) -shared -Wl,-soname,\$(SONAME),-rpath,\$(libdir)"
2084 else
2085   AC_CACHE_CHECK(whether we can build a UnixWare (Solaris) dll,
2086                 ac_cv_c_dll_unixware,
2087   [saved_cflags=$CFLAGS
2088   CFLAGS="$CFLAGS -fPIC -Wl,-G,-h,conftest.so.1.0"
2089   AC_TRY_LINK(,[return 1],ac_cv_c_dll_unixware="yes",ac_cv_c_dll_unixware="no")
2090   CFLAGS=$saved_cflags
2091   ])
2092   if test "$ac_cv_c_dll_unixware" = "yes"
2093   then
2094     LDSHARED="\$(CC) -Wl,-G,-h,\$(libdir)/\$(SONAME)"
2095   else
2096     AC_CACHE_CHECK("whether we can build a NetBSD dll",
2097                    ac_cv_c_dll_netbsd,
2098     [saved_cflags=$CFLAGS
2099     CFLAGS="$CFLAGS -fPIC -Bshareable -Bforcearchive"
2100     AC_TRY_LINK(,[return 1],ac_cv_c_dll_netbsd="yes",ac_cv_c_dll_netbsd="no")
2101     CFLAGS=$saved_cflags
2102     ])
2103     if test "$ac_cv_c_dll_netbsd" = "yes"
2104     then
2105       LDSHARED="ld -Bshareable -Bforcearchive"
2106     fi
2107   fi
2108 fi
2109 if test "$ac_cv_c_dll_linux" = "no" -a "$ac_cv_c_dll_unixware" = "no" -a "$ac_cv_c_dll_netbsd" = "no"
2110 then
2111   AC_MSG_ERROR([Could not find how to build a dynamically linked library])
2112 fi
2113
2114 DLLFLAGS="-fPIC"
2115 DLL_LINK="\$(WINELIB_LIBRARY_PATH) \$(DLLS:%=-l%) \$(IMPORTS:%=-l%) -lwine -lwine_unicode"
2116
2117 AC_SUBST(DLL_LINK)
2118 AC_SUBST(DLLFLAGS)
2119 AC_SUBST(LDSHARED)
2120
2121 dnl *** check for the need to define __i386__
2122
2123 AC_CACHE_CHECK("whether we need to define __i386__",ac_cv_cpp_def_i386,
2124  AC_EGREP_CPP(yes,[#if (defined(i386) || defined(__i386)) && !defined(__i386__)
2125 yes
2126 #endif],
2127  ac_cv_cpp_def_i386="yes", ac_cv_cpp_def_i386="no"))
2128 if test "$ac_cv_cpp_def_i386" = "yes"
2129 then
2130     CFLAGS="$CFLAGS -D__i386__"
2131 fi
2132
2133 dnl $GCC is set by autoconf
2134 GCC_NO_BUILTIN=""
2135 if test "$GCC" = "yes"
2136 then
2137     GCC_NO_BUILTIN="-fno-builtin"
2138 fi
2139 AC_SUBST(GCC_NO_BUILTIN)
2140
2141 dnl **** Test Winelib-related features of the C++ compiler
2142 AC_LANG_CPLUSPLUS()
2143 if test "x${GCC}" = "xyes"
2144 then
2145   OLDCXXFLAGS="$CXXFLAGS";
2146   CXXFLAGS="-fpermissive";
2147   AC_CACHE_CHECK("for g++ -fpermissive option", has_gxx_permissive,
2148     AC_TRY_COMPILE(,[
2149         for (int i=0;i<2;i++);
2150         i=0;
2151       ],
2152       [has_gxx_permissive="yes"],
2153       [has_gxx_permissive="no"])
2154    )
2155   CXXFLAGS="-fno-for-scope";
2156   AC_CACHE_CHECK("for g++ -fno-for-scope option", has_gxx_no_for_scope,
2157     AC_TRY_COMPILE(,[
2158         for (int i=0;i<2;i++);
2159         i=0;
2160       ],
2161       [has_gxx_no_for_scope="yes"],
2162       [has_gxx_no_for_scope="no"])
2163    )
2164   CXXFLAGS="$OLDCXXFLAGS";
2165   if test "$has_gxx_permissive" = "yes"
2166   then
2167     CXXFLAGS="$CXXFLAGS -fpermissive"
2168   fi
2169   if test "$has_gxx_no_for_scope" = "yes"
2170   then
2171     CXXFLAGS="$CXXFLAGS -fno-for-scope"
2172   fi
2173 fi
2174
2175 dnl **** Test Winelib-related features of the C compiler
2176 dnl none for now
2177
2178 dnl **** Try to find where winelib is located ****
2179
2180 dnl This section is implemented using custom code since autoconf does not
2181 dnl provide a standard method. Here is how other people have tried to
2182 dnl solve the same (or similar) problem.
2183 dnl See: http://www.geocrawler.com/archives/3/402/1999/4/50/2131449/
2184 dnl or   http://www.geocrawler.com/archives/3/402/1999/4/50/2131443/
2185 dnl      ftp://ftp.slac.stanford.edu/users/langston/autoconf/smr_macros-0.09.tar.gz
2186 dnl or   http://www.geocrawler.com/archives/3/402/1999/4/50/2131452/
2187 dnl or   http://www.geocrawler.com/archives/3/402/1999/4/50/2131446/
2188
2189 WINELIB_INCLUDE_ROOT="";
2190 WINELIB_INCLUDE_PATH="";
2191 WINELIB_LIBRARY_ROOT="";
2192 WINELIB_LIBRARY_PATH="";
2193 WINELIB_TOOL_PATH="";
2194 WINEBUILD="";
2195 WRC="";
2196
2197 AC_ARG_WITH(winelib-root,
2198 [  --with-winelib-root=DIR       take the Winelib includes, libraries and tools from this directory],
2199 [if test "$withval" != "no"; then
2200   WINELIB_ROOT="$withval";
2201   WINELIB_INCLUDES="";
2202   WINELIB_LIBRARIES="";
2203   WINELIB_TOOLS="";
2204 else
2205   WINELIB_ROOT="";
2206 fi])
2207 if test -n "$WINELIB_ROOT"
2208 then
2209   WINELIB_INCLUDE_ROOT="$WINELIB_ROOT/include";
2210   WINELIB_LIBRARY_ROOT="$WINELIB_ROOT";
2211   WINELIB_TOOL_PATH="$WINELIB_ROOT:$WINELIB_ROOT/bin:$WINELIB_ROOT/tools/wrc:$WINELIB_ROOT/tools/winebuild:$PATH";
2212 fi
2213
2214 AC_ARG_WITH(winelib-includes,
2215 [  --with-winelib-includes=DIR   take the Winelib includes from this directory],
2216 [if test "$withval" != "no"; then
2217   WINELIB_INCLUDES="$withval";
2218 else
2219   WINELIB_INCLUDES="";
2220 fi])
2221 if test -n "$WINELIB_INCLUDES"
2222 then
2223   WINELIB_INCLUDE_ROOT="$WINELIB_INCLUDES";
2224 fi
2225
2226 AC_ARG_WITH(winelib-libraries,
2227 [  --with-winelib-libraries=DIR  take the Winelib libraries from this directory],
2228 [if test "$withval" != "no"; then
2229   WINELIB_LIBRARIES="$withval";
2230 else
2231   WINELIB_LIBRARIES="";
2232 fi])
2233 if test -n "$WINELIB_LIBRARIES"
2234 then
2235   WINELIB_LIBRARY_ROOT="$WINELIB_LIBRARIES";
2236 fi
2237
2238 AC_ARG_WITH(winelib-tools,
2239 [  --with-winelib-tools=DIR      take the Winelib tools from this directory],
2240 [if test "$withval" != "no"; then
2241   WINELIB_TOOLS="$withval";
2242 else
2243   WINELIB_TOOLS="";
2244 fi])
2245 if test -n "$WINELIB_TOOLS"
2246 then
2247   WINELIB_TOOL_PATH="$WINELIB_TOOLS:$WINELIB_TOOLS/wrc:$WINELIB_TOOLS/winebuild";
2248 fi
2249
2250 if test -z "$WINELIB_INCLUDE_ROOT"
2251 then
2252   WINELIB_INCLUDE_ROOT="/usr/include/wine";
2253 fi
2254 if test ! -f "$WINELIB_INCLUDE_ROOT/windows.h"
2255 then
2256   AC_MSG_ERROR([Could not find the Winelib includes])
2257 fi
2258 WINELIB_INCLUDE_PATH="-I$WINELIB_INCLUDE_ROOT"
2259
2260 if test -z "$WINELIB_LIBRARY_ROOT"
2261 then
2262   WINELIB_LIBRARY_ROOT="/usr/lib/wine";
2263 fi
2264 if test ! -f "$WINELIB_LIBRARY_ROOT/libwine.so"
2265 then
2266   if test -f "$WINELIB_LIBRARY_ROOT/lib/libwine.so"
2267   then
2268     WINELIB_LIBRARY_ROOT="$WINELIB_LIBRARY_ROOT/lib";
2269   else
2270     AC_MSG_ERROR([Could not find the Winelib libraries (libwine)])
2271   fi
2272 fi
2273 if test -f "$WINELIB_LIBRARY_ROOT/libkernel32.so"
2274 then
2275   WINELIB_LIBRARY_PATH="-L$WINELIB_LIBRARY_ROOT";
2276 else
2277   if test -f "$WINELIB_LIBRARY_ROOT/dlls/libkernel32.so"
2278   then
2279     WINELIB_LIBRARY_PATH="-L$WINELIB_LIBRARY_ROOT -L$WINELIB_LIBRARY_ROOT/dlls";
2280   else
2281     AC_MSG_ERROR([Could not find the Winelib libraries (libkernel32)])
2282   fi
2283 fi
2284
2285 AC_PATH_PROG(WINEBUILD,winebuild,,$WINELIB_TOOL_PATH)
2286 if test -z "$WINEBUILD"
2287 then
2288   AC_MSG_ERROR([Could not find Winelib's winebuild tool])
2289 fi
2290 AC_PATH_PROG(WRC,wrc,,$WINELIB_TOOL_PATH)
2291 if test -z "$WRC"
2292 then
2293   AC_MSG_ERROR([Could not find Winelib's wrc tool])
2294 fi
2295
2296 AC_SUBST(WINELIB_INCLUDE_ROOT)
2297 AC_SUBST(WINELIB_INCLUDE_PATH)
2298 AC_SUBST(WINELIB_LIBRARY_ROOT)
2299 AC_SUBST(WINELIB_LIBRARY_PATH)
2300
2301 dnl **** Try to find where the MFC are located ****
2302
2303 if test "x$NEEDS_MFC" = "x1"
2304 then
2305   ATL_INCLUDE_ROOT="";
2306   ATL_INCLUDE_PATH="";
2307   MFC_INCLUDE_ROOT="";
2308   MFC_INCLUDE_PATH="";
2309   MFC_LIBRARY_ROOT="";
2310   MFC_LIBRARY_PATH="";
2311
2312   AC_ARG_WITH(mfc-root,
2313   [  --with-mfc-root=DIR           take the MFC includes and libraries from this directory],
2314   [if test "$withval" != "no"; then
2315     MFC_ROOT="$withval";
2316     ATL_INCLUDES="";
2317     MFC_INCLUDES="";
2318     MFC_LIBRARIES="";
2319   else
2320     MFC_ROOT="";
2321   fi])
2322   if test -n "$MFC_ROOT"
2323   then
2324     ATL_INCLUDE_ROOT="$MFC_ROOT";
2325     MFC_INCLUDE_ROOT="$MFC_ROOT";
2326     MFC_LIBRARY_ROOT="$MFC_ROOT";
2327   fi
2328
2329   AC_ARG_WITH(atl-includes,
2330   [  --with-atl-includes=DIR       take the ATL includes from this directory],
2331   [if test "$withval" != "no"; then
2332     ATL_INCLUDES="$withval";
2333   else
2334     ATL_INCLUDES="";
2335   fi])
2336   if test -n "$ATL_INCLUDES"
2337   then
2338     ATL_INCLUDE_ROOT="$ATL_INCLUDES";
2339   fi
2340
2341   AC_ARG_WITH(mfc-includes,
2342   [  --with-mfc-includes=DIR       take the MFC includes from this directory],
2343   [if test "$withval" != "no"; then
2344     MFC_INCLUDES="$withval";
2345   else
2346     MFC_INCLUDES="";
2347   fi])
2348   if test -n "$MFC_INCLUDES"
2349   then
2350     MFC_INCLUDE_ROOT="$MFC_INCLUDES";
2351   fi
2352
2353   AC_ARG_WITH(mfc-libraries,
2354   [  --with-mfc-libraries=DIR      take the MFC libraries from this directory],
2355   [if test "$withval" != "no"; then
2356     MFC_LIBRARIES="$withval";
2357   else
2358     MFC_LIBRARIES="";
2359   fi])
2360   if test -n "$MFC_LIBRARIES"
2361   then
2362     MFC_LIBRARY_ROOT="$MFC_LIBRARIES";
2363   fi
2364
2365   dnl FIXME: We should have an include path and just iterate through it.
2366   dnl These tests become ugly.
2367   if test -z "$ATL_INCLUDE_ROOT"
2368   then
2369     ATL_INCLUDE_ROOT="/usr/include";
2370   fi
2371   if test ! -f "$ATL_INCLUDE_ROOT/atlbase.h"
2372   then
2373     if test -f "$ATL_INCLUDE_ROOT/atl/atlbase.h"
2374     then
2375       ATL_INCLUDE_ROOT="$ATL_INCLUDE_ROOT/atl"
2376     else
2377       if test -f "$ATL_INCLUDE_ROOT/atl/include/atlbase.h"
2378       then
2379         ATL_INCLUDE_ROOT="$ATL_INCLUDE_ROOT/atl/include"
2380       else
2381         AC_MSG_ERROR([Could not find the ATL includes])
2382       fi
2383     fi
2384   fi
2385   ATL_INCLUDE_PATH="-I$ATL_INCLUDE_ROOT"
2386
2387   if test -z "$MFC_INCLUDE_ROOT"
2388   then
2389     MFC_INCLUDE_ROOT="/usr/include";
2390   fi
2391   if test ! -f "$MFC_INCLUDE_ROOT/afx.h"
2392   then
2393     if test -f "$MFC_INCLUDE_ROOT/mfc/afx.h"
2394     then
2395       MFC_INCLUDE_ROOT="$MFC_INCLUDE_ROOT/mfc"
2396     else
2397       if test -f "$MFC_INCLUDE_ROOT/mfc/include/afx.h"
2398       then
2399         MFC_INCLUDE_ROOT="$MFC_INCLUDE_ROOT/mfc/include"
2400       else
2401         AC_MSG_ERROR([Could not find the MFC includes])
2402       fi
2403     fi
2404   fi
2405   MFC_INCLUDE_PATH="-D_DLL -D_MT -I$ATL_INCLUDE_ROOT -I$MFC_INCLUDE_ROOT -I\$(WINELIB_INCLUDE_ROOT)/mixedcrt"
2406
2407   if test -z "$MFC_LIBRARY_ROOT"
2408   then
2409     MFC_LIBRARY_ROOT="/usr/lib/mfc";
2410   fi
2411   if test -f "$MFC_LIBRARY_ROOT/libmfc.so"
2412   then
2413     MFC_LIBRARY_ROOT="$MFC_LIBRARY_ROOT";
2414   else
2415     if test -f "$MFC_LIBRARY_ROOT/lib/libmfc.so"
2416     then
2417       MFC_LIBRARY_ROOT="$MFC_LIBRARY_ROOT/lib";
2418     else
2419       if test -f "$MFC_LIBRARY_ROOT/mfc/src/libmfc.so"
2420       then
2421         MFC_LIBRARY_ROOT="$MFC_LIBRARY_ROOT/mfc/src";
2422       else
2423         AC_MSG_ERROR([Could not find the MFC library (libmfc)])
2424       fi
2425     fi
2426   fi
2427   MFC_LIBRARY_PATH="-L$MFC_LIBRARY_ROOT"
2428
2429   AC_SUBST(ATL_INCLUDE_ROOT)
2430   AC_SUBST(ATL_INCLUDE_PATH)
2431   AC_SUBST(MFC_INCLUDE_ROOT)
2432   AC_SUBST(MFC_INCLUDE_PATH)
2433   AC_SUBST(MFC_LIBRARY_ROOT)
2434   AC_SUBST(MFC_LIBRARY_PATH)
2435 fi
2436
2437 dnl **** Generate output files ****
2438
2439 MAKE_RULES=Make.rules
2440 AC_SUBST_FILE(MAKE_RULES)
2441
2442 AC_OUTPUT([
2443 Make.rules
2444 ##WINEMAKER_PROJECTS##
2445  ])
2446
2447 echo
2448 echo "Configure finished.  Do 'make' to build the project."
2449 echo
2450
2451 dnl Local Variables:
2452 dnl comment-start: "dnl "
2453 dnl comment-end: ""
2454 dnl comment-start-skip: "\\bdnl\\b\\s *"
2455 dnl compile-command: "autoconf"
2456 dnl End:
2457 --- Make.rules.in ---
2458 # Copyright 2000 Francois Gouget for CodeWeavers
2459 # fgouget@codeweavers.com
2460 #
2461 # Global rules shared by all makefiles     -*-Makefile-*-
2462 #
2463 # Each individual makefile must define the following variables:
2464 # WINELIB_INCLUDE_ROOT: Winelib includes location
2465 # WINELIB_LIBRARY_ROOT: Winelib libraries location
2466 # TOPOBJDIR    : top-level object directory
2467 # SRCDIR       : source directory for this module
2468 #
2469 # Each individual makefile may define the following additional variables:
2470 #
2471 # SUBDIRS      : subdirectories that contain a Makefile
2472 # LIBRARIES    : libraries to be built
2473 # PROGRAMS     : programs to be built
2474 #
2475 # CEXTRA       : extra c flags (e.g. '-Wall')
2476 # CXXEXTRA     : extra c++ flags (e.g. '-Wall')
2477 # WRCEXTRA     : extra wrc flags (e.g. '-p _SysRes')
2478 # DEFINES      : defines (e.g. -DSTRICT)
2479 # INCLUDE_PATH : additional include path
2480 # LIBRARY_PATH : additional library path
2481 # IMPORTS      : additional libraries to link with
2482 #
2483 # C_SRCS       : C sources for the module
2484 # CXX_SRCS     : C++ sources for the module
2485 # RC_SRCS      : resource source files
2486 # SPEC_SRCS    : interface definition files
2487
2488
2489 # Where is Winelib
2490
2491 WINELIB_INCLUDE_ROOT = @WINELIB_INCLUDE_ROOT@
2492 WINELIB_INCLUDE_PATH = @WINELIB_INCLUDE_PATH@
2493 WINELIB_LIBRARY_ROOT = @WINELIB_LIBRARY_ROOT@
2494 WINELIB_LIBRARY_PATH = @WINELIB_LIBRARY_PATH@
2495
2496 # Where are the MFC
2497
2498 ATL_INCLUDE_ROOT = @ATL_INCLUDE_ROOT@
2499 ATL_INCLUDE_PATH = @ATL_INCLUDE_PATH@
2500 MFC_INCLUDE_ROOT = @MFC_INCLUDE_ROOT@
2501 MFC_INCLUDE_PATH = @MFC_INCLUDE_PATH@
2502 MFC_LIBRARY_ROOT = @MFC_LIBRARY_ROOT@
2503 MFC_LIBRARY_PATH = @MFC_LIBRARY_PATH@
2504
2505 # First some useful definitions
2506
2507 SHELL     = /bin/sh
2508 CC        = @CC@
2509 CPP       = @CPP@
2510 CFLAGS    = @CFLAGS@
2511 CXXFLAGS  = @CXXFLAGS@
2512 OPTIONS   = @OPTIONS@ -D_REENTRANT -DWINELIB
2513 X_CFLAGS  = @X_CFLAGS@
2514 X_LIBS    = @X_LIBS@
2515 XLIB      = @X_PRE_LIBS@ @XLIB@ @X_EXTRA_LIBS@
2516 DLL_LINK  = @DLL_LINK@
2517 LIBS      = @LIBS@ $(LIBRARY_PATH)
2518 YACC      = @YACC@
2519 LEX       = @LEX@
2520 LEXLIB    = @LEXLIB@
2521 LN_S      = @LN_S@
2522 DIVINCL   = -I$(SRCDIR) $(WINELIB_INCLUDE_PATH) $(INCLUDE_PATH)
2523 ALLCFLAGS = $(DIVINCL) $(CFLAGS) $(CEXTRA) $(OPTIONS) $(X_CFLAGS) $(DEFINES)
2524 ALLCXXFLAGS = $(DIVINCL) $(CXXFLAGS) $(CXXEXTRA) $(OPTIONS) $(X_CFLAGS) $(DEFINES)
2525 LDCOMBINE = ld -r
2526 LDSHARED  = @LDSHARED@
2527 RM        = rm -f
2528 MV        = mv
2529 MKDIR     = mkdir -p
2530 WINEBUILD = @WINEBUILD@
2531 WRC       = @WRC@
2532 WRCFLAGS  = -r -L
2533 @SET_MAKE@
2534
2535 # Installation infos
2536
2537 INSTALL         = @INSTALL@
2538 INSTALL_PROGRAM = @INSTALL_PROGRAM@
2539 INSTALL_DATA    = @INSTALL_DATA@
2540 prefix          = @prefix@
2541 exec_prefix     = @exec_prefix@
2542 bindir          = @bindir@
2543 libdir          = @libdir@
2544 infodir         = @infodir@
2545 mandir          = @mandir@
2546 prog_manext     = 1
2547 conf_manext     = 5
2548 CLEAN_FILES     = *.o *.a *.so \\\#*\\\# *~ *% .\\\#* *.orig *.rej \
2549                   *.spec.c y.tab.c y.tab.h lex.yy.c core
2550
2551 OBJS = $(SPEC_SRCS:.spec=.spec.o) $(C_SRCS:.c=.o) $(CXX_SRCS:.cpp=.o)
2552
2553 # DLL list
2554
2555 X_DLLS = \
2556         ddraw \
2557         x11drv
2558
2559 DLLS = \
2560         @X_DLLS@ \
2561         advapi32 \
2562         avifil32 \
2563         comctl32 \
2564         comdlg32 \
2565         crtdll \
2566         dciman32 \
2567         dinput \
2568         dplay \
2569         dplayx \
2570         dsound \
2571         gdi32 \
2572         imagehlp \
2573         imm32 \
2574         joystick.drv \
2575         kernel32 \
2576         lz32 \
2577         mcianim.drv \
2578         mciavi.drv \
2579         mcicda.drv \
2580         mciseq.drv \
2581         mciwave.drv \
2582         midimap.drv \
2583         mpr \
2584         msacm.drv \
2585         msacm32 \
2586         msnet32 \
2587         msvfw32 \
2588         odbc32 \
2589         ole32 \
2590         oleaut32 \
2591         olecli32 \
2592         oledlg \
2593         olepro32 \
2594         olesvr32 \
2595         psapi \
2596         rasapi32 \
2597         riched32 \
2598         rpcrt4 \
2599         serialui \
2600         shell32 \
2601         shfolder \
2602         shlwapi \
2603         tapi32 \
2604         ttydrv \
2605         urlmon \
2606         user32 \
2607         version \
2608         w32skrnl \
2609         wineoss.drv \
2610         wineps \
2611         wininet \
2612         winmm \
2613         winspool.drv \
2614         wnaspi32 \
2615         wow32 \
2616         ws2_32 \
2617         wsock32
2618
2619 # Implicit rules
2620
2621 .SUFFIXES: .C .cpp .CPP .cxx .CXX .rc .RC .res .spec .spec.c .spec.o
2622
2623 .c.o:
2624         $(CC) -c $(ALLCFLAGS) -o $@ $<
2625
2626 .C.o:
2627         $(CC) -c $(ALLCFLAGS) -o $@ $<
2628
2629 .cpp.o:
2630         $(CXX) -c $(ALLCXXFLAGS) -o $@ $<
2631
2632 .CPP.o:
2633         $(CXX) -c $(ALLCXXFLAGS) -o $@ $<
2634
2635 .cxx.o:
2636         $(CXX) -c $(ALLCXXFLAGS) -o $@ $<
2637
2638 .CXX.o:
2639         $(CXX) -c $(ALLCXXFLAGS) -o $@ $<
2640
2641 .spec.spec.c:
2642         $(WINEBUILD) @DLLFLAGS@ -o $@ -spec $<
2643
2644 .spec.c.spec.o:
2645         $(CC) -c $(ALLCFLAGS) @GCC_NO_BUILTIN@ -o $@ $<
2646
2647 .rc.res:
2648         $(WRC) $(WRCFLAGS) $(WRCEXTRA) $(DIVINCL) -o $@ $<
2649
2650 .RC.res:
2651         $(WRC) $(WRCFLAGS) $(WRCEXTRA) $(DIVINCL) -o $@ $<
2652
2653 .PHONY: all install uninstall clean distclean depend dummy
2654
2655 # 'all' target first in case the enclosing Makefile didn't define any target
2656
2657 all: Makefile
2658
2659 # Rules for makefile
2660
2661 Makefile: Makefile.in $(TOPSRCDIR)/configure
2662         @echo Makefile is older than $?, please rerun $(TOPSRCDIR)/configure
2663         @exit 1
2664
2665 # Rules for cleaning
2666
2667 $(SUBDIRS:%=%/__clean__): dummy
2668         cd `dirname $@` && $(MAKE) clean
2669
2670 $(EXTRASUBDIRS:%=%/__clean__): dummy
2671         -cd `dirname $@` && $(RM) $(CLEAN_FILES)
2672
2673 clean:: $(SUBDIRS:%=%/__clean__) $(EXTRASUBDIRS:%=%/__clean__)
2674         $(RM) $(CLEAN_FILES) $(RC_SRCS:.rc=.res) $(LIBRARIES) $(PROGRAMS)
2675
2676 # Rules for installing
2677
2678 $(SUBDIRS:%=%/__install__): dummy
2679         cd `dirname $@` && $(MAKE) install
2680
2681 $(SUBDIRS:%=%/__uninstall__): dummy
2682         cd `dirname $@` && $(MAKE) uninstall
2683
2684 # Misc. rules
2685
2686 $(SUBDIRS): dummy
2687         @cd $@ && $(MAKE)
2688
2689 dummy:
2690
2691 # End of global rules
2692 --- wrapper.c ---
2693 /*
2694  * Copyright 2000 Francois Gouget <fgouget@codeweavers.com> for CodeWeavers
2695  */
2696
2697 #include <dlfcn.h>
2698 #include <windows.h>
2699
2700
2701
2702 /*
2703  * Describe the wrapped application
2704  */
2705
2706 /**
2707  * This is either CUIEXE for a console based application or
2708  * GUIEXE for a regular windows application.
2709  */
2710 #define      APP_TYPE      ##WINEMAKER_APP_TYPE##
2711
2712 /**
2713  * This is the application library's base name, i.e. 'hello' if the
2714  * library is called 'libhello.so'.
2715  */
2716 static char* appName     = ##WINEMAKER_APP_NAME##;
2717
2718 /**
2719  * This is the name of the application's Windows module. If left NULL
2720  * then appName is used.
2721  */
2722 static char* appModule   = NULL;
2723
2724 /**
2725  * This is the application's entry point. This is usually "WinMain" for a
2726  * GUIEXE and 'main' for a CUIEXE application.
2727  */
2728 static char* appInit     = ##WINEMAKER_APP_INIT##;
2729
2730 /**
2731  * This is either non-NULL for MFC-based applications and is the name of the
2732  * MFC's module. This is the module in which we will take the 'WinMain'
2733  * function.
2734  */
2735 static char* mfcModule   = ##WINEMAKER_APP_MFC##;
2736
2737
2738
2739 /*
2740  * Implement the main.
2741  */
2742
2743 #if APP_TYPE == GUIEXE
2744 typedef int WINAPI (*WinMainFunc)(HINSTANCE hInstance, HINSTANCE hPrevInstance,
2745                                   PSTR szCmdLine, int iCmdShow);
2746 #else
2747 typedef int WINAPI (*MainFunc)(int argc, char** argv, char** envp);
2748 #endif
2749
2750 #if APP_TYPE == GUIEXE
2751 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
2752                    PSTR szCmdLine, int iCmdShow)
2753 #else
2754 int WINAPI Main(int argc, char** argv, char** envp)
2755 #endif
2756 {
2757     void* appLibrary;
2758     HINSTANCE hApp,hMFC,hMain;
2759     void* appMain;
2760     char* libName;
2761     int retcode;
2762
2763     /* Load the application's library */
2764     libName=(char*)malloc(strlen(appName)+5+3+1);
2765     /* FIXME: we should get the wrapper's path and use that as the base for
2766      * the library
2767      */
2768     sprintf(libName,"./lib%s.so",appName);
2769     appLibrary=dlopen(libName,RTLD_NOW);
2770     if (appLibrary==NULL) {
2771         sprintf(libName,"lib%s.so",appName);
2772         appLibrary=dlopen(libName,RTLD_NOW);
2773     }
2774     if (appLibrary==NULL) {
2775         char format[]="Could not load the %s library:\r\n%s";
2776         char* error;
2777         char* msg;
2778
2779         error=dlerror();
2780         msg=(char*)malloc(strlen(format)+strlen(libName)+strlen(error));
2781         sprintf(msg,format,libName,error);
2782         MessageBox(NULL,msg,"dlopen error",MB_OK);
2783         free(msg);
2784         return 1;
2785     }
2786
2787     /* Then if this application is MFC based, load the MFC module */
2788     /* FIXME: I'm not sure this is really necessary */
2789     if (mfcModule!=NULL) {
2790         hMFC=LoadLibrary(mfcModule);
2791         if (hMFC==NULL) {
2792             char format[]="Could not load the MFC module %s (%d)";
2793             char* msg;
2794
2795             msg=(char*)malloc(strlen(format)+strlen(mfcModule)+11);
2796             sprintf(msg,format,mfcModule,GetLastError());
2797             MessageBox(NULL,msg,"LoadLibrary error",MB_OK);
2798             free(msg);
2799             return 1;
2800         }
2801         /* MFC is a special case: the WinMain is in the MFC library,
2802          * instead of the application's library.
2803          */
2804         hMain=hMFC;
2805     } else {
2806         hMFC=NULL;
2807     }
2808
2809     /* Load the application's module */
2810     if (appModule==NULL) {
2811         appModule=appName;
2812     }
2813     hApp=LoadLibrary(appModule);
2814     if (hApp==NULL) {
2815         char format[]="Could not load the application's module %s (%d)";
2816         char* msg;
2817
2818         msg=(char*)malloc(strlen(format)+strlen(appModule)+11);
2819         sprintf(msg,format,appModule,GetLastError());
2820         MessageBox(NULL,msg,"LoadLibrary error",MB_OK);
2821         free(msg);
2822         return 1;
2823     } else if (hMain==NULL) {
2824         hMain=hApp;
2825     }
2826
2827     /* Get the address of the application's entry point */
2828     appMain=(WinMainFunc*)GetProcAddress(hMain, appInit);
2829     if (appMain==NULL) {
2830         char format[]="Could not get the address of %s (%d)";
2831         char* msg;
2832
2833         msg=(char*)malloc(strlen(format)+strlen(appInit)+11);
2834         sprintf(msg,format,appInit,GetLastError());
2835         MessageBox(NULL,msg,"GetProcAddress error",MB_OK);
2836         free(msg);
2837         return 1;
2838     }
2839
2840     /* And finally invoke the application's entry point */
2841 #if APP_TYPE == GUIEXE
2842     retcode=(*((WinMainFunc)appMain))(hApp,hPrevInstance,szCmdLine,iCmdShow);
2843 #else
2844     retcode=(*((MainFunc)appMain))(argc,argv,envp);
2845 #endif
2846
2847     /* Cleanup and done */
2848     FreeLibrary(hApp);
2849     if (hMFC!=NULL) {
2850         FreeLibrary(hMFC);
2851     }
2852     dlclose(appLibrary);
2853     free(libName);
2854
2855     return retcode;
2856 }