xref: /aoo41x/main/solenv/bin/deliver.pl (revision f76c8802)
1:
2eval 'exec perl -wS $0 ${1+"$@"}'
3    if 0;
4#**************************************************************
5#
6#  Licensed to the Apache Software Foundation (ASF) under one
7#  or more contributor license agreements.  See the NOTICE file
8#  distributed with this work for additional information
9#  regarding copyright ownership.  The ASF licenses this file
10#  to you under the Apache License, Version 2.0 (the
11#  "License"); you may not use this file except in compliance
12#  with the License.  You may obtain a copy of the License at
13#
14#    http://www.apache.org/licenses/LICENSE-2.0
15#
16#  Unless required by applicable law or agreed to in writing,
17#  software distributed under the License is distributed on an
18#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
19#  KIND, either express or implied.  See the License for the
20#  specific language governing permissions and limitations
21#  under the License.
22#
23#**************************************************************
24
25
26
27#
28# deliver.pl - copy from module output tree to solver
29#
30
31use Cwd;
32use File::Basename;
33use File::Copy;
34use File::DosGlob 'glob';
35use File::Path;
36use File::Spec;
37
38#### script id #####
39
40( $script_name = $0 ) =~ s/^.*\b(\w+)\.pl$/$1/;
41
42$id_str = ' $Revision: 275594 $ ';
43$id_str =~ /Revision:\s+(\S+)\s+\$/
44  ? ($script_rev = $1) : ($script_rev = "-");
45
46
47#### globals ####
48
49### valid actions ###
50# if you add a action 'foo', than add 'foo' to this list and
51# implement 'do_foo()' in the implemented actions area
52@action_list        =   (           # valid actions
53                        'copy',
54                        'dos',
55                        'addincpath',
56                        'linklib',
57                        'mkdir',
58                        'symlink',
59                        'touch'
60                        );
61
62# copy filter: files matching these patterns won't be copied by
63# the copy action
64@copy_filter_patterns = (
65                        );
66
67$strip              = '';
68$is_debug           = 0;
69
70$error              = 0;
71$module             = 0;            # module name
72$repository         = 0;            # parent directory of this module
73$base_dir           = 0;            # path to module base directory
74$dlst_file          = 0;            # path to d.lst
75$ilst_ext           = 'ilst';       # extension of image lists
76$umask              = 22;           # default file/directory creation mask
77$dest               = 0;            # optional destination path
78$common_build       = 0;            # do we have common trees?
79$common_dest        = 0;            # common tree on solver
80
81@action_data        = ();           # LoL with all action data
82@macros             = ();           # d.lst macros
83@addincpath_list    = ();           # files which have to be filtered through addincpath
84@dirlist            = ();           # List of 'mkdir' targets
85@zip_list           = ();           # files which have to be zipped
86@common_zip_list    = ();           # common files which have to be zipped
87@log_list           = ();           # LoL for logging all copy and link actions
88@common_log_list    = ();           # LoL for logging all copy and link actions in common_dest
89$logfiledate        = 0;            # Make log file as old as newest delivered file
90$commonlogfiledate  = 0;            # Make log file as old as newest delivered file
91
92$files_copied       = 0;            # statistics
93$files_unchanged    = 0;            # statistics
94
95$opt_force          = 0;            # option force copy
96$opt_check          = 0;            # do actually execute any action
97$opt_zip            = 0;            # create an additional zip file
98$opt_silent         = 0;            # be silent, only report errors
99$opt_verbose        = 0;            # be verbose (former default behaviour)
100$opt_log            = 1;            # create an additional log file
101$opt_link           = 0;            # hard link files into the solver to save disk space
102$opt_deloutput      = 0;            # delete the output tree for the project once successfully delivered
103$opt_checkdlst      = 0;
104$delete_common      = 1;            # for "-delete": if defined delete files from common tree also
105
106if ($^O ne 'cygwin') {              # iz59477 - cygwin needes a dot "." at the end of filenames to disable
107    $maybedot     = '';             # some .exe transformation magic.
108} else {
109    my $cygvernum = `uname -r`;
110    my @cygvernum = split( /\./, $cygvernum);
111    $cygvernum = shift @cygvernum;
112    $cygvernum .= shift @cygvernum;
113    if ( $cygvernum < 17 ) {
114        $maybedot     = '.';
115    } else {
116        $maybedot     = '';               # no longer works with cygwin 1.7. other magic below.
117    }
118}
119
120($gui		= lc($ENV{GUI})) 		|| die "Can't determine 'GUI'. Please set environment.\n";
121$tempcounter        = 0;
122
123# zip is default for RE master builds
124$opt_zip = 1 if ( defined($ENV{DELIVER_TO_ZIP}) && uc($ENV{DELIVER_TO_ZIP}) eq 'TRUE' && ! defined($ENV{CWS_WORK_STAMP}));
125
126$has_symlinks       = 0;            # system supports symlinks
127
128for (@action_list) {
129    $action_hash{$_}++;
130}
131
132# trap normal signals (HUP, INT, PIPE, TERM)
133# for clean up on unexpected termination
134use sigtrap 'handler' => \&cleanup_and_die, 'normal-signals';
135
136#### main ####
137
138parse_options();
139init_globals();
140
141print "$script_name -- version: $script_rev\n" if !$opt_silent;
142
143if ( ! $opt_delete ) {
144    if ( $ENV{GUI} eq 'WNT' ) {
145        if ($ENV{COM} eq 'GCC') {
146            initialize_strip() ;
147        };
148    } else {
149        initialize_strip();
150    }
151}
152
153push_default_actions();
154parse_dlst();
155check_dlst() if $opt_checkdlst;
156walk_action_data();
157walk_addincpath_list();
158write_log() if $opt_log;
159zip_files() if $opt_zip;
160cleanup() if $opt_delete;
161delete_output() if $opt_deloutput;
162print_stats();
163
164exit($error);
165
166#### implemented actions #####
167
168sub do_copy
169{
170    # We need to copy two times:
171    # from the platform dependent output tree
172    # and from the common output tree
173    my ($dependent, $common, $from, $to, $file_list);
174    my $line = shift;
175    my $touch = 0;
176
177    $dependent = expand_macros($line);
178    ($from, $to) = split(' ', $dependent);
179    print "copy dependent: from: $from, to: $to\n" if $is_debug;
180    glob_and_copy($from, $to, $touch);
181
182    if ($delete_common && $common_build && ( $line !~ /%COMMON_OUTDIR%/ ) ) {
183        $line =~ s/%__SRC%/%COMMON_OUTDIR%/ig;
184        if ( $line =~ /%COMMON_OUTDIR%/ ) {
185            $line =~ s/%_DEST%/%COMMON_DEST%/ig;
186            $common = expand_macros($line);
187            ($from, $to) = split(' ', $common);
188            print "copy common: from: $from, to: $to\n" if $is_debug;
189            glob_and_copy($from, $to, $touch);
190        }
191    }
192}
193
194sub do_dos
195{
196    my $line = shift;
197
198    my $command = expand_macros($line);
199    if ( $opt_check ) {
200        print "DOS: $command\n";
201    }
202    else {
203        # HACK: remove MACOSX stuff which is wrongly labled with dos
204        # better: fix broken d.lst
205        return if ( $command =~ /MACOSX/ );
206        $command =~ s#/#\\#g if $^O eq 'MSWin32';
207        system($command);
208    }
209}
210
211sub do_addincpath
212{
213    # just collect all addincpath files, actual filtering is done later
214    my $line = shift;
215    my ($from, $to);
216    my @globbed_files = ();
217
218    $line = expand_macros($line);
219    ($from, $to) = split(' ', $line);
220
221    push( @addincpath_list, @{glob_line($from, $to)});
222}
223
224sub do_linklib
225{
226    my ($lib_base, $lib_major,$from_dir, $to_dir);
227    my $lib = shift;
228    my @globbed_files = ();
229    my %globbed_hash = ();
230
231    print "linklib: $lib\n" if $is_debug;
232    print "has symlinks\n" if ( $has_symlinks && $is_debug );
233
234    return unless $has_symlinks;
235
236    $from_dir = expand_macros('../%__SRC%/lib');
237    $to_dir = expand_macros('%_DEST%/lib%_EXT%');
238
239    @globbed_files = glob("$from_dir/$lib");
240
241    if ( $#globbed_files == -1 ) {
242       return;
243    }
244
245    foreach $lib (@globbed_files) {
246        $lib = basename($lib);
247        if ( $lib =~ /^(lib\S+(\.so|\.dylib))\.(\d+)\.(\d+)(\.(\d+))?$/
248             || $lib =~ /^(lib\S+(\.so|\.dylib))\.(\d+)$/ )
249        {
250           push(@{$globbed_hash{$1}}, $lib);
251        }
252        else {
253            print_warning("invalid library name: $lib");
254        }
255    }
256
257    foreach $lib_base ( sort keys %globbed_hash ) {
258        $lib = get_latest_patchlevel(@{$globbed_hash{$lib_base}});
259
260        if ( $lib =~ /^(lib\S+(\.so|\.dylib))\.(\d+)\.(\d+)(\.(\d+))?$/ )
261        {
262            $lib_major = "$lib_base.$3";
263            $long = 1;
264        }
265        else
266        {
267            # $lib =~ /^(lib[\w-]+(\.so|\.dylib))\.(\d+)$/;
268            $long = 0;
269        }
270
271        if ( $opt_check ) {
272            if ( $opt_delete ) {
273                print "REMOVE: $to_dir/$lib_major\n" if $long;
274                print "REMOVE: $to_dir/$lib_base\n";
275            }
276            else {
277                print "LINKLIB: $to_dir/$lib -> $to_dir/$lib_major\n" if $long;
278                print "LINKLIB: $to_dir/$lib -> $to_dir/$lib_base\n";
279            }
280        }
281        else {
282            if ( $opt_delete ) {
283                print "REMOVE: $to_dir/$lib_major\n" if ($long && $opt_verbose);
284                print "REMOVE: $to_dir/$lib_base\n" if $opt_verbose;
285                unlink "$to_dir/$lib_major" if $long;
286                unlink "$to_dir/$lib_base";
287                if ( $opt_zip ) {
288                    push_on_ziplist("$to_dir/$lib_major") if $long;
289                    push_on_ziplist("$to_dir/$lib_base");
290                }
291                return;
292            }
293            my $symlib;
294            my @symlibs;
295            if ($long)
296            {
297                @symlibs = ("$to_dir/$lib_major", "$to_dir/$lib_base");
298            }
299            else
300            {
301                @symlibs = ("$to_dir/$lib_base");
302            }
303            # remove old symlinks
304            unlink(@symlibs);
305            foreach $symlib (@symlibs) {
306                print "LINKLIB: $lib -> $symlib\n" if $opt_verbose;
307                if ( !symlink("$lib", "$symlib") ) {
308                    print_error("can't symlink $lib -> $symlib: $!",0);
309                }
310                else {
311                    push_on_ziplist($symlib) if $opt_zip;
312                    push_on_loglist("LINK", "$lib", "$symlib") if $opt_log;
313                }
314            }
315        }
316    }
317}
318
319sub do_mkdir
320{
321    my $path = expand_macros(shift);
322    # strip whitespaces from path name
323    $path =~ s/\s$//;
324    if (( ! $opt_delete ) && ( ! -d $path )) {
325        if ( $opt_check ) {
326            print "MKDIR: $path\n";
327        } else {
328            mkpath($path, 0, 0777-$umask);
329            if ( ! -d $path ) {
330                print_error("mkdir: could not create directory '$path'", 0);
331            }
332        }
333    }
334}
335
336sub do_symlink
337{
338    my $line = shift;
339
340    $line = expand_macros($line);
341    ($from, $to) = split(' ',$line);
342    my $fullfrom = $from;
343    if ( dirname($from) eq dirname($to) ) {
344        $from = basename($from);
345    }
346    elsif ( dirname($from) eq '.' ) {
347        # nothing to do
348    }
349    else {
350        print_error("symlink: link must be in the same directory as file",0);
351        return 0;
352    }
353
354    print "symlink: $from, to: $to\n" if $is_debug;
355
356    return unless $has_symlinks;
357
358    if ( $opt_check ) {
359        if ( $opt_delete ) {
360            print "REMOVE: $to\n";
361        }
362        else {
363            print "SYMLINK $from -> $to\n";
364        }
365    }
366    else {
367        print "REMOVE: $to\n" if $opt_verbose;
368        unlink $to;
369        if ( $opt_delete ) {
370            push_on_ziplist($to) if $opt_zip;
371            return;
372        }
373        return unless -e $fullfrom;
374        print "SYMLIB: $from -> $to\n" if $opt_verbose;
375        if ( !symlink("$from", "$to") ) {
376            print_error("can't symlink $from -> $to: $!",0);
377        }
378        else {
379            push_on_ziplist($to) if $opt_zip;
380            push_on_loglist("LINK", "$from", "$to") if $opt_log;
381        }
382    }
383}
384
385sub do_touch
386{
387    my ($from, $to);
388    my $line = shift;
389    my $touch = 1;
390
391    $line = expand_macros($line);
392    ($from, $to) = split(' ', $line);
393    print "touch: $from, to: $to\n" if $is_debug;
394    glob_and_copy($from, $to, $touch);
395}
396
397#### subroutines #####
398
399sub parse_options
400{
401    my $arg;
402    my $dontdeletecommon = 0;
403    $opt_silent = 1 if ( defined $ENV{VERBOSE} && $ENV{VERBOSE} eq 'FALSE');
404    $opt_verbose = 1 if ( defined $ENV{VERBOSE} && $ENV{VERBOSE} eq 'TRUE');
405    while ( $arg = shift @ARGV ) {
406        $arg =~ /^-force$/      and $opt_force  = 1  and next;
407        $arg =~ /^-check$/      and $opt_check  = 1  and $opt_verbose = 1 and next;
408        $arg =~ /^-quiet$/      and $opt_silent = 1  and next;
409        $arg =~ /^-verbose$/    and $opt_verbose = 1 and next;
410        $arg =~ /^-zip$/        and $opt_zip    = 1  and next;
411        $arg =~ /^-delete$/     and $opt_delete = 1  and next;
412        $arg =~ /^-dontdeletecommon$/ and $dontdeletecommon = 1 and next;
413        $arg =~ /^-help$/       and $opt_help   = 1  and $arg = '';
414        $arg =~ /^-link$/       and $ENV{GUI} ne 'WNT' and $opt_link = 1 and next;
415        $arg =~ /^-deloutput$/  and $opt_deloutput = 1 and next;
416        $arg =~ /^-debug$/      and $is_debug   = 1  and next;
417        $arg =~ /^-checkdlst$/  and $opt_checkdlst = 1 and next;
418        print_error("invalid option $arg") if ( $arg =~ /^-/ );
419        if ( $arg =~ /^-/ || $opt_help || $#ARGV > -1 ) {
420            usage(1);
421        }
422        $dest = $arg;
423    }
424    # $dest and $opt_zip or $opt_delete are mutually exclusive
425    if ( $dest and ($opt_zip || $opt_delete) ) {
426        usage(1);
427    }
428    # $opt_silent and $opt_check or $opt_verbose are mutually exclusive
429    if ( ($opt_check or $opt_verbose) and $opt_silent ) {
430        print STDERR "Error on command line: options '-check' and '-quiet' are mutually exclusive.\n";
431        usage(1);
432    }
433    if ($dontdeletecommon) {
434        if (!$opt_delete) {
435            usage(1);
436        }
437        $delete_common = 0;
438    };
439    # $opt_delete implies $opt_force
440    $opt_force = 1 if $opt_delete;
441}
442
443sub init_globals
444{
445    my $ext;
446    ($module, $repository, $base_dir, $dlst_file) =  get_base();
447
448    # for CWS:
449    $module =~ s/\.lnk$//;
450
451    print "Module=$module, Base_Dir=$base_dir, d.lst=$dlst_file\n" if $is_debug;
452
453    $umask = umask();
454    if ( !defined($umask) ) {
455        $umask = 22;
456    }
457
458    my $build_sosl    = $ENV{'BUILD_SOSL'};
459    my $common_outdir = $ENV{'COMMON_OUTDIR'};
460    my $inpath        = $ENV{'INPATH'};
461    my $solarversion  = $ENV{'SOLARVERSION'};
462    my $updater       = $ENV{'UPDATER'};
463    my $updminor      = $ENV{'UPDMINOR'};
464    my $updminorext   = $ENV{'UPDMINOREXT'};
465    my $work_stamp    = $ENV{'WORK_STAMP'};
466
467    $::CC_PATH=(fileparse( $ENV{"CC"}))[1];
468
469    # special security check for release engineers
470    if ( defined($updater) && !defined($build_sosl) && !$opt_force) {
471        my $path = getcwd();
472        if ( $path !~ /$work_stamp/io ) {
473            print_error("can't deliver from local directory to SOLARVERSION");
474            print STDERR "\nDANGER! Release Engineer:\n";
475            print STDERR "do you really want to deliver from $path to SOLARVERSION?\n";
476            print STDERR "If so, please use the -force switch\n\n";
477            exit(7);
478        }
479    }
480
481    # do we have a valid environment?
482    if ( !defined($inpath) ) {
483            print_error("no environment", 0);
484            exit(3);
485    }
486
487    $ext = "";
488    if ( ($updminor) && !$dest ) {
489        $ext = "$updminorext";
490    }
491
492    # Do we have common trees?
493    if ( defined($ENV{'common_build'}) && $ENV{'common_build'} eq 'TRUE' ) {
494        $common_build = 1;
495        if ((defined $common_outdir) && ($common_outdir ne "")) {
496            $common_outdir = $common_outdir . ".pro" if $inpath =~ /\.pro$/;
497            if ( $dest ) {
498                $common_dest = $dest;
499            } else {
500                $common_dest = "$solarversion/$common_outdir";
501                $dest = "$solarversion/$inpath";
502            }
503        } else {
504            print_error("common_build defined without common_outdir", 0);
505            exit(6);
506        }
507    } else {
508        $common_outdir = $inpath;
509        $dest = "$solarversion/$inpath" if ( !$dest );
510        $common_dest = $dest;
511    }
512    $dest =~ s#\\#/#g;
513    $common_dest =~ s#\\#/#g;
514
515    # the following macros are obsolete, will be flagged as error
516    # %__WORKSTAMP%
517    # %GUIBASE%
518    # %SDK%
519    # %SOLARVER%
520    # %__OFFENV%
521    # %DLLSUFFIX%'
522    # %OUTPATH%
523    # %L10N_FRAMEWORK%
524    # %UPD%
525
526    # valid macros
527    @macros = (
528                [ '%__PRJROOT%',        $base_dir       ],
529                [ '%__SRC%',            $inpath         ],
530                [ '%_DEST%',            $dest           ],
531                [ '%_EXT%',             $ext            ],
532                [ '%COMMON_OUTDIR%',    $common_outdir  ],
533                [ '%COMMON_DEST%',      $common_dest    ],
534                [ '%GUI%',              $gui            ]
535              );
536
537    # find out if the system supports symlinks
538    $has_symlinks = eval { symlink("",""); 1 };
539}
540
541sub get_base
542{
543    # a module base dir contains a subdir 'prj'
544    # which in turn contains a file 'd.lst'
545    my (@field, $repo, $base, $dlst);
546    my $path = getcwd();
547
548    @field = split(/\//, $path);
549
550    while ( $#field != -1 ) {
551        $base = join('/', @field);
552        $dlst = $base . '/prj/d.lst';
553        last if -e $dlst;
554        pop @field;
555    }
556
557    if ( $#field == -1 ) {
558        print_error("can't find d.lst");
559        exit(2);
560    }
561    else {
562        if ( defined $field[-2] ) {
563            $repo = $field[-2];
564        } else {
565            print_error("Internal error: cannot determine module's parent directory");
566        }
567        return ($field[-1], $repo, $base, $dlst);
568    }
569}
570
571sub parse_dlst
572{
573    my $line_cnt = 0;
574    open(DLST, "<$dlst_file") or die "can't open d.lst";
575    while(<DLST>) {
576        $line_cnt++;
577        tr/\r\n//d;
578        next if /^#/;
579        next if /^\s*$/;
580        if (!$delete_common && /%COMMON_DEST%/) {
581            # Just ignore all lines with %COMMON_DEST%
582            next;
583        };
584        if ( /^\s*(\w+?):\s+(.*)$/ ) {
585            if ( !exists $action_hash{$1} ) {
586                print_error("unknown action: \'$1\'", $line_cnt);
587                exit(4);
588            }
589            push(@action_data, [$1, $2]);
590        }
591        else {
592            if ( /^\s*%(COMMON)?_DEST%\\/ ) {
593                # only copy from source dir to solver, not from solver to solver
594                print_warning("illegal copy action, ignored: \'$_\'", $line_cnt);
595                next;
596            }
597            push(@action_data, ['copy', $_]);
598            # for each ressource file (.res) copy its image list (.ilst)
599            if ( /\.res\s/ ) {
600                my $imagelist = $_;
601                $imagelist =~ s/\.res/\.$ilst_ext/g;
602                $imagelist =~ s/\\bin%_EXT%\\/\\res%_EXT%\\img\\/;
603                push(@action_data, ['copy', $imagelist]);
604            }
605        }
606        # call expand_macros()just to find any undefined macros early
607        # real expansion is done later
608        expand_macros($_, $line_cnt);
609    }
610    close(DLST);
611}
612
613sub expand_macros
614{
615    # expand all macros and change backslashes to slashes
616    my $line        = shift;
617    my $line_cnt    = shift;
618    my $i;
619
620    for ($i=0; $i<=$#macros; $i++)  {
621        $line =~ s/$macros[$i][0]/$macros[$i][1]/gi
622    }
623    if ( $line =~ /(%\w+%)/ ) {
624        if ( $1 ne '%OS%' ) {   # %OS% looks like a macro but is not ...
625            print_error("unknown/obsolete macro: \'$1\'", $line_cnt);
626        }
627    }
628    $line =~ s#\\#/#g;
629    return $line;
630}
631
632sub walk_action_data
633{
634    # all actions have to be excuted relative to the prj directory
635    chdir("$base_dir/prj");
636    # dispatch depending on action type
637    for (my $i=0; $i <= $#action_data; $i++) {
638            &{"do_".$action_data[$i][0]}($action_data[$i][1]);
639            if ( $action_data[$i][0] eq 'mkdir' ) {
640                # fill array with (possibly) created directories in
641                # revers order for removal in 'cleanup'
642                unshift @dirlist, $action_data[$i][1];
643            }
644    }
645}
646
647sub glob_line
648{
649    my $from = shift;
650    my $to = shift;
651    my $to_dir = shift;
652    my $replace = 0;
653    my @globbed_files = ();
654
655    if ( ! ( $from && $to ) ) {
656        print_warning("Error in d.lst? source: '$from' destination: '$to'");
657        return \@globbed_files;
658    }
659
660    if ( $to =~ /[\*\?\[\]]/ ) {
661        my $to_fname;
662        ($to_fname, $to_dir) = fileparse($to);
663        $replace = 1;
664    }
665
666    if ( $from =~ /[\*\?\[\]]/ ) {
667        # globbing necessary, no renaming possible
668        my $file;
669        my @file_list = glob($from);
670
671        foreach $file ( @file_list ) {
672            next if ( -d $file); # we only copy files, not directories
673            my ($fname, $dir) = fileparse($file);
674            my $copy = ($replace) ? $to_dir . $fname : $to . '/' . $fname;
675            push(@globbed_files, [$file, $copy]);
676        }
677    }
678    else {
679        # no globbing but renaming possible
680        # #i89066#
681        if (-d $to && -f $from) {
682            my $filename = File::Basename::basename($from);
683            $to .= '/' if ($to !~ /[\\|\/]$/);
684            $to .= $filename;
685        };
686        push(@globbed_files, [$from, $to]);
687    }
688    if ( $opt_checkdlst ) {
689        my $outtree = expand_macros("%__SRC%");
690        my $commonouttree = expand_macros("%COMMON_OUTDIR%");
691        if (( $from !~ /\Q$outtree\E/ ) && ( $from !~ /\Q$commonouttree\E/ )) {
692            print_warning("'$from' does not match any file") if ( $#globbed_files == -1 );
693        }
694    }
695    return \@globbed_files;
696}
697
698
699sub glob_and_copy
700{
701    my $from = shift;
702    my $to = shift;
703    my $touch = shift;
704
705    my @copy_files = @{glob_line($from, $to)};
706
707    for (my $i = 0; $i <= $#copy_files; $i++) {
708        next if filter_out($copy_files[$i][0]); # apply copy filter
709        copy_if_newer($copy_files[$i][0], $copy_files[$i][1], $touch)
710                    ? $files_copied++ : $files_unchanged++;
711    }
712}
713
714sub is_unstripped {
715    my $file_name = shift;
716    my $nm_output;
717
718    if (-f $file_name.$maybedot) {
719        my $file_type = `file $file_name`;
720        # OS X file command doesn't know if a file is stripped or not
721        if (($file_type =~ /not stripped/o) || ($file_type =~ /Mach-O/o) ||
722            (($file_type =~ /PE/o) && ($ENV{GUI} eq 'WNT') &&
723             ($nm_output = `nm $file_name 2>&1`) && $nm_output &&
724             !($nm_output =~ /no symbols/i) && !($nm_output =~ /not recognized/i))) {
725            return '1' if ($file_name =~ /\.bin$/o);
726            return '1' if ($file_name =~ /\.so\.*/o);
727            return '1' if ($file_name =~ /\.dylib\.*/o);
728            return '1' if ($file_name =~ /\.com\.*/o);
729            return '1' if ($file_name =~ /\.dll\.*/o);
730            return '1' if ($file_name =~ /\.exe\.*/o);
731            return '1' if (basename($file_name) !~ /\./o);
732        }
733    };
734    return '';
735}
736
737sub initialize_strip {
738    if ((!defined $ENV{DISABLE_STRIP}) || ($ENV{DISABLE_STRIP} eq "")) {
739        $strip .= 'guw ' if ($^O eq 'cygwin');
740        $strip .= $::CC_PATH if (-e $::CC_PATH.'/strip');
741        $strip .= 'strip';
742        $strip .= " -x" if ($ENV{OS} eq 'MACOSX');
743        $strip .= " -R '.comment' -s" if ($ENV{OS} eq 'LINUX');
744    };
745};
746
747sub is_jar {
748    my $file_name = shift;
749
750    if (-f $file_name && (( `file $file_name` ) =~ /Zip archive/o)) {
751        return '1' if ($file_name =~ /\.jar\.*/o);
752    };
753    return '';
754}
755
756sub execute_system {
757    my $command = shift;
758    if (system($command)) {
759        print_error("Failed to execute $command");
760        exit($?);
761    };
762};
763
764sub strip_target {
765    my $file = shift;
766    my $temp_file = shift;
767    $temp_file =~ s/\/{2,}/\//g;
768    my $rc = copy($file, $temp_file);
769    execute_system("$strip $temp_file");
770    return $rc;
771};
772
773sub copy_if_newer
774{
775    # return 0 if file is unchanged ( for whatever reason )
776    # return 1 if file has been copied
777    my $from = shift;
778    my $to = shift;
779    my $touch = shift;
780    my $from_stat_ref;
781    my $rc = 0;
782
783    print "testing $from, $to\n" if $is_debug;
784    push_on_ziplist($to) if $opt_zip;
785    push_on_loglist("COPY", "$from", "$to") if $opt_log;
786    return 0 unless ($from_stat_ref = is_newer($from, $to, $touch));
787
788    if ( $opt_delete ) {
789        print "REMOVE: $to\n" if $opt_verbose;
790        $rc = unlink($to) unless $opt_check;
791        return 1 if $opt_check;
792        return $rc;
793    }
794
795    if( !$opt_check && $opt_link ) {
796        # hard link if possible
797        if( link($from, $to) ){
798            print "LINK: $from -> $to\n" if $opt_verbose;
799            return 1;
800        }
801    }
802
803    if( $touch ) {
804       print "TOUCH: $from -> $to\n" if $opt_verbose;
805    }
806    else {
807       print "COPY: $from -> $to\n" if $opt_verbose;
808    }
809
810    return 1 if( $opt_check );
811
812    #
813    # copy to temporary file first and rename later
814    # to minimize the possibility for race conditions
815    local $temp_file = sprintf('%s.%d-%d', $to, $$, time());
816    $rc = '';
817    if (($strip ne '') && (defined $ENV{PROEXT}) && (is_unstripped($from))) {
818        $rc = strip_target($from, $temp_file);
819    } else {
820        $rc = copy($from, $temp_file);
821    };
822    if ( $rc) {
823        if ( is_newer($temp_file, $from, 0) ) {
824            $rc = utime($$from_stat_ref[9], $$from_stat_ref[9], $temp_file);
825            if ( !$rc ) {
826                print_warning("can't update temporary file modification time '$temp_file': $!\n
827                               Check file permissions of '$from'.",0);
828            }
829        }
830        fix_file_permissions($$from_stat_ref[2], $temp_file);
831        if ( $^O eq 'os2' )
832        {
833            $rc = unlink($to); # YD OS/2 can't rename if $to exists!
834        }
835        # Ugly hack: on windows file locking(?) sometimes prevents renaming.
836        # Until we've found and fixed the real reason try it repeatedly :-(
837        my $try = 0;
838        my $maxtries = 1;
839        $maxtries = 5 if ( $^O eq 'MSWin32' );
840        my $success = 0;
841        while ( $try < $maxtries && ! $success ) {
842            sleep $try;
843            $try ++;
844            $success = rename($temp_file, $to);
845            if ( $^O eq 'cygwin' && $to =~ /\.bin$/) {
846                # hack to survive automatically added .exe for executables renamed to
847                # *.bin - will break if there is intentionally a .bin _and_ .bin.exe file.
848                $success = rename( "$to.exe", $to ) if -f "$to.exe";
849            }
850        }
851        if ( $success ) {
852            # handle special packaging of *.dylib files for Mac OS X
853            if ( $^O eq 'darwin' )
854            {
855                system("macosx-create-bundle", "$to=$from.app") if ( -d "$from.app" );
856                system("ranlib", "$to" ) if ( $to =~ /\.a/ );
857            }
858            if ( $try > 1 ) {
859                print_warning("File '$to' temporarily locked. Dependency bug?");
860            }
861            return 1;
862        }
863        else {
864            print_error("can't rename temporary file to $to: $!",0);
865        }
866    }
867    else {
868        print_error("can't copy $from: $!",0);
869        my $destdir = dirname($to);
870        if ( ! -d $destdir ) {
871            print_error("directory '$destdir' does not exist", 0);
872        }
873    }
874    unlink($temp_file);
875    return 0;
876}
877
878sub is_newer
879{
880        # returns whole stat buffer if newer
881        my $from = shift;
882        my $to = shift;
883        my $touch = shift;
884        my (@from_stat, @to_stat);
885
886        @from_stat = stat($from.$maybedot);
887        if ( $opt_checkdlst ) {
888            my $outtree = expand_macros("%__SRC%");
889            my $commonouttree = expand_macros("%COMMON_OUTDIR%");
890            if ( $from !~ /$outtree/ ) {
891                if ( $from !~ /$commonouttree/ ) {
892                    print_warning("'$from' does not exist") unless -e _;
893                }
894            }
895        }
896        return 0 unless -f _;
897
898        if ( $touch ) {
899            $from_stat[9] = time();
900        }
901        # adjust timestamps to even seconds
902        # this is necessary since NT platforms have a
903        # 2s modified time granularity while the timestamps
904        # on Samba volumes have a 1s granularity
905
906        $from_stat[9]-- if $from_stat[9] % 2;
907
908        if ( $to =~ /^\Q$dest\E/ ) {
909            if ( $from_stat[9] > $logfiledate ) {
910                $logfiledate = $from_stat[9];
911            }
912        } elsif ( $common_build && ( $to =~ /^\Q$common_dest\E/ ) ) {
913            if ( $from_stat[9] > $commonlogfiledate ) {
914                $commonlogfiledate = $from_stat[9];
915            }
916        }
917
918        @to_stat = stat($to.$maybedot);
919        return \@from_stat unless -f _;
920
921        if ( $opt_force ) {
922            return \@from_stat;
923        }
924        else {
925            return ($from_stat[9] > $to_stat[9]) ? \@from_stat : 0;
926        }
927}
928
929sub filter_out
930{
931    my $file = shift;
932
933    foreach my $pattern ( @copy_filter_patterns ) {
934        if  ( $file =~ /$pattern/ ) {
935           print "filter out: $file\n" if $is_debug;
936           return 1;
937        }
938    }
939
940    return 0;
941}
942
943sub fix_file_permissions
944{
945    my $mode = shift;
946    my $file = shift;
947
948    if ( ($mode >> 6) % 2 == 1 ) {
949        $mode = 0777 & ~$umask;
950    }
951    else {
952        $mode = 0666 & ~$umask;
953    }
954    chmod($mode, $file);
955}
956
957sub get_latest_patchlevel
958{
959    # note: feed only well formed library names to this function
960    # of the form libfoo.so.x.y.z with x,y,z numbers
961
962    my @sorted_files = sort by_rev @_;
963    return $sorted_files[-1];
964
965    sub by_rev {
966    # comparison function for sorting
967        my (@field_a, @field_b, $i);
968
969        $a =~ /^(lib[\w-]+(\.so|\.dylib))\.(\d+)\.(\d+)\.(\d+)$/;
970        @field_a = ($3, $4, $5);
971        $b =~ /^(lib[\w-]+(\.so|\.dylib))\.(\d+)\.(\d+)\.(\d+)$/;
972        @field_b = ($3, $4, $5);
973
974        for ($i = 0; $i < 3; $i++)
975          {
976              if ( ($field_a[$i] < $field_b[$i]) ) {
977                  return -1;
978              }
979              if ( ($field_a[$i] > $field_b[$i]) ) {
980                  return 1;
981              }
982          }
983
984        # can't happen
985        return 0;
986    }
987
988}
989
990sub push_default_actions
991{
992    # any default action (that is an action which must be done even without
993    # a corresponding d.lst entry) should be pushed here on the
994    # @action_data list.
995    my $subdir;
996    my @subdirs = (
997                    'bin',
998                    'doc',
999                    'inc',
1000                    'lib',
1001                    'par',
1002                    'pck',
1003                    'rdb',
1004                    'res',
1005                    'tmp',
1006                    'xml'
1007                );
1008    push(@subdirs, 'zip') if $opt_zip;
1009    push(@subdirs, 'idl') if ! $common_build;
1010    push(@subdirs, 'pus') if ! $common_build;
1011    my @common_subdirs = (
1012                    'bin',
1013                    'idl',
1014                    'inc',
1015                    'pck',
1016                    'pus',
1017                    'res'
1018                );
1019    push(@common_subdirs, 'zip') if $opt_zip;
1020
1021    if ( ! $opt_delete ) {
1022        # create all the subdirectories on solver
1023        foreach $subdir (@subdirs) {
1024            push(@action_data, ['mkdir', "%_DEST%/$subdir%_EXT%"]);
1025        }
1026        if ( $common_build ) {
1027            foreach $subdir (@common_subdirs) {
1028                push(@action_data, ['mkdir', "%COMMON_DEST%/$subdir%_EXT%"]);
1029            }
1030        }
1031    }
1032    push(@action_data, ['mkdir', "%_DEST%/inc%_EXT%/$module"]);
1033    if ( $common_build ) {
1034        push(@action_data, ['mkdir', "%COMMON_DEST%/inc%_EXT%/$module"]);
1035        push(@action_data, ['mkdir', "%COMMON_DEST%/res%_EXT%/img"]);
1036    } else {
1037        push(@action_data, ['mkdir', "%_DEST%/res%_EXT%/img"]);
1038    }
1039
1040    # deliver build.lst to $dest/inc/$module
1041    push(@action_data, ['copy', "build.lst %_DEST%/inc%_EXT%/$module/build.lst"]);
1042    if ( $common_build ) {
1043        # ... and to $common_dest/inc/$module
1044        push(@action_data, ['copy', "build.lst %COMMON_DEST%/inc%_EXT%/$module/build.lst"]);
1045    }
1046
1047    # need to copy libstaticmxp.dylib for Mac OS X
1048    if ( $^O eq 'darwin' )
1049    {
1050        push(@action_data, ['copy', "../%__SRC%/lib/lib*static*.dylib %_DEST%/lib%_EXT%/lib*static*.dylib"]);
1051    }
1052}
1053
1054sub walk_addincpath_list
1055{
1056    my (@addincpath_headers);
1057    return if $#addincpath_list == -1;
1058
1059    # create hash with all addincpath header names
1060    for (my $i = 0; $i <= $#addincpath_list; $i++) {
1061        my @field = split('/', $addincpath_list[$i][0]);
1062        push (@addincpath_headers, $field[-1]);
1063    }
1064
1065    # now stream all addincpath headers through addincpath filter
1066    for (my $i = 0; $i <= $#addincpath_list; $i++) {
1067        add_incpath_if_newer($addincpath_list[$i][0], $addincpath_list[$i][1], \@addincpath_headers)
1068                ? $files_copied++ : $files_unchanged++;
1069    }
1070}
1071
1072sub add_incpath_if_newer
1073{
1074    my $from = shift;
1075    my $to = shift;
1076    my $modify_headers_ref = shift;
1077    my ($from_stat_ref, $header);
1078
1079    push_on_ziplist($to) if $opt_zip;
1080    push_on_loglist("ADDINCPATH", "$from", "$to") if $opt_log;
1081
1082    if ( $opt_delete ) {
1083        print "REMOVE: $to\n" if $opt_verbose;
1084        my $rc = unlink($to);
1085        return 1 if $rc;
1086        return 0;
1087    }
1088
1089    if ( $from_stat_ref = is_newer($from, $to) ) {
1090        print "ADDINCPATH: $from -> $to\n" if $opt_verbose;
1091
1092        return 1 if $opt_check;
1093
1094        my $save = $/;
1095        undef $/;
1096        open(FROM, "<$from");
1097        # slurp whole file in one big string
1098        my $content = <FROM>;
1099        close(FROM);
1100        $/ = $save;
1101
1102        foreach $header (@$modify_headers_ref) {
1103            $content =~ s/#include [<"]$header[>"]/#include <$module\/$header>/g;
1104        }
1105
1106        open(TO, ">$to");
1107        print TO $content;
1108        close(TO);
1109
1110        utime($$from_stat_ref[9], $$from_stat_ref[9], $to);
1111        fix_file_permissions($$from_stat_ref[2], $to);
1112        return 1;
1113    }
1114    return 0;
1115}
1116
1117sub push_on_ziplist
1118{
1119    my $file = shift;
1120    return if ( $opt_check );
1121    # strip $dest from path since we don't want to record it in zip file
1122    if ( $file =~ s#^\Q$dest\E/##o ) {
1123        if ( $updminor ){
1124            # strip minor from path
1125            my $ext = "%_EXT%";
1126            $ext = expand_macros($ext);
1127            $file =~ s#^$ext##o;
1128        }
1129        push(@zip_list, $file);
1130    } elsif ( $file =~ s#^\Q$common_dest\E/##o ) {
1131        if ( $updminor ){
1132            # strip minor from path
1133            my $ext = "%_EXT%";
1134            $ext = expand_macros($ext);
1135            $file =~ s#^$ext##o;
1136        }
1137        push(@common_zip_list, $file);
1138    }
1139}
1140
1141sub push_on_loglist
1142{
1143    my @entry = @_;
1144    return 0 if ( $opt_check );
1145    return -1 if ( $#entry != 2 );
1146    if (( $entry[0] eq "COPY" ) || ( $entry[0] eq "ADDINCPATH" )) {
1147        return 0 if ( ! -e $entry[1].$maybedot );
1148        # make 'from' relative to source root
1149        $entry[1] = $repository ."/" . $module . "/prj/" . $entry[1];
1150        $entry[1] =~ s/$module\/prj\/\.\./$module/;
1151    }
1152    # platform or common tree?
1153    my $common;
1154    if ( $entry[2] =~ /^\Q$dest\E/ ) {
1155        $common = 0;
1156    } elsif ( $common_build && ( $entry[2] =~ /^\Q$common_dest\E/ )) {
1157        $common = 1;
1158    } else {
1159        warn "Neither common nor platform tree?";
1160        return;
1161    }
1162    # make 'to' relative to SOLARVERSION
1163    my $solarversion  = $ENV{'SOLARVERSION'};
1164    $solarversion =~ s#\\#/#g;
1165    $entry[2] =~ s/^\Q$solarversion\E\///;
1166    # strip minor from 'to'
1167    my $ext = "%_EXT%";
1168    $ext = expand_macros($ext);
1169    $entry[2] =~ s#$ext([\\\/])#$1#o;
1170
1171    if ( $common ) {
1172        push @common_log_list, [@entry];
1173    } else {
1174        push @log_list, [@entry];
1175    }
1176    return 1;
1177}
1178
1179sub zip_files
1180{
1181    my $zipexe = 'zip';
1182    $zipexe .= ' -y' unless  $^O eq 'MSWin32';
1183
1184    my ($platform_zip_file, $common_zip_file);
1185    $platform_zip_file = "%_DEST%/zip%_EXT%/$module.zip";
1186    $platform_zip_file = expand_macros($platform_zip_file);
1187    my (%dest_dir, %list_ref);
1188    $dest_dir{$platform_zip_file} = $dest;
1189    $list_ref{$platform_zip_file} = \@zip_list;
1190    if ( $common_build ) {
1191        $common_zip_file = "%COMMON_DEST%/zip%_EXT%/$module.zip";
1192        $common_zip_file = expand_macros($common_zip_file);
1193        $dest_dir{$common_zip_file}   = $common_dest;
1194        $list_ref{$common_zip_file}   = \@common_zip_list;
1195    }
1196
1197    my $ext = "%_EXT%";
1198    $ext = expand_macros($ext);
1199
1200    my @zipfiles;
1201    $zipfiles[0] = $platform_zip_file;
1202    if ( $common_build ) {
1203        push @zipfiles, ($common_zip_file);
1204    }
1205    foreach my $zip_file ( @zipfiles ) {
1206        print "ZIP: updating $zip_file\n" if $opt_verbose;
1207        next if ( $opt_check );
1208
1209        if ( $opt_delete ) {
1210            if ( -e $zip_file ) {
1211                unlink $zip_file or die "Error: can't remove file '$zip_file': $!";
1212            }
1213            next;
1214        }
1215
1216        local $work_file = "";
1217        if ( $zip_file eq $common_zip_file) {
1218            # Zip file in common tree: work on uniq copy to avoid collisions
1219            $work_file = $zip_file;
1220            $work_file =~ s/\.zip$//;
1221            $work_file .= (sprintf('.%d-%d', $$, time())) . ".zip";
1222            die "Error: temp file $work_file already exists" if ( -e $work_file);
1223            if ( -e $zip_file ) {
1224                if ( -z $zip_file) {
1225                    # sometimes there are files of 0 byte size - remove them
1226                    unlink $zip_file or print_error("can't remove empty file '$zip_file': $!",0);
1227                } else {
1228                    if ( ! copy($zip_file, $work_file)) {
1229                        # give a warning, not an error:
1230                        # we can zip from scratch instead of just updating the old zip file
1231                        print_warning("can't copy'$zip_file' into '$work_file': $!", 0);
1232                        unlink $work_file;
1233                    }
1234                }
1235            }
1236        } else {
1237            # No pre processing necessary, working directly on solver.
1238            $work_file = $zip_file;
1239        }
1240
1241        # zip content has to be relative to $dest_dir
1242        chdir($dest_dir{$zip_file}) or die "Error: cannot chdir into $dest_dir{$zip_file}";
1243        my $this_ref = $list_ref{$zip_file};
1244        open(ZIP, "| $zipexe -q -o -u -@ $work_file") or die "error opening zip file";
1245        foreach $file ( @$this_ref ) {
1246            print "ZIP: adding $file to $zip_file\n" if $is_debug;
1247            print ZIP "$file\n";
1248        }
1249        close(ZIP);
1250        fix_broken_cygwin_created_zips($work_file) if $^O eq "cygwin";
1251
1252        if ( $zip_file eq $common_zip_file) {
1253            # rename work file back
1254            if ( -e $work_file ) {
1255                if ( -e $zip_file) {
1256                    # do some tricks to be fast. otherwise we may disturb other platforms
1257                    # by unlinking a file which just gets copied -> stale file handle.
1258                    my $buffer_file=$work_file . '_rm';
1259                    rename($zip_file, $buffer_file) or warn "Warning: can't rename old zip file '$zip_file': $!";
1260                    if (! rename($work_file, $zip_file)) {
1261                        print_error("can't rename temporary file to $zip_file: $!",0);
1262                        unlink $work_file;
1263                    }
1264                    unlink $buffer_file;
1265                } else {
1266                    if (! rename($work_file, $zip_file)) {
1267                        print_error("can't rename temporary file to $zip_file: $!",0);
1268                        unlink $work_file;
1269                    }
1270                }
1271            }
1272        }
1273    }
1274}
1275
1276sub fix_broken_cygwin_created_zips
1277# add given extension to or strip it from stored path
1278{
1279    require Archive::Zip; import Archive::Zip;
1280    my $zip_file = shift;
1281
1282    $zip = Archive::Zip->new();
1283    unless ( $zip->read($work_file) == AZ_OK ) {
1284        die "Error: can't open zip file '$zip_file' to fix broken cygwin file permissions";
1285    }
1286    my $latest_member_mod_time = 0;
1287    foreach $member ( $zip->members() ) {
1288        my $attributes = $member->unixFileAttributes();
1289        $attributes &= ~0xFE00;
1290        print $member->fileName() . ": " . sprintf("%lo", $attributes) if $is_debug;
1291        $attributes |= 0x10; # add group write permission
1292        print "-> " . sprintf("%lo", $attributes) . "\n" if $is_debug;
1293        $member->unixFileAttributes($attributes);
1294        if ( $latest_member_mod_time < $member->lastModTime() ) {
1295            $latest_member_mod_time = $member->lastModTime();
1296        }
1297    }
1298    die "Error: can't overwrite zip file '$zip_file' for fixing permissions" unless $zip->overwrite() == AZ_OK;
1299    utime($latest_member_mod_time, $latest_member_mod_time, $zip_file);
1300}
1301
1302sub get_tempfilename
1303{
1304    my $temp_dir = shift;
1305    $temp_dir = ( -d '/tmp' ? '/tmp' : $ENV{TMPDIR} || $ENV{TEMP} || '.' )
1306            unless defined($temp_dir);
1307 	if ( ! -d $temp_dir ) {
1308        die "no temp directory $temp_dir\n";
1309    }
1310    my $base_name = sprintf( "%d-%di-%d", $$, time(), $tempcounter++ );
1311    return "$temp_dir/$base_name";
1312}
1313
1314sub write_log
1315{
1316    my (%log_file, %file_date);
1317    $log_file{\@log_list} = "%_DEST%/inc%_EXT%/$module/deliver.log";
1318    $log_file{\@common_log_list} = "%COMMON_DEST%/inc%_EXT%/$module/deliver.log";
1319    $file_date{\@log_list} = $logfiledate;
1320    $file_date{\@common_log_list} = $commonlogfiledate;
1321
1322    my @logs = ( \@log_list );
1323    push @logs, ( \@common_log_list ) if ( $common_build );
1324    foreach my $log ( @logs ) {
1325        $log_file{$log} = expand_macros( $log_file{$log} );
1326        if ( $opt_delete ) {
1327            print "LOG: removing $log_file{$log}\n" if $opt_verbose;
1328            next if ( $opt_check );
1329            unlink $log_file{$log};
1330        } else {
1331            print "LOG: writing $log_file{$log}\n" if $opt_verbose;
1332            next if ( $opt_check );
1333            open( LOGFILE, "> $log_file{$log}" ) or warn "Error: could not open log file.";
1334            foreach my $item ( @$log ) {
1335                print LOGFILE "@$item\n";
1336            }
1337            close( LOGFILE );
1338            utime($file_date{$log}, $file_date{$log}, $log_file{$log});
1339        }
1340        push_on_ziplist( $log_file{$log} ) if $opt_zip;
1341    }
1342    return;
1343}
1344
1345sub check_dlst
1346{
1347    my %createddir;
1348    my %destdir;
1349    my %destfile;
1350    # get all checkable actions to perform
1351    foreach my $action ( @action_data ) {
1352        my $path = expand_macros( $$action[1] );
1353        if ( $$action[0] eq 'mkdir' ) {
1354            $createddir{$path} ++;
1355        } elsif (( $$action[0] eq 'copy' ) || ( $$action[0] eq 'addincpath' )) {
1356            my ($from, $to) = split(' ', $path);
1357            my ($to_fname, $to_dir);
1358            my $withwildcard = 0;
1359            if ( $from =~ /[\*\?\[\]]/ ) {
1360                $withwildcard = 1;
1361            }
1362            ($to_fname, $to_dir) = fileparse($to);
1363            if ( $withwildcard ) {
1364                if ( $to !~ /[\*\?\[\]]/ ) {
1365                    $to_dir = $to;
1366                    $to_fname ='';
1367                }
1368            }
1369            $to_dir =~ s/[\\\/\s]$//;
1370            $destdir{$to_dir} ++;
1371            # Check: copy into non existing directory?
1372            if ( ! $createddir{$to_dir} ) {
1373                # unfortunately it is not so easy: it's OK if a subdirectory of $to_dir
1374                # gets created, because mkpath creates the whole tree
1375                foreach my $directory ( keys %createddir ) {
1376                    if ( $directory =~ /^\Q$to_dir\E[\\\/]/ ) {
1377                        $createddir{$to_dir} ++;
1378                        last;
1379                    }
1380                }
1381                print_warning("Possibly copying into directory without creating in before: '$to_dir'")
1382                    unless $createddir{$to_dir};
1383            }
1384            # Check: overwrite file?
1385            if ( ! $to ) {
1386                if ( $destfile{$to} ) {
1387                    print_warning("Multiple entries copying to '$to'");
1388                }
1389                $destfile{$to} ++;
1390            }
1391        }
1392    }
1393}
1394
1395sub cleanup
1396{
1397    # remove empty directories
1398    foreach my $path ( @dirlist ) {
1399        $path = expand_macros($path);
1400        if ( $opt_check ) {
1401            print "RMDIR: $path\n" if $opt_verbose;
1402        } else {
1403            rmdir $path;
1404        }
1405    }
1406}
1407
1408sub delete_output
1409{
1410    my $output_path = expand_macros("../%__SRC%");
1411    if ( "$output_path" ne "../" ) {
1412        if ( rmtree([$output_path], 0, 1) ) {
1413            print "Deleted output tree.\n" if $opt_verbose;
1414        }
1415        else {
1416            print_error("Error deleting output tree $output_path: $!",0);
1417        }
1418    }
1419    else {
1420        print_error("Output not deleted - INPATH is not set");
1421    }
1422}
1423
1424sub print_warning
1425{
1426    my $message = shift;
1427    my $line = shift;
1428
1429    print STDERR "$script_name: ";
1430    if ( $dlst_file ) {
1431        print STDERR "$dlst_file: ";
1432    }
1433    if ( $line ) {
1434        print STDERR "line $line: ";
1435    }
1436    print STDERR "WARNING: $message\n";
1437}
1438
1439sub print_error
1440{
1441    my $message = shift;
1442    my $line = shift;
1443
1444    print STDERR "$script_name: ";
1445    if ( $dlst_file ) {
1446        print STDERR "$dlst_file: ";
1447    }
1448    if ( $line ) {
1449        print STDERR "line $line: ";
1450    }
1451    print STDERR "ERROR: $message\n";
1452    $error ++;
1453}
1454
1455sub print_stats
1456{
1457    print "Module '$module' delivered ";
1458    if ( $error ) {
1459        print "with errors\n";
1460    } else {
1461        print "successfully.";
1462        if ( $opt_delete ) {
1463            print " $files_copied files removed,";
1464        }
1465        else {
1466            print " $files_copied files copied,";
1467        }
1468        print " $files_unchanged files unchanged\n";
1469    }
1470}
1471
1472sub cleanup_and_die
1473{
1474    # clean up on unexpected termination
1475    my $sig = shift;
1476    if ( defined($temp_file) && -e $temp_file ) {
1477        unlink($temp_file);
1478    }
1479    if ( defined($work_file) && -e $work_file ) {
1480        unlink($work_file);
1481        print STDERR "$work_file removed\n";
1482    }
1483
1484    die "caught unexpected signal $sig, terminating ...";
1485}
1486
1487sub usage
1488{
1489    my $exit_code = shift;
1490    print STDERR "Usage:\ndeliver [OPTIONS] [DESTINATION-PATH]\n";
1491    print STDERR "Options:\n";
1492    print STDERR "  -check       just print what would happen, no actual copying of files\n";
1493    print STDERR "  -checkdlst   be verbose about (possible) d.lst bugs\n";
1494    print STDERR "  -delete      delete files (undeliver), use with care\n";
1495    print STDERR "  -deloutput   remove the output tree after copying\n";
1496    print STDERR "  -dontdeletecommon do not delete common files (for -delete option)\n";
1497    print STDERR "  -force       copy even if not newer\n";
1498    print STDERR "  -help        print this message\n";
1499    if ( !defined($ENV{GUI}) || $ENV{GUI} ne 'WNT' ) {
1500        print STDERR "  -link        hard link files into the solver to save disk space\n";
1501    }
1502    print STDERR "  -quiet       be quiet, only report errors\n";
1503    print STDERR "  -verbose     be verbose\n";
1504    print STDERR "  -zip         additionally create zip files of delivered content\n";
1505    print STDERR "Options '-zip' and a destination-path are mutually exclusive.\n";
1506    print STDERR "Options '-check' and '-quiet' are mutually exclusive.\n";
1507    exit($exit_code);
1508}
1509
1510# vim: set ts=4 shiftwidth=4 expandtab syntax=perl:
1511