| #!/usr/bin/perl -w |
| ###################################################################### |
| # Do not call this script directly! |
| # |
| # The generate script ensures that @INC is correct before the engine |
| # is executed. |
| # |
| # Copyright (C) 2009 Marius Storm-Olsen <mstormo@gmail.com> |
| ###################################################################### |
| use strict; |
| use File::Basename; |
| use File::Spec; |
| use Cwd; |
| use Generators; |
| use Text::ParseWords; |
| |
| my (%build_structure, %compile_options, @makedry); |
| my $out_dir = getcwd(); |
| my $git_dir = $out_dir; |
| $git_dir =~ s=\\=/=g; |
| $git_dir = dirname($git_dir) while (!-e "$git_dir/git.c" && "$git_dir" ne ""); |
| die "Couldn't find Git repo" if ("$git_dir" eq ""); |
| |
| my @gens = Generators::available(); |
| my $gen = "Vcproj"; |
| |
| sub showUsage |
| { |
| my $genlist = join(', ', @gens); |
| print << "EOM"; |
| generate usage: |
| -g <GENERATOR> --gen <GENERATOR> Specify the buildsystem generator (default: $gen) |
| Available: $genlist |
| -o <PATH> --out <PATH> Specify output directory generation (default: .) |
| --make-out <PATH> Write the output of GNU Make into a file |
| -i <FILE> --in <FILE> Specify input file, instead of running GNU Make |
| -h,-? --help This help |
| EOM |
| exit 0; |
| } |
| |
| # Parse command-line options |
| my $make_out; |
| while (@ARGV) { |
| my $arg = shift @ARGV; |
| if ("$arg" eq "-h" || "$arg" eq "--help" || "$arg" eq "-?") { |
| showUsage(); |
| exit(0); |
| } elsif("$arg" eq "--out" || "$arg" eq "-o") { |
| $out_dir = shift @ARGV; |
| } elsif("$arg" eq "--make-out") { |
| $make_out = shift @ARGV; |
| } elsif("$arg" eq "--gen" || "$arg" eq "-g") { |
| $gen = shift @ARGV; |
| } elsif("$arg" eq "--in" || "$arg" eq "-i") { |
| my $infile = shift @ARGV; |
| open(F, "<$infile") || die "Couldn't open file $infile"; |
| @makedry = <F>; |
| close(F); |
| } else { |
| die "Unknown option: " . $arg; |
| } |
| } |
| |
| # NOT using File::Spec->rel2abs($path, $base) here, as |
| # it fails badly for me in the msysgit environment |
| $git_dir = File::Spec->rel2abs($git_dir); |
| $out_dir = File::Spec->rel2abs($out_dir); |
| my $rel_dir = makeOutRel2Git($git_dir, $out_dir); |
| |
| # Print some information so the user feels informed |
| print << "EOM"; |
| ----- |
| Generator: $gen |
| Git dir: $git_dir |
| Out dir: $out_dir |
| ----- |
| Running GNU Make to figure out build structure... |
| EOM |
| |
| # Pipe a make --dry-run into a variable, if not already loaded from file |
| # Capture the make dry stderr to file for review (will be empty for a release build). |
| |
| my $ErrsFile = "msvc-build-makedryerrors.txt"; |
| @makedry = `make -C $git_dir -n MSVC=1 SKIP_VCPKG=1 V=1 2>$ErrsFile` |
| if !@makedry; |
| # test for an empty Errors file and remove it |
| unlink $ErrsFile if -f -z $ErrsFile; |
| |
| if (defined $make_out) { |
| open OUT, ">" . $make_out; |
| print OUT @makedry; |
| close OUT; |
| } |
| |
| # Parse the make output into usable info |
| parseMakeOutput(); |
| |
| # Finally, ask the generator to start generating.. |
| Generators::generate($gen, $git_dir, $out_dir, $rel_dir, %build_structure); |
| |
| # main flow ends here |
| # ------------------------------------------------------------------------------------------------- |
| |
| |
| # 1) path: /foo/bar/baz 2) path: /foo/bar/baz 3) path: /foo/bar/baz |
| # base: /foo/bar/baz/temp base: /foo/bar base: /tmp |
| # rel: .. rel: baz rel: ../foo/bar/baz |
| sub makeOutRel2Git |
| { |
| my ($path, $base) = @_; |
| my $rel; |
| if ("$path" eq "$base") { |
| return "."; |
| } elsif ($base =~ /^$path/) { |
| # case 1 |
| my $tmp = $base; |
| $tmp =~ s/^$path//; |
| foreach (split('/', $tmp)) { |
| $rel .= "../" if ("$_" ne ""); |
| } |
| } elsif ($path =~ /^$base/) { |
| # case 2 |
| $rel = $path; |
| $rel =~ s/^$base//; |
| $rel = "./$rel"; |
| } else { |
| my $tmp = $base; |
| foreach (split('/', $tmp)) { |
| $rel .= "../" if ("$_" ne ""); |
| } |
| $rel .= $path; |
| } |
| $rel =~ s/\/\//\//g; # simplify |
| $rel =~ s/\/$//; # don't end with / |
| return $rel; |
| } |
| |
| sub parseMakeOutput |
| { |
| print "Parsing GNU Make output to figure out build structure...\n"; |
| my $line = 0; |
| while (my $text = shift @makedry) { |
| my $ate_next; |
| do { |
| $ate_next = 0; |
| $line++; |
| chomp $text; |
| chop $text if ($text =~ /\r$/); |
| if ($text =~ /\\$/) { |
| $text =~ s/\\$//; |
| $text .= shift @makedry; |
| $ate_next = 1; |
| } |
| } while($ate_next); |
| |
| if ($text =~ /^test /) { |
| # options to test (eg -o) may be mistaken for linker options |
| next; |
| } |
| |
| if ($text =~ /^(mkdir|msgfmt) /) { |
| # options to the Portable Object translations |
| # the line "mkdir ... && msgfmt ..." contains no linker options |
| next; |
| } |
| |
| if($text =~ / -c /) { |
| # compilation |
| handleCompileLine($text, $line); |
| |
| } elsif ($text =~ / -o /) { |
| # linking executable |
| handleLinkLine($text, $line); |
| |
| } elsif ($text =~ /\.o / && $text =~ /\.a /) { |
| # libifying |
| handleLibLine($text, $line); |
| # |
| # } elsif ($text =~ /^cp /) { |
| # # copy file around |
| # |
| # } elsif ($text =~ /^rm -f /) { |
| # # shell command |
| # |
| # } elsif ($text =~ /^make[ \[]/) { |
| # # make output |
| # |
| # } elsif ($text =~ /^echo /) { |
| # # echo to file |
| # |
| # } elsif ($text =~ /^if /) { |
| # # shell conditional |
| # |
| # } elsif ($text =~ /^tclsh /) { |
| # # translation stuff |
| # |
| # } elsif ($text =~ /^umask /) { |
| # # handling boilerplates |
| # |
| # } elsif ($text =~ /\$\(\:\)/) { |
| # # ignore |
| # |
| # } elsif ($text =~ /^FLAGS=/) { |
| # # flags check for dependencies |
| # |
| # } elsif ($text =~ /^'\/usr\/bin\/perl' -MError -e/) { |
| # # perl commands for copying files |
| # |
| # } elsif ($text =~ /generate-cmdlist\.sh/) { |
| # # command for generating list of commands |
| # |
| # } elsif ($text =~ /new locations or Tcl/) { |
| # # command for detecting Tcl/Tk changes |
| # |
| # } elsif ($text =~ /mkdir -p/) { |
| # # command creating path |
| # |
| # } elsif ($text =~ /: no custom templates yet/) { |
| # # whatever |
| # |
| # } else { |
| # print "Unhandled (line: $line): $text\n"; |
| } |
| } |
| |
| # use Data::Dumper; |
| # print "Parsed build structure:\n"; |
| # print Dumper(%build_structure); |
| } |
| |
| # variables for the compilation part of each step |
| my (@defines, @incpaths, @cflags, @sources); |
| |
| sub clearCompileStep |
| { |
| @defines = (); |
| @incpaths = (); |
| @cflags = (); |
| @sources = (); |
| } |
| |
| sub removeDuplicates |
| { |
| my (%dupHash, $entry); |
| %dupHash = map { $_, 1 } @defines; |
| @defines = keys %dupHash; |
| |
| %dupHash = map { $_, 1 } @incpaths; |
| @incpaths = keys %dupHash; |
| |
| %dupHash = map { $_, 1 } @cflags; |
| @cflags = keys %dupHash; |
| } |
| |
| sub handleCompileLine |
| { |
| my ($line, $lineno) = @_; |
| my @parts = shellwords($line); |
| my $sourcefile; |
| shift(@parts); # ignore cmd |
| while (my $part = shift @parts) { |
| if ("$part" eq "-o") { |
| # ignore object file |
| shift @parts; |
| } elsif ("$part" eq "-c") { |
| # ignore compile flag |
| } elsif ("$part" eq "-c") { |
| } elsif ($part =~ /^.?-I/) { |
| push(@incpaths, $part); |
| } elsif ($part =~ /^.?-D/) { |
| push(@defines, $part); |
| } elsif ($part =~ /^-/) { |
| push(@cflags, $part); |
| } elsif ($part =~ /\.(c|cc|cpp)$/) { |
| $sourcefile = $part; |
| } else { |
| die "Unhandled compiler option @ line $lineno: $part"; |
| } |
| } |
| @{$compile_options{"${sourcefile}_CFLAGS"}} = @cflags; |
| @{$compile_options{"${sourcefile}_DEFINES"}} = @defines; |
| @{$compile_options{"${sourcefile}_INCPATHS"}} = @incpaths; |
| clearCompileStep(); |
| } |
| |
| sub handleLibLine |
| { |
| my ($line, $lineno) = @_; |
| my (@objfiles, @lflags, $libout, $part); |
| # kill cmd and rm 'prefix' |
| $line =~ s/^rm -f .* && .* rcs //; |
| my @parts = shellwords($line); |
| while ($part = shift @parts) { |
| if ($part =~ /^-/) { |
| push(@lflags, $part); |
| } elsif ($part =~ /\.(o|obj)$/) { |
| push(@objfiles, $part); |
| } elsif ($part =~ /\.(a|lib)$/) { |
| $libout = $part; |
| $libout =~ s/\.a$//; |
| } else { |
| die "Unhandled lib option @ line $lineno: $part"; |
| } |
| } |
| # print "LibOut: '$libout'\nLFlags: @lflags\nOfiles: @objfiles\n"; |
| # exit(1); |
| foreach (@objfiles) { |
| my $sourcefile = $_; |
| $sourcefile =~ s/\.o$/.c/; |
| push(@sources, $sourcefile); |
| push(@cflags, @{$compile_options{"${sourcefile}_CFLAGS"}}); |
| push(@defines, @{$compile_options{"${sourcefile}_DEFINES"}}); |
| push(@incpaths, @{$compile_options{"${sourcefile}_INCPATHS"}}); |
| } |
| removeDuplicates(); |
| |
| push(@{$build_structure{"LIBS"}}, $libout); |
| @{$build_structure{"LIBS_${libout}"}} = ("_DEFINES", "_INCLUDES", "_CFLAGS", "_SOURCES", |
| "_OBJECTS"); |
| @{$build_structure{"LIBS_${libout}_DEFINES"}} = @defines; |
| @{$build_structure{"LIBS_${libout}_INCLUDES"}} = @incpaths; |
| @{$build_structure{"LIBS_${libout}_CFLAGS"}} = @cflags; |
| @{$build_structure{"LIBS_${libout}_LFLAGS"}} = @lflags; |
| @{$build_structure{"LIBS_${libout}_SOURCES"}} = @sources; |
| @{$build_structure{"LIBS_${libout}_OBJECTS"}} = @objfiles; |
| clearCompileStep(); |
| } |
| |
| sub handleLinkLine |
| { |
| my ($line, $lineno) = @_; |
| my (@objfiles, @lflags, @libs, $appout, $part); |
| my @parts = shellwords($line); |
| shift(@parts); # ignore cmd |
| while ($part = shift @parts) { |
| if ($part =~ /^-IGNORE/) { |
| push(@lflags, $part); |
| } elsif ($part =~ /^-[GRIMDO]/) { |
| # eat compiler flags |
| } elsif ("$part" eq "-o") { |
| $appout = shift @parts; |
| } elsif ("$part" eq "-lz") { |
| push(@libs, "zlib.lib"); |
| } elsif ("$part" eq "-lcrypto") { |
| push(@libs, "libcrypto.lib"); |
| } elsif ("$part" eq "-lssl") { |
| push(@libs, "libssl.lib"); |
| } elsif ("$part" eq "-lcurl") { |
| push(@libs, "libcurl.lib"); |
| } elsif ("$part" eq "-lexpat") { |
| push(@libs, "libexpat.lib"); |
| } elsif ("$part" eq "-liconv") { |
| push(@libs, "iconv.lib"); |
| } elsif ($part =~ /^[-\/]/) { |
| push(@lflags, $part); |
| } elsif ($part =~ /\.(a|lib)$/) { |
| $part =~ s/\.a$/.lib/; |
| push(@libs, $part); |
| } elsif ($part eq 'invalidcontinue.obj') { |
| # ignore - known to MSVC |
| } elsif ($part =~ /\.o$/) { |
| push(@objfiles, $part); |
| } elsif ($part =~ /\.obj$/) { |
| # do nothing, 'make' should not be producing .obj, only .o files |
| } else { |
| die "Unhandled link option @ line $lineno: $part"; |
| } |
| } |
| # print "AppOut: '$appout'\nLFlags: @lflags\nLibs : @libs\nOfiles: @objfiles\n"; |
| # exit(1); |
| foreach (@objfiles) { |
| my $sourcefile = $_; |
| $sourcefile =~ s/\.o$/.c/; |
| push(@sources, $sourcefile); |
| push(@cflags, @{$compile_options{"${sourcefile}_CFLAGS"}}); |
| push(@defines, @{$compile_options{"${sourcefile}_DEFINES"}}); |
| push(@incpaths, @{$compile_options{"${sourcefile}_INCPATHS"}}); |
| } |
| removeDuplicates(); |
| |
| removeDuplicates(); |
| push(@{$build_structure{"APPS"}}, $appout); |
| @{$build_structure{"APPS_${appout}"}} = ("_DEFINES", "_INCLUDES", "_CFLAGS", "_LFLAGS", |
| "_SOURCES", "_OBJECTS", "_LIBS"); |
| @{$build_structure{"APPS_${appout}_DEFINES"}} = @defines; |
| @{$build_structure{"APPS_${appout}_INCLUDES"}} = @incpaths; |
| @{$build_structure{"APPS_${appout}_CFLAGS"}} = @cflags; |
| @{$build_structure{"APPS_${appout}_LFLAGS"}} = @lflags; |
| @{$build_structure{"APPS_${appout}_SOURCES"}} = @sources; |
| @{$build_structure{"APPS_${appout}_OBJECTS"}} = @objfiles; |
| @{$build_structure{"APPS_${appout}_LIBS"}} = @libs; |
| clearCompileStep(); |
| } |