contrib/buildsystems/engine.pl

   1 #!/usr/bin/perl -w
   2 ######################################################################
   3 # Do not call this script directly!
   4 #
   5 # The generate script ensures that @INC is correct before the engine
   6 # is executed.
   7 #
   8 # Copyright (C) 2009 Marius Storm-Olsen <mstormo@gmail.com>
   9 ######################################################################
  10 use strict;
  11 use File::Basename;
  12 use File::Spec;
  13 use Cwd;
  14 use Generators;
  15 use Text::ParseWords;
  16
  17 my (%build_structure, %compile_options, @makedry);
  18 my $out_dir = getcwd();
  19 my $git_dir = $out_dir;
  20 $git_dir =~ s=\\=/=g;
  21 $git_dir = dirname($git_dir) while (!-e "$git_dir/git.c" && "$git_dir" ne "");
  22 die "Couldn't find Git repo" if ("$git_dir" eq "");
  23
  24 my @gens = Generators::available();
  25 my $gen = "Vcproj";
  26
  27 sub showUsage
  28 {
  29     my $genlist = join(', ', @gens);
  30     print << "EOM";
  31 generate usage:
  32   -g <GENERATOR>  --gen <GENERATOR> Specify the buildsystem generator    (default: $gen)
  33                                     Available: $genlist
  34   -o <PATH>       --out <PATH>      Specify output directory generation  (default: .)
  35                   --make-out <PATH> Write the output of GNU Make into a file
  36   -i <FILE>       --in <FILE>       Specify input file, instead of running GNU Make
  37   -h,-?           --help            This help
  38 EOM
  39     exit 0;
  40 }
  41
  42 # Parse command-line options
  43 my $make_out;
  44 while (@ARGV) {
  45     my $arg = shift @ARGV;
  46     if ("$arg" eq "-h" || "$arg" eq "--help" || "$arg" eq "-?") {
  47         showUsage();
  48         exit(0);
  49     } elsif("$arg" eq "--out" || "$arg" eq "-o") {
  50         $out_dir = shift @ARGV;
  51     } elsif("$arg" eq "--make-out") {
  52         $make_out = shift @ARGV;
  53     } elsif("$arg" eq "--gen" || "$arg" eq "-g") {
  54         $gen = shift @ARGV;
  55     } elsif("$arg" eq "--in" || "$arg" eq "-i") {
  56         my $infile = shift @ARGV;
  57         open(F, "<$infile") || die "Couldn't open file $infile";
  58         @makedry = <F>;
  59         close(F);
  60     } else {
  61         die "Unknown option: " . $arg;
  62     }
  63 }
  64
  65 # NOT using File::Spec->rel2abs($path, $base) here, as
  66 # it fails badly for me in the msysgit environment
  67 $git_dir = File::Spec->rel2abs($git_dir);
  68 $out_dir = File::Spec->rel2abs($out_dir);
  69 my $rel_dir = makeOutRel2Git($git_dir, $out_dir);
  70
  71 # Print some information so the user feels informed
  72 print << "EOM";
  73 -----
  74 Generator: $gen
  75 Git dir:   $git_dir
  76 Out dir:   $out_dir
  77 -----
  78 Running GNU Make to figure out build structure...
  79 EOM
  80
  81 # Pipe a make --dry-run into a variable, if not already loaded from file
  82 # Capture the make dry stderr to file for review (will be empty for a release build).
  83
  84 my $ErrsFile = "msvc-build-makedryerrors.txt";
  85 @makedry = `make -C $git_dir -n MSVC=1 SKIP_VCPKG=1 V=1 2>$ErrsFile`
  86 if !@makedry;
  87 # test for an empty Errors file and remove it
  88 unlink $ErrsFile if -f -z $ErrsFile;
  89
  90 if (defined $make_out) {
  91     open OUT, ">" . $make_out;
  92     print OUT @makedry;
  93     close OUT;
  94 }
  95
  96 # Parse the make output into usable info
  97 parseMakeOutput();
  98
  99 # Finally, ask the generator to start generating..
 100 Generators::generate($gen, $git_dir, $out_dir, $rel_dir, %build_structure);
 101
 102 # main flow ends here
 103 # -------------------------------------------------------------------------------------------------
 104
 105
 106 # 1) path: /foo/bar/baz        2) path: /foo/bar/baz   3) path: /foo/bar/baz
 107 #    base: /foo/bar/baz/temp      base: /foo/bar          base: /tmp
 108 #    rel:  ..                     rel:  baz               rel:  ../foo/bar/baz
 109 sub makeOutRel2Git
 110 {
 111     my ($path, $base) = @_;
 112     my $rel;
 113     if ("$path" eq "$base") {
 114         return ".";
 115     } elsif ($base =~ /^$path/) {
 116         # case 1
 117         my $tmp = $base;
 118         $tmp =~ s/^$path//;
 119         foreach (split('/', $tmp)) {
 120             $rel .= "../" if ("$_" ne "");
 121         }
 122     } elsif ($path =~ /^$base/) {
 123         # case 2
 124         $rel = $path;
 125         $rel =~ s/^$base//;
 126         $rel = "./$rel";
 127     } else {
 128         my $tmp = $base;
 129         foreach (split('/', $tmp)) {
 130             $rel .= "../" if ("$_" ne "");
 131         }
 132         $rel .= $path;
 133     }
 134     $rel =~ s/\/\//\//g; # simplify
 135     $rel =~ s/\/$//;     # don't end with /
 136     return $rel;
 137 }
 138
 139 sub parseMakeOutput
 140 {
 141     print "Parsing GNU Make output to figure out build structure...\n";
 142     my $line = 0;
 143     while (my $text = shift @makedry) {
 144         my $ate_next;
 145         do {
 146             $ate_next = 0;
 147             $line++;
 148             chomp $text;
 149             chop $text if ($text =~ /\r$/);
 150             if ($text =~ /\\$/) {
 151                 $text =~ s/\\$//;
 152                 $text .= shift @makedry;
 153                 $ate_next = 1;
 154             }
 155         } while($ate_next);
 156
 157         if ($text =~ /^test /) {
 158             # options to test (eg -o) may be mistaken for linker options
 159             next;
 160         }
 161
 162         if ($text =~ /^(mkdir|msgfmt) /) {
 163             # options to the Portable Object translations
 164             # the line "mkdir ... && msgfmt ..." contains no linker options
 165             next;
 166         }
 167
 168         if($text =~ / -c /) {
 169             # compilation
 170             handleCompileLine($text, $line);
 171
 172         } elsif ($text =~ / -o /) {
 173             # linking executable
 174             handleLinkLine($text, $line);
 175
 176         } elsif ($text =~ /\.o / && $text =~ /\.a /) {
 177             # libifying
 178             handleLibLine($text, $line);
 179 #
 180 #        } elsif ($text =~ /^cp /) {
 181 #            # copy file around
 182 #
 183 #        } elsif ($text =~ /^rm -f /) {
 184 #            # shell command
 185 #
 186 #        } elsif ($text =~ /^make[ \[]/) {
 187 #            # make output
 188 #
 189 #        } elsif ($text =~ /^echo /) {
 190 #            # echo to file
 191 #
 192 #        } elsif ($text =~ /^if /) {
 193 #            # shell conditional
 194 #
 195 #        } elsif ($text =~ /^tclsh /) {
 196 #            # translation stuff
 197 #
 198 #        } elsif ($text =~ /^umask /) {
 199 #            # handling boilerplates
 200 #
 201 #        } elsif ($text =~ /\$\(\:\)/) {
 202 #            # ignore
 203 #
 204 #        } elsif ($text =~ /^FLAGS=/) {
 205 #            # flags check for dependencies
 206 #
 207 #        } elsif ($text =~ /^'\/usr\/bin\/perl' -MError -e/) {
 208 #            # perl commands for copying files
 209 #
 210 #        } elsif ($text =~ /generate-cmdlist\.sh/) {
 211 #            # command for generating list of commands
 212 #
 213 #        } elsif ($text =~ /new locations or Tcl/) {
 214 #            # command for detecting Tcl/Tk changes
 215 #
 216 #        } elsif ($text =~ /mkdir -p/) {
 217 #            # command creating path
 218 #
 219 #        } elsif ($text =~ /: no custom templates yet/) {
 220 #            # whatever
 221 #
 222 #        } else {
 223 #            print "Unhandled (line: $line): $text\n";
 224         }
 225     }
 226
 227 #    use Data::Dumper;
 228 #    print "Parsed build structure:\n";
 229 #    print Dumper(%build_structure);
 230 }
 231
 232 # variables for the compilation part of each step
 233 my (@defines, @incpaths, @cflags, @sources);
 234
 235 sub clearCompileStep
 236 {
 237     @defines = ();
 238     @incpaths = ();
 239     @cflags = ();
 240     @sources = ();
 241 }
 242
 243 sub removeDuplicates
 244 {
 245     my (%dupHash, $entry);
 246     %dupHash = map { $_, 1 } @defines;
 247     @defines = keys %dupHash;
 248
 249     %dupHash = map { $_, 1 } @incpaths;
 250     @incpaths = keys %dupHash;
 251
 252     %dupHash = map { $_, 1 } @cflags;
 253     @cflags = keys %dupHash;
 254 }
 255
 256 sub handleCompileLine
 257 {
 258     my ($line, $lineno) = @_;
 259     my @parts = shellwords($line);
 260     my $sourcefile;
 261     shift(@parts); # ignore cmd
 262     while (my $part = shift @parts) {
 263         if ("$part" eq "-o") {
 264             # ignore object file
 265             shift @parts;
 266         } elsif ("$part" eq "-c") {
 267             # ignore compile flag
 268         } elsif ("$part" eq "-c") {
 269         } elsif ($part =~ /^.?-I/) {
 270             push(@incpaths, $part);
 271         } elsif ($part =~ /^.?-D/) {
 272             push(@defines, $part);
 273         } elsif ($part =~ /^-/) {
 274             push(@cflags, $part);
 275         } elsif ($part =~ /\.(c|cc|cpp)$/) {
 276             $sourcefile = $part;
 277         } else {
 278             die "Unhandled compiler option @ line $lineno: $part";
 279         }
 280     }
 281     @{$compile_options{"${sourcefile}_CFLAGS"}} = @cflags;
 282     @{$compile_options{"${sourcefile}_DEFINES"}} = @defines;
 283     @{$compile_options{"${sourcefile}_INCPATHS"}} = @incpaths;
 284     clearCompileStep();
 285 }
 286
 287 sub handleLibLine
 288 {
 289     my ($line, $lineno) = @_;
 290     my (@objfiles, @lflags, $libout, $part);
 291     # kill cmd and rm 'prefix'
 292     $line =~ s/^rm -f .* && .* rcs //;
 293     my @parts = shellwords($line);
 294     while ($part = shift @parts) {
 295         if ($part =~ /^-/) {
 296             push(@lflags, $part);
 297         } elsif ($part =~ /\.(o|obj)$/) {
 298             push(@objfiles, $part);
 299         } elsif ($part =~ /\.(a|lib)$/) {
 300             $libout = $part;
 301             $libout =~ s/\.a$//;
 302         } else {
 303             die "Unhandled lib option @ line $lineno: $part";
 304         }
 305     }
 306 #    print "LibOut: '$libout'\nLFlags: @lflags\nOfiles: @objfiles\n";
 307 #    exit(1);
 308     foreach (@objfiles) {
 309         my $sourcefile = $_;
 310         $sourcefile =~ s/\.o$/.c/;
 311         push(@sources, $sourcefile);
 312         push(@cflags, @{$compile_options{"${sourcefile}_CFLAGS"}});
 313         push(@defines, @{$compile_options{"${sourcefile}_DEFINES"}});
 314         push(@incpaths, @{$compile_options{"${sourcefile}_INCPATHS"}});
 315     }
 316     removeDuplicates();
 317
 318     push(@{$build_structure{"LIBS"}}, $libout);
 319     @{$build_structure{"LIBS_${libout}"}} = ("_DEFINES", "_INCLUDES", "_CFLAGS", "_SOURCES",
 320                                              "_OBJECTS");
 321     @{$build_structure{"LIBS_${libout}_DEFINES"}} = @defines;
 322     @{$build_structure{"LIBS_${libout}_INCLUDES"}} = @incpaths;
 323     @{$build_structure{"LIBS_${libout}_CFLAGS"}} = @cflags;
 324     @{$build_structure{"LIBS_${libout}_LFLAGS"}} = @lflags;
 325     @{$build_structure{"LIBS_${libout}_SOURCES"}} = @sources;
 326     @{$build_structure{"LIBS_${libout}_OBJECTS"}} = @objfiles;
 327     clearCompileStep();
 328 }
 329
 330 sub handleLinkLine
 331 {
 332     my ($line, $lineno) = @_;
 333     my (@objfiles, @lflags, @libs, $appout, $part);
 334     my @parts = shellwords($line);
 335     shift(@parts); # ignore cmd
 336     while ($part = shift @parts) {
 337         if ($part =~ /^-IGNORE/) {
 338             push(@lflags, $part);
 339         } elsif ($part =~ /^-[GRIMDO]/) {
 340             # eat compiler flags
 341         } elsif ("$part" eq "-o") {
 342             $appout = shift @parts;
 343         } elsif ("$part" eq "-lz") {
 344             push(@libs, "zlib.lib");
 345         } elsif ("$part" eq "-lcrypto") {
 346             push(@libs, "libcrypto.lib");
 347         } elsif ("$part" eq "-lssl") {
 348             push(@libs, "libssl.lib");
 349         } elsif ("$part" eq "-lcurl") {
 350             push(@libs, "libcurl.lib");
 351         } elsif ("$part" eq "-lexpat") {
 352             push(@libs, "expat.lib");
 353         } elsif ("$part" eq "-liconv") {
 354             push(@libs, "libiconv.lib");
 355         } elsif ($part =~ /^[-\/]/) {
 356             push(@lflags, $part);
 357         } elsif ($part =~ /\.(a|lib)$/) {
 358             $part =~ s/\.a$/.lib/;
 359             push(@libs, $part);
 360         } elsif ($part eq 'invalidcontinue.obj') {
 361             # ignore - known to MSVC
 362         } elsif ($part =~ /\.o$/) {
 363             push(@objfiles, $part);
 364         } elsif ($part =~ /\.obj$/) {
 365             # do nothing, 'make' should not be producing .obj, only .o files
 366         } else {
 367             die "Unhandled link option @ line $lineno: $part";
 368         }
 369     }
 370 #    print "AppOut: '$appout'\nLFlags: @lflags\nLibs  : @libs\nOfiles: @objfiles\n";
 371 #    exit(1);
 372     foreach (@objfiles) {
 373         my $sourcefile = $_;
 374         $sourcefile =~ s/\.o$/.c/;
 375         push(@sources, $sourcefile);
 376         push(@cflags, @{$compile_options{"${sourcefile}_CFLAGS"}});
 377         push(@defines, @{$compile_options{"${sourcefile}_DEFINES"}});
 378         push(@incpaths, @{$compile_options{"${sourcefile}_INCPATHS"}});
 379     }
 380     removeDuplicates();
 381
 382     removeDuplicates();
 383     push(@{$build_structure{"APPS"}}, $appout);
 384     @{$build_structure{"APPS_${appout}"}} = ("_DEFINES", "_INCLUDES", "_CFLAGS", "_LFLAGS",
 385                                              "_SOURCES", "_OBJECTS", "_LIBS");
 386     @{$build_structure{"APPS_${appout}_DEFINES"}} = @defines;
 387     @{$build_structure{"APPS_${appout}_INCLUDES"}} = @incpaths;
 388     @{$build_structure{"APPS_${appout}_CFLAGS"}} = @cflags;
 389     @{$build_structure{"APPS_${appout}_LFLAGS"}} = @lflags;
 390     @{$build_structure{"APPS_${appout}_SOURCES"}} = @sources;
 391     @{$build_structure{"APPS_${appout}_OBJECTS"}} = @objfiles;
 392     @{$build_structure{"APPS_${appout}_LIBS"}} = @libs;
 393     clearCompileStep();
 394 }