home *** CD-ROM | disk | FTP | other *** search
/ c't freeware shareware 2001 January / CT_SW0101.ISO / pc / software / kommunik / ftp / kmago112.tgz / kmago112.tar / kmago-1.1.2 / admin / am_edit < prev    next >
Text File  |  2001-04-19  |  66KB  |  1,941 lines
  1. #!/usr/bin/perl
  2.  
  3. # Expands the specilised KDE tags in Makefile.in to (hopefully) valid
  4. # make syntax.
  5. # When called without file parameters, we work recursively on all Makefile.in
  6. # in and below the current subdirectory. When called with file parameters,
  7. # only those Makefile.in are changed.
  8. # The currently supported tags are
  9. #
  10. # {program}_METASOURCES
  11. # where you have a choice of two styles
  12. #   {program}_METASOURCES = name1.moc name2.moc ... [\]
  13. #   {program}_METASOURCES = AUTO
  14. #       The second style requires other tags as well.
  15. #
  16. # To install icons :
  17. #    KDE_ICON = iconname iconname2 ...
  18. #    KDE_ICON = AUTO
  19. #
  20. # For documentation :
  21. #    ...
  22. #
  23. # and more new tags TBD!
  24. #
  25. # The concept (and base code) for this program came from automoc,
  26. # supplied by the following
  27. #
  28. # Matthias Ettrich <ettrich@kde.org>      (The originator)
  29. # Kalle Dalheimer <kalle@kde.org>      (The original implementator)
  30. # Harri Porten  <porten@tu-harburg.de>
  31. # Alex Zepeda  <jazepeda@pacbell.net>
  32. # David Faure <faure@kde.org>
  33. # Stephan Kulow <coolo@kde.org>
  34. #
  35. # I've puddled around with automoc and produced something different
  36. # 1999-02-01 John Birch <jb.nz@writeme.com>
  37. #       * Rewritten automoc to cater for more than just moc file expansion
  38. #         Version 0.01 does the same as automoc at this stage.
  39. # 1999-02-18 jb
  40. #       * We must always write a Makefile.in file out even if we fail
  41. #         because we need the "perl autokmake" in the AUTOMAKE so that a
  42. #         "make" will regenerate the Makefile.in correctly.
  43. #         Reworked moc file checking so that missing includes in cpp
  44. #         will work and includes in cpp when using use_automoc will also
  45. #         work.
  46. # 1999-02-23 jb
  47. #       * Added POFILE processing and changed the USE_AUTOMOC tag to
  48. #         AUTO instead.
  49. # ... See ChangeLog for more logs
  50.  
  51. use Cwd;
  52. use File::Find;
  53. use File::Basename;
  54.  
  55. # Prototype the functions
  56. sub initialise ();
  57. sub processMakefile ($);
  58. sub updateMakefile ();
  59. sub restoreMakefile ();
  60.  
  61. sub removeLine ($$);
  62. sub appendLines ($);
  63. sub substituteLine ($$);
  64.  
  65. sub findMocCandidates ();
  66. sub pruneMocCandidates ($);
  67. sub checkMocCandidates ();
  68. sub addMocRules ();
  69.  
  70. sub tag_AUTOMAKE ();
  71. sub tag_META_INCLUDES ();
  72. sub tag_METASOURCES ();
  73. sub tag_POFILES ();
  74. sub tag_DOCFILES ();
  75. sub tag_LOCALINSTALL();
  76. sub tag_IDLFILES();
  77. sub tag_UIFILES();
  78. sub tag_TOPLEVEL();
  79. sub tag_SUBDIRS();
  80. sub tag_ICON();
  81. sub tag_CLOSURE();
  82. sub tag_DIST();
  83.  
  84. # Some global globals...
  85. $verbose    = 0;        # a debug flag
  86. $thisProg   = "$0";     # This programs name
  87. $topdir     = cwd();    # The current directory
  88. @makefiles  = ();       # Contains all the files we'll process
  89. @foreignfiles = ();
  90. $start      = (times)[0]; # some stats for testing - comment out for release
  91. $version    = "v0.2";
  92. $errorflag  = 0;
  93. $cppExt     = "*.cpp *.cc *.cxx *.C *.c++";           # used by grep
  94. $hExt       = "*.h *.H *.hh *.hxx *.h++";             # used by grep
  95. $progId     = "KDE tags expanded automatically by " . basename($thisProg);
  96. $automkCall = "\n";
  97. $printname  = "";  # used to display the directory the Makefile is in
  98. $use_final  = 1;        # create code for --enable-final
  99. $cleantarget = "clean";
  100. $dryrun     = 0;
  101. $pathoption = 0;
  102.  
  103. while (defined ($ARGV[0]))
  104. {
  105.     $_ = shift;
  106.     if (/^--version$/)
  107.     {
  108.         print STDOUT "\n";
  109.         print STDOUT basename($thisProg), " $version\n",
  110.                 "This is really free software, unencumbered by the GPL.\n",
  111.                 "You can do anything you like with it except sueing me.\n",
  112.                 "Copyright 1998 Kalle Dalheimer <kalle\@kde.org>\n",
  113.                 "Concept, design and unnecessary questions about perl\n",
  114.                 "       by Matthias Ettrich <ettrich\@kde.org>\n\n",
  115.                 "Making it useful by Stephan Kulow <coolo\@kde.org> and\n",
  116.                 "Harri Porten <porten\@kde.org>\n",
  117.                 "Updated (Feb-1999), John Birch <jb.nz\@writeme.com>\n",
  118.             "Current Maintainer Stephan Kulow\n\n";
  119.         exit 0;
  120.     }
  121.     elsif (/^--verbose$|^-v$/)
  122.     {
  123.         $verbose = 1;       # Oh is there a problem...?
  124.     }
  125.     elsif (/^-p(.+)$|^--path=(.+)$/)
  126.     {
  127.         $thisProg = "$1/".basename($thisProg) if($1);
  128.         $thisProg = "$2/".basename($thisProg) if($2);
  129.         warn ("$thisProg doesn't exist\n")      if (!(-f $thisProg));
  130.         $pathoption=1;
  131.     }
  132.     elsif (/^--help$|^-h$/)
  133.     {
  134.         print STDOUT "Usage $thisProg [OPTION] ... [dir/Makefile.in]...\n",
  135.                 "\n",
  136.                 "Patches dir/Makefile.in generated from automake\n",
  137.                 "(where dir can be a full or relative directory name)",
  138.                 "\n",
  139.                 "  -v, --verbose      verbosely list files processed\n",
  140.                 "  -h, --help         print this help, then exit\n",
  141.                 "  --version          print version number, then exit\n",
  142.                 "  -p, --path=        use the path to am_edit if the path\n",
  143.             "  --no-final         don't patch for --enable-final\n",
  144.                 "                     called from is not the one to be used\n";
  145.     
  146.         exit 0;
  147.     }
  148.     elsif (/^--no-final$/)
  149.     {
  150.     $use_final = 0;
  151.         $thisProg .= " --no-final";
  152.     }
  153.     elsif (/^-n$/)
  154.     {
  155.         $dryrun = 1;
  156.     }
  157.     else
  158.     {
  159.         # user selects what input files to check
  160.         # add full path if relative path is given
  161.         $_ = cwd()."/".$_   if (! /^\//);
  162.         print "User wants $_\n" if ($verbose);
  163.         push (@makefiles, $_);
  164.     }
  165. }
  166.  
  167. if ($thisProg =~ /^\// && !$pathoption )
  168. {
  169.   print STDERR "Illegal full pathname call performed...\n",
  170.       "The call to \"$thisProg\"\nwould be inserted in some Makefile.in.\n",
  171.       "Please use option --path.\n";
  172.   exit 1;
  173. }
  174.  
  175. # Only scan for files when the user hasn't entered data
  176. if (!@makefiles)
  177. {
  178.     print STDOUT "Scanning for Makefile.in\n"       if ($verbose);
  179.     find (\&add_makefile, cwd());
  180.     #chdir('$topdir');
  181. } else {
  182.     print STDOUT "Using user enter input files\n"   if ($verbose);
  183. }
  184.  
  185. foreach $makefile (sort(@makefiles))
  186. {
  187.     processMakefile ($makefile);
  188.     last            if ($errorflag);
  189. }
  190.  
  191. # Just some debug statistics - comment out for release as it uses printf.
  192. printf STDOUT "Time %.2f CPU sec\n", (times)[0] - $start     if ($verbose);
  193.  
  194. exit $errorflag;        # causes make to fail if erroflag is set
  195.  
  196. #-----------------------------------------------------------------------------
  197.  
  198. # In conjunction with the "find" call, this builds the list of input files
  199. sub add_makefile ()
  200. {
  201.   push (@makefiles, $File::Find::name) if (/Makefile.in$/);
  202. }
  203.  
  204. #-----------------------------------------------------------------------------
  205.  
  206. # Processes a single make file
  207. # The parameter contains the full path name of the Makefile.in to use
  208. sub processMakefile ($)
  209. {
  210.     # some useful globals for the subroutines called here
  211.     local ($makefile)       = @_;
  212.     local @headerdirs       = ('.');
  213.     local $haveAutomocTag   = 0;
  214.     local $MakefileData     = "";
  215.  
  216.     local $cxxsuffix  = "KKK";
  217.  
  218.     local @programs = ();  # lists the names of programs and libraries
  219.     local $program = "";
  220.  
  221.     local %realObjs = ();  # lists the objects compiled into $program
  222.     local %sources = ();   # lists the sources used for $program
  223.     local %finalObjs = (); # lists the objects compiled when final
  224.     local %realname = ();  # the binary name of program variable
  225.     local %idlfiles = ();  # lists the idl files used for $program
  226.     local %globalmocs = ();# list of all mocfiles (in %mocFiles format)
  227.     local %important = (); # list of files to be generated asap
  228.  
  229.     local $allidls = "";
  230.     local $alluis = "";
  231.     local $idl_output = "";# lists all idl generated files for cleantarget
  232.     local $ui_output = "";# lists all uic generated files for cleantarget
  233.     local $ui_mocs = "";# lists all moc files associated with generated uic files
  234.  
  235.     local %depedmocs = ();
  236.     
  237.     local $metasourceTags = 0;
  238.     local $dep_files      = "";
  239.     local $dep_finals     = "";
  240.     local %target_adds    = (); # the targets to add
  241.     local $kdelang        = "";
  242.     local @cleanfiles     = ();
  243.     local $cleanMoc       = "";
  244.     local $closure_output = "";
  245.  
  246.     $makefileDir = dirname($makefile);
  247.     chdir ($makefileDir);
  248.     $printname = $makefile;
  249.     $printname =~ s/^\Q$topdir\E\///;
  250.     $makefile = basename($makefile);
  251.  
  252.     print STDOUT "Processing makefile $printname\n"   if ($verbose);
  253.     
  254.     # Setup and see if we need to do this.
  255.     return      if (!initialise());
  256.     
  257.     tag_AUTOMAKE ();            # Allows a "make" to redo the Makefile.in
  258.     tag_META_INCLUDES ();       # Supplies directories for src locations
  259.     
  260.     foreach $program (@programs) {
  261.         $sources_changed{$program} = 0;
  262.         $depedmocs{$program} = "";
  263.         $important{$program} = "";
  264.     tag_IDLFILES();             # Sorts out idl rules
  265.     tag_UIFILES();             # Sorts out ui rules
  266.     tag_CLOSURE();
  267.         tag_METASOURCES ();         # Sorts out the moc rules
  268.         if ($sources_changed{$program}) {
  269.             my $lookup = "$program" . '_SOURCES\s*=\s*(.*)';
  270.             substituteLine($lookup, "$program\_SOURCES=" . $sources{$program});
  271.         }
  272.         if ($important{$program}) {
  273.             local %source_dict = ();
  274.             for $source (split(/[\034\s]+/, $sources{$program})) {
  275.                 $source_dict{$source} = 1;
  276.             }
  277.             for $source (@cleanfiles) {
  278.                 $source_dict{$source} = 0;
  279.             }
  280.             for $source (keys %source_dict) {
  281.                 next if (!$source);
  282.                 if ($source_dict{$source}) {
  283.                     # sanity check
  284.                     if (! -f $source) {
  285.                         print STDERR "Error: $source is listed in a _SOURCE line in $printname, but doesn't exist yet. Put it in DISTCLEANFILES!\n";
  286.                     } else {
  287.                         $target_adds{"\$(srcdir)/$source"} .= $important{$program};
  288.                     }
  289.                 }
  290.             }
  291.         }
  292.     }
  293.     if ($cleanMoc) {
  294.         # Always add dist clean tag
  295.         # Add extra *.moc.cpp files created for USE_AUTOMOC because they
  296.         # aren't included in the normal *.moc clean rules.
  297.         appendLines ("$cleantarget-metasources:\n\t-rm -f $cleanMoc\n");
  298.         $target_adds{"$cleantarget-am"} .= "$cleantarget-metasources ";
  299.     }
  300.     tag_DIST();
  301.  
  302.     if ($idl_output) {
  303.         appendLines ("$cleantarget-idl:\n\t-rm -f $idl_output\n");
  304.         $target_adds{"$cleantarget-am"} .= "$cleantarget-idl ";
  305.     }
  306.  
  307.     if ($ui_output) {
  308.         appendLines ("$cleantarget-ui:\n\t-rm -f $ui_output\n");
  309.         $target_adds{"$cleantarget-am"} .= "$cleantarget-ui ";
  310.     }
  311.  
  312.     if ($closure_output) {
  313.         appendLines ("$cleantarget-closures:\n\t-rm -f $closure_output\n");
  314.         $target_adds{"$cleantarget-am"} .= "$cleantarget-closures ";
  315.     }
  316.  
  317.     if ($MakefileData =~ /\nKDE_LANG\s*=\s*(\S*)\s*\n/) {
  318.         $kdelang = '$(KDE_LANG)'
  319.     } else {
  320.         $kdelang = '';
  321.     }
  322.  
  323.     tag_POFILES ();             # language rules for po directory
  324.     tag_DOCFILES ();            # language rules for doc directories
  325.     tag_TOPLEVEL ();            # language rules for po toplevel
  326.     tag_LOCALINSTALL();         # add $(DESTDIR) before all kde_ dirs
  327.     tag_ICON();
  328.  
  329.     my $tmp = "force-reedit:\n";
  330.     $tmp   .= "\t$automkCall\n\tcd \$(top_srcdir) && perl $thisProg $printname\n\n";
  331.     appendLines($tmp);
  332.     
  333.     make_meta_classes();
  334.     tag_FINAL() if (!$kdeopts{"nofinal"});
  335.  
  336.     my $final_lines = "final:\n\t\$(MAKE) ";
  337.     my $nofinal_lines = "no-final:\n\t\$(MAKE) ";
  338.  
  339.     foreach $program (@programs) {
  340.         
  341.         my $lookup = "$program\_OBJECTS.*=[^\n]*";
  342.         
  343.         my $new = "";
  344.         
  345.         my @list = split(/[\034\s]+/, $realObjs{$program});
  346.         
  347.         if (!$kdeopts{"nofinal"} && @list > 1 && $finalObjs{$program}) {
  348.             
  349.             $new .= "$program\_final\_OBJECTS = " . $finalObjs{$program};
  350.             $new .= "\n$program\_nofinal\_OBJECTS = " . $realObjs{$program};
  351.             $new .= "\n\@KDE_USE_FINAL_FALSE\@$program\_OBJECTS = \$($program\_nofinal\_OBJECTS)";
  352.             $new .= "\n\@KDE_USE_FINAL_TRUE\@$program\_OBJECTS = \$($program\_final\_OBJECTS)";
  353.             
  354.             $final_lines .= "$program\_OBJECTS=\"\$($program\_final_OBJECTS)\" ";
  355.             $nofinal_lines .= "$program\_OBJECTS=\"\$($program\_nofinal\_OBJECTS)\" ";
  356.         } else {
  357.             $new = "$program\_OBJECTS = " . $realObjs{$program};
  358.         }
  359.         substituteLine ($lookup, $new);
  360.     }
  361.     appendLines($final_lines . "all-am");
  362.     appendLines($nofinal_lines . "all-am");
  363.     
  364.     my $lookup = 'DEP_FILES\s*=([^\n]*)';
  365.     if ($MakefileData =~ /\n$lookup\n/) {
  366.         $depfiles = $1;
  367.         
  368.         if ($dep_finals) {
  369.             $lines  = "\@KDE_USE_FINAL_TRUE\@DEP_FILES = $dep_files $dep_finals \034\t$depfiles\n";
  370.             $lines .= "\@KDE_USE_FINAL_FALSE\@DEP_FILES = $dep_files $depfiles\n";
  371.         } else {
  372.             $lines = "DEP_FILES = $dep_files $depfiles\n";
  373.         }
  374.         
  375.         substituteLine($lookup, $lines);
  376.     }
  377.     
  378.     my $cvs_lines = "cvs-clean:\n";
  379.     $cvs_lines .= "\t\$(MAKE) -f \$(top_srcdir)/admin/Makefile.common cvs-clean\n";
  380.     appendLines($cvs_lines);
  381.     
  382.     $cvs_lines  = "kde-rpo-clean:\n";
  383.     $cvs_lines .= "\t-rm -f *.rpo\n";
  384.     appendLines($cvs_lines);
  385.     $target_adds{"clean"} .= "kde-rpo-clean ";
  386.     
  387.     my $lines = "";
  388.  
  389.     foreach $add (keys %target_adds) {
  390.         my $lookup = quotemeta($add) . ":\s*(.*)";
  391.         if ($MakefileData =~ /\n$lookup\n/) {
  392.             substituteLine($lookup, "$add: " . $target_adds{$add} . $1);
  393.         } else {
  394.             $lines .= "$add: " . $target_adds{$add} . "\n";
  395.         }
  396.     }
  397.     if ($lines) {
  398.         appendLines($lines);
  399.     }
  400.  
  401.     my $found = 1;
  402.     
  403.     while ($found) {
  404.         if ($MakefileData =~ m/\n(.*)\$\(CXXFLAGS\)(.*)\n/) {
  405.             my $vor = $1;
  406.             my $nach = $2;
  407.             my $lookup = quotemeta("$1\$(CXXFLAGS)$2");
  408.             my $replacement = "$1\$(KCXXFLAGS)$2";
  409.             $MakefileData =~ s/$lookup/$replacement/;
  410.             $lookup =~ s/\\\$\\\(CXXFLAGS\\\)/\\\$\\\(KCXXFLAGS\\\)/;
  411.             $replacement = "$vor\$(KCXXFLAGS) \$(KDE_CXXFLAGS)$nach";
  412.             substituteLine($lookup, $replacement);
  413.         } else {
  414.             $found = 0;
  415.         }
  416.     }
  417.  
  418.     $lookup = '(\n[^#].*\$\(LIBTOOL\) --mode=link) (\$\(CXXLD\).*\$\(KCXXFLAGS\))';
  419.     
  420.     if ($MakefileData =~ m/$lookup/ ) {
  421.         $MakefileData =~ s/$lookup/$1 --tag=CXX $2/;
  422.     }
  423.  
  424.     $lookup = '(\n[^#].*\$\(LIBTOOL\) --mode=compile) (\$\(CXX\).*\$\(KCXXFLAGS\))';
  425.     if ($MakefileData =~ m/$lookup/ ) {
  426.         $MakefileData =~ s/$lookup/$1 --tag=CXX $2/;
  427.     }
  428.  
  429.     $MakefileData =~ s/\$\(KCXXFLAGS\)/\$\(CXXFLAGS\)/g;
  430.  
  431.     $lookup = '(.*)cp -pr \$\$/\$\$file \$\(distdir\)/\$\$file(.*)';
  432.     if ($MakefileData =~ m/$lookup/) {
  433.         substituteLine($lookup, "$1cp -pr \$\$d/\$\$file \$(distdir)/\$\$file$2");
  434.     }
  435.  
  436.     # Always update the Makefile.in
  437.     updateMakefile ();
  438.     return;
  439. }
  440.  
  441. #-----------------------------------------------------------------------------
  442.  
  443. # Check to see whether we should process this make file.
  444. # This is where we look for tags that we need to process.
  445. # A small amount of initialising on the tags is also done here.
  446. # And of course we open and/or create the needed make files.
  447. sub initialise ()
  448. {
  449.     if (! -r "Makefile.am") {
  450.     print STDOUT "found Makefile.in without Makefile.am\n" if ($verbose);
  451.     return 0;
  452.     }
  453.  
  454.     # Checking for files to process...
  455.     open (FILEIN, $makefile)
  456.       || die "Could not open $makefileDir/$makefile: $!\n";
  457.     # Read the file
  458.     while ( <FILEIN> )
  459.     {
  460.         $MakefileData .= $_;
  461.         if ($_ =~ /\r\n$/) {
  462.             die "DOS-Linefeeds within $makefileDir/$makefile!\n";
  463.         }
  464.     }
  465.     close FILEIN;
  466.  
  467.     # Remove the line continuations, but keep them marked
  468.     # Note: we lose the trailing spaces but that's ok.
  469.     $MakefileData =~ s/\\\s*\n/\034/g;
  470.  
  471.     # If we've processed the file before...
  472.     restoreMakefile ()      if ($MakefileData =~ /$progId/);
  473.  
  474.     foreach $dir (@foreignfiles) {
  475.       if (substr($makefileDir,0,length($dir)) eq $dir) {
  476.     return 0;
  477.       }
  478.     }
  479.  
  480.     %kdeopts = ();
  481.     $kdeopts{"foreign"} = 0;
  482.     $kdeopts{"qtonly"} = 0;
  483.     $kdeopts{"nofinal"} = !$use_final; # default
  484.  
  485.     if ($MakefileData =~ /\nKDE_OPTIONS\s*=\s*([^\n]*)\n/) {
  486.         local @kde_options = split(/[\s\034]/, $1);
  487.         if (grep(/^foreign$/, @kde_options)) {
  488.             push(@foreignfiles, $makefileDir . "/");
  489.             return 0; # don't touch me
  490.         }
  491.         for $opt (@kde_options) {
  492.             if (!defined $kdeopts{$opt}) {
  493.                 print STDERR "Warning: unknown option $opt in $printname\n";
  494.             } else {
  495.                 $kdeopts{$opt} = 1;
  496.             }
  497.         }
  498.     }
  499.  
  500.     # Look for the tags that mean we should process this file.
  501.     $metasourceTags = 0;
  502.     $metasourceTags++    while ($MakefileData =~ /\n[^=\#]*METASOURCES\s*=/g);
  503.  
  504.     my $pofileTag = 0;
  505.     $pofileTag++    while ($MakefileData =~ /\nPOFILES\s*=/g);
  506.     if ($pofileTag > 1)
  507.       {
  508.           print STDERR "Error: Only one POFILES tag allowed\n";
  509.           $errorflag = 1;
  510.       }
  511.  
  512.     while ($MakefileData =~ /\n\.SUFFIXES:([^\n]+)\n/g) {
  513.     my @list=split(' ', $1);
  514.     my $extions = " " . $cppExt . " ";
  515.     foreach $ext (@list) {
  516.         if ($extions =~ / \*\Q$ext\E /) {
  517.         $cxxsuffix = $ext;
  518.         $cxxsuffix =~ s/\.//g;
  519.         print STDOUT "will use suffix $cxxsuffix\n" if ($verbose);
  520.         last;
  521.         }
  522.     }
  523.     }
  524.                                                      
  525.     while ($MakefileData =~ /\n(\S*)_OBJECTS\s*=[ \t\034]*([^\n]*)\n/g) {
  526.         
  527.         my $program = $1;
  528.         my $objs = $2; # safe them
  529.         
  530.         my $ocv = 0;
  531.         
  532.         my @objlist = split(/[\s\034]+/, $objs);
  533.         foreach $obj (@objlist) {
  534.             if ($obj =~ /\$\((\S+)\)/ ) {
  535.                 my $variable = $1;
  536.                 if ($variable !~ 'OBJEXT') {
  537.                     $ocv = 1;
  538.                 }
  539.             }
  540.         }
  541.         
  542.         next if ($ocv);
  543.         
  544.         $program =~ s/^am_// if ($program =~ /^am_/);
  545.         
  546.         print STDOUT "found program $program\n" if ($verbose);
  547.         push(@programs, $program);
  548.         
  549.         $realObjs{$program} = $objs;
  550.         
  551.         if ($MakefileData =~ /\n$program\_SOURCES\s*=\s*(.*)\n/) {
  552.             $sources{$program} = $1;
  553.         } else {
  554.             $sources{$program} = "";
  555.             print STDERR "found program with no _SOURCES: $program\n";
  556.         }
  557.         
  558.         my $realprogram = $program;
  559.         $realprogram =~ s/_/./g; # unmask to regexp
  560.         if ($MakefileData =~ /\n($realprogram)(\$\(EXEEXT\)?)?:.*\$\($program\_OBJECTS\)/) {
  561.             $realname{$program} = $1;
  562.         } else {
  563.             # not standard Makefile - nothing to worry about
  564.             $realname{$program} = "";
  565.         }
  566.     }
  567.     
  568.     my $lookup = '\nDEPDIR\s*=.*';
  569.     if ($MakefileData !~ /($lookup)\n/) {
  570.         $lookup = '\nbindir\s*=.*';
  571.         if ($MakefileData =~ /($lookup)\n/) {
  572.             substituteLine ($lookup, "DEPDIR = .deps\n$1");
  573.         }
  574.     } else {
  575.         print STDERR "$printname defines DEPDIR. This means you're using automake > 1.4 - this is not supported!\n";
  576.     }
  577.  
  578.     my @marks = ('MAINTAINERCLEANFILES', 'CLEANFILES', 'DISTCLEANFILES');
  579.     foreach $mark (@marks) {
  580.         while ($MakefileData =~ /\n($mark)\s*=\s*([^\n]*)/g) {
  581.             foreach $file (split('[\034\s]', $2)) {
  582.                 $file =~ s/\.\///;
  583.                 push(@cleanfiles, $file);
  584.             }
  585.         }
  586.     }
  587.  
  588.     my $localTag = 0;
  589.     $localTag++ if ($MakefileData =~ /\ninstall-\S+-local:/);
  590.     
  591.     return (!$errorflag);
  592. }
  593.  
  594. #-----------------------------------------------------------------------------
  595.  
  596. # Gets the list of user defined directories - relative to $srcdir - where
  597. # header files could be located.
  598. sub tag_META_INCLUDES ()
  599. {
  600.     my $lookup = '[^=\n]*META_INCLUDES\s*=\s*(.*)';
  601.     return 1    if ($MakefileData !~ /($lookup)\n/);
  602.     print STDOUT "META_INCLUDE processing <$1>\n"       if ($verbose);
  603.  
  604.     my $headerStr = $2;
  605.     removeLine ($lookup, $1);
  606.  
  607.     $headerStr =~ tr/\034/ /;
  608.     my @headerlist = split(' ', $headerStr);
  609.  
  610.     foreach $dir (@headerlist)
  611.     {
  612.         $dir =~ s#\$\(srcdir\)#.#;
  613.         if (! -d $dir)
  614.         {
  615.             print STDERR "Warning: $dir can't be found. ",
  616.                             "Must be a relative path to \$(srcdir)\n";
  617.         }
  618.         else
  619.         {
  620.             push (@headerdirs, $dir);
  621.         }
  622.     }
  623.  
  624.     return 0;
  625. }
  626.  
  627. #-----------------------------------------------------------------------------
  628.  
  629. sub tag_FINAL()
  630. {
  631.     my @final_names = ();
  632.     
  633.     foreach $program (@programs) {
  634.         
  635.         if ($sources{$program} =~ /\(/) {
  636.             print STDOUT "found ( in $program\_SOURCES. skipping\n" if ($verbose);
  637.             next;
  638.         }
  639.         
  640.         my $mocsources = "";
  641.         
  642.         my @progsources = split(/[\s\034]+/, $sources{$program});
  643.         my %sourcelist = ();
  644.         
  645.         foreach $source (@progsources) {
  646.             my $suffix = $source;
  647.             $suffix =~ s/^.*\.([^\.]+)$/$1/;
  648.             
  649.             if (defined($sourcelist{$suffix})) {
  650.                 $sourcelist{$suffix} .= " " . $source;
  651.             } else {
  652.                 $sourcelist{$suffix} .= $source;
  653.             }
  654.         }
  655.         
  656.         foreach $suffix (keys %sourcelist) {
  657.             
  658.             # See if this file contains c++ code. (ie Just check the files suffix against
  659.             my $suffix_is_cxx = 0;
  660.             foreach $cxx_suffix (split(' ', $cppExt)) {
  661.                 $cxx_suffix =~ s/^\*\.//;
  662.                 $cxx_suffix = quotemeta($cxx_suffix);
  663.                 if ($suffix =~ $cxx_suffix) {
  664.                     $suffix_is_cxx = 1;
  665.                     last; # $cxx_suffix
  666.                 }
  667.             }
  668.             
  669.             my $mocfiles_in = ($suffix eq $cxxsuffix) &&
  670.               defined($depedmocs{$program});
  671.             
  672.             my @sourcelist = split(/[\s\034]+/, $sourcelist{$suffix});
  673.             
  674.             if ((@sourcelist == 1 && !$mocfiles_in) || $suffix_is_cxx != 1 ) {
  675.                 
  676.                 # we support IDL on our own
  677.                 if ($suffix =~ /^skel$/ || $suffix =~ /^stub/ || $suffix =~ /^h$/
  678.                     || $suffix =~ /^ui$/ ) {
  679.                     next;
  680.                 }
  681.                 
  682.                 foreach $file (@sourcelist) {
  683.                     
  684.                     $file =~ s/\Q$suffix\E$//;
  685.                     
  686.                     $finalObjs{$program} .= $file;
  687.                     if ($program =~ /_la$/) {
  688.                         $finalObjs{$program} .= "lo ";
  689.                     } else {
  690.                         $finalObjs{$program} .= "o ";
  691.                     }
  692.                 }
  693.                 next; # suffix
  694.             }
  695.             
  696.             my $source_deps = "";
  697.             foreach $source (@sourcelist) {
  698.                 if (-f $source) {
  699.                     $source_deps .= "\$(srcdir)/$source ";
  700.                 } else {
  701.                     $source_deps .= "$source ";
  702.                 }
  703.             }
  704.             
  705.             $handling = "$program.all_$suffix.$suffix: \$(srcdir)/Makefile.in " . $source_deps . " ";
  706.             
  707.             if ($mocfiles_in) {
  708.                 $handling .= $depedmocs{$program};
  709.                 foreach $mocfile (split(' ', $depedmocs{$program})) {
  710.                     if ($mocfile =~ m/\.$suffix$/) {
  711.                         $mocsources .= " " . $mocfile;
  712.                     }
  713.                 }
  714.             }
  715.             
  716.             $handling .= "\n";
  717.             $handling .= "\t\@echo 'creating $program.all_$suffix.$suffix ...'; \\\n";
  718.             $handling .= "\trm -f $program.all_$suffix.files $program.all_$suffix.final; \\\n";
  719.             $handling .= "\techo \"#define KDE_USE_FINAL 1\" >> $program.all_$suffix.final; \\\n";
  720.             $handling .= "\tfor file in " . $sourcelist{$suffix} . " $mocsources; do \\\n";
  721.             $handling .= "\t  echo \"#include \\\"\$\$file\\\"\" >> $program.all_$suffix.files; \\\n";
  722.             $handling .= "\t  test ! -f \$\(srcdir\)/\$\$file || egrep '^#pragma +implementation' \$\(srcdir\)/\$\$file >> $program.all_$suffix.final; \\\n";
  723.             $handling .= "\tdone; \\\n";
  724.             $handling .= "\tcat $program.all_$suffix.final $program.all_$suffix.files  > $program.all_$suffix.$suffix; \\\n";
  725.             $handling .= "\trm -f $program.all_$suffix.final $program.all_$suffix.files\n";
  726.             
  727.             appendLines($handling);
  728.             
  729.             push(@final_names, "$program.all_$suffix.$suffix");
  730.             $finalObjs{$program} .= "$program.all_$suffix.";
  731.             if ($program =~ /_la$/) {
  732.                 $finalObjs{$program} .= "lo ";
  733.             } else {
  734.                 $finalObjs{$program} .= "o ";
  735.             }
  736.         }
  737.     }
  738.     
  739.     if (!$kdeopts{"nofinal"} && @final_names >= 1) {
  740.         # add clean-final target
  741.         my $lines = "$cleantarget-final:\n";
  742.         $lines .= "\t-rm -f " . join(' ', @final_names) . "\n" if (@final_names);
  743.         appendLines($lines);
  744.         $target_adds{"$cleantarget-am"} .= "$cleantarget-final ";
  745.         
  746.         foreach $finalfile (@final_names) {
  747.             $finalfile =~ s/\.[^.]*$/.P/;
  748.             $dep_finals .= " \$(DEPDIR)/$finalfile";
  749.         }
  750.     }
  751. }
  752.  
  753. # Organises the list of headers that we'll use to produce moc files
  754. # from.
  755. sub tag_METASOURCES ()
  756. {
  757.     local @newObs           = ();  # here we add to create object files
  758.     local @deped            = ();  # here we add to create moc files
  759.     local $mocExt           = ".moc";
  760.     local %mocFiles         = ();
  761.  
  762.     my $line = "";
  763.     my $postEqual = "";
  764.  
  765.     my $lookup;
  766.     my $found = "";
  767.  
  768.     if ($metasourceTags > 1) {
  769.     $lookup = $program . '_METASOURCES\s*=\s*(.*)';
  770.     return 1    if ($MakefileData !~ /\n($lookup)\n/);
  771.     $found = $1;
  772.     } else {
  773.     $lookup = $program . '_METASOURCES\s*=\s*(.*)';
  774.     if ($MakefileData !~ /\n($lookup)\n/) {
  775.         $lookup = 'METASOURCES\s*=\s*(.*)';
  776.         return 1    if ($MakefileData !~ /\n($lookup)\n/);
  777.         $found = $1;
  778.         $metasourceTags = 0; # we can use the general target only once
  779.     } else {
  780.             $found = $1;
  781.         }
  782.     }
  783.     print STDOUT "METASOURCE processing <$found>)\n"      if ($verbose);
  784.     
  785.     $postEqual = $found;
  786.     $postEqual =~ s/[^=]*=//;
  787.     
  788.     removeLine ($lookup, $found);
  789.     
  790.     # Always find the header files that could be used to "moc"
  791.     return 1    if (findMocCandidates ());
  792.     
  793.     if ($postEqual =~ /AUTO\s*(\S*)|USE_AUTOMOC\s*(\S*)/)
  794.       {
  795.     print STDERR "$printname: the argument for AUTO|USE_AUTOMOC is obsolete" if ($+);
  796.     $mocExt = ".moc.$cxxsuffix";
  797.     $haveAutomocTag = 1;
  798.     }
  799.     else
  800.     {
  801.         # Not automoc so read the list of files supplied which
  802.         # should be .moc files.
  803.  
  804.         $postEqual =~ tr/\034/ /;
  805.  
  806.         # prune out extra headers - This also checks to make sure that
  807.         # the list is valid.
  808.         pruneMocCandidates ($postEqual);
  809.     }
  810.  
  811.     checkMocCandidates ();
  812.     
  813.     if (@newObs) {
  814.         my $ext =  ($program =~ /_la$/) ? ".moc.lo " : ".moc.o ";
  815.         $realObjs{$program} .= "\034" . join ($ext, @newObs) . $ext;
  816.         $depedmocs{$program} = join (".moc.$cxxsuffix " , @newObs) . ".moc.$cxxsuffix";
  817.         foreach $file (@newObs) {
  818.             $dep_files .= " \$(DEPDIR)/$file.moc.P";
  819.         }
  820.     }
  821.     if (@deped) {
  822.         $depedmocs{$program} .= " ";
  823.         $depedmocs{$program} .= join('.moc ', @deped) . ".moc";
  824.         $depedmocs{$program} .= " ";
  825.     }
  826.     addMocRules ();
  827.     @globalmocs{keys %mocFiles}=values %mocFiles;
  828. }
  829.  
  830. #-----------------------------------------------------------------------------
  831.  
  832. # Returns 0 if the line was processed - 1 otherwise.
  833. # Errors are logged in the global $errorflags
  834. sub tag_AUTOMAKE ()
  835. {
  836.     my $lookup = '.*cd \$\(top_srcdir\)\s+&&\s+\$\(AUTOMAKE\)(.*)';
  837.     return 1    if ($MakefileData !~ /($lookup)/);
  838.     print STDOUT "AUTOMAKE processing <$1>\n"        if ($verbose);
  839.  
  840.     my $newLine = $1."\n\tcd \$(top_srcdir) && perl $thisProg $printname";
  841.     substituteLine ($lookup, $newLine);
  842.     $automkCall = $1;
  843.     return 0;
  844. }
  845.  
  846. #-----------------------------------------------------------------------------
  847.  
  848. sub tag_TOPLEVEL()
  849. {
  850.     my $lookup = 'TOPLEVEL_LANG\s*=\s*(\S+)';
  851.     return 1 if ($MakefileData !~ /\n$lookup\n/);
  852.     my $lang = $1;
  853.  
  854.     if (tag_SUBDIRS()) {
  855.         print STDERR "Error: TOPLEVEL_LANG without SUBDIRS = \$(AUTODIRS) in $printname\n";
  856.         $errorflag = 1;
  857.         return 1;
  858.     }
  859.     
  860.     my $pofiles = "";
  861.     my @restfiles = ();
  862.     opendir (THISDIR, ".");
  863.     foreach $entry (readdir(THISDIR)) {
  864.         next if (-d $entry);
  865.         
  866.         next if ($entry eq "CVS" || $entry =~ /^\./  || $entry =~ /^Makefile/ || $entry =~ /~$/ || $entry =~ /^\#.*\#$/ || $entry =~ /.gmo$/);
  867.                  
  868.         if ($entry =~ /\.po$/) {
  869.             $pofiles .= "$entry ";
  870.             next;
  871.         }
  872.         push(@restfiles, $entry);
  873.     }
  874.     closedir (THISDIR);
  875.     
  876.     print STDOUT "pofiles found = $pofiles\n"   if ($verbose);
  877.     handle_POFILES($pofiles, '$(TOPLEVEL_LANG)') if ($pofiles);
  878.     
  879.     if (@restfiles) {
  880.         $target_adds{"install-data-am"} .= "install-nls-files ";
  881.         $lines = "install-nls-files:\n";
  882.         $lines .= "\t\$(mkinstalldirs) \$(DESTDIR)\$(kde_locale)/$lang\n";
  883.         for $file (@restfiles) {
  884.             $lines .= "\t\$(INSTALL_DATA) \$\(srcdir\)/$file \$(DESTDIR)\$(kde_locale)/$lang/$file\n";
  885.         }
  886.         appendLines($lines);
  887.     }
  888.     
  889.     return 0;
  890. }
  891.  
  892. #-----------------------------------------------------------------------------
  893.  
  894. sub tag_SUBDIRS ()
  895. {
  896.   if ($MakefileData !~ /\nSUBDIRS\s*=\s*\$\(AUTODIRS\)\s*\n/) {
  897.     return 1;
  898.   }
  899.  
  900.   my $subdirs;
  901.  
  902.   opendir (THISDIR, ".");
  903.   foreach $entry (readdir(THISDIR)) {
  904.     next if ($entry eq "CVS" || $entry =~ /^\./);
  905.     if (-d $entry && -f $entry . "/Makefile.am") {
  906.       $subdirs .= " $entry";
  907.       next;
  908.     }
  909.   }
  910.   closedir (THISDIR);
  911.  
  912.   my $lines = "SUBDIRS =$subdirs\n";
  913.   substituteLine('SUBDIRS\s*=.*', $lines);
  914.   return 0;
  915. }
  916.  
  917. sub tag_IDLFILES ()
  918. {
  919.     my @psources = split(/[\034\s]+/, $sources{$program});
  920.     my $dep_lines = "";
  921.     my @cppFiles = ();
  922.     
  923.     foreach $source (@psources) {
  924.         
  925.         my $skel = ($source =~ m/\.skel$/);
  926.         
  927.         if ($source =~ m/\.stub$/ || $skel) {
  928.             
  929.             my $qs = quotemeta($source);
  930.             $sources{$program} =~ s/$qs//;
  931.             $sources_changed{$program} = 1;
  932.             
  933.             print STDOUT "adding IDL file $source\n" if ($verbose);
  934.             
  935.             $source =~ s/\.(stub|skel)$//;
  936.             
  937.             my $sourcename;
  938.             
  939.             if ($skel) {
  940.                 $sourcename = "$source\_skel";
  941.             } else {
  942.                 $sourcename = "$source\_stub";
  943.             }
  944.             
  945.             my $sourcedir = '';
  946.             if (-f "$makefileDir/$source.h") {
  947.                 $sourcedir = '$(srcdir)/';
  948.             } else {
  949.                 if ($MakefileData =~ /\n$source\_DIR\s*=\s*(\S+)\n/) {
  950.                     $sourcedir = $1;
  951.                     $sourcedir .= "/" if ($sourcedir !~ /\/$/);
  952.                 }
  953.             }
  954.             
  955.             if ($allidls !~ /$source\_kidl/) {
  956.                 
  957.                 $dep_lines .= "$source.kidl: $sourcedir$source.h \$(DCOPIDL_DEPENDENCIES)\n";
  958.                 $dep_lines .= "\t\$(DCOPIDL) $sourcedir$source.h > $source.kidl || ( rm -f $source.kidl ; /bin/false )\n";
  959.                 
  960.                 $allidls .= $source . "_kidl ";
  961.             }
  962.             
  963.             if ($allidls !~ /$sourcename/) {
  964.                 
  965.                 if ($skel) {
  966.                     $dep_lines .= "$sourcename.$cxxsuffix: $source.kidl\n";
  967.                     $dep_lines .= "\t\$(DCOPIDL2CPP) --c++-suffix $cxxsuffix --no-stub $source.kidl\n";
  968.                 } else {
  969.                     $target_adds{"$sourcename.$cxxsuffix"} .= "$sourcename.h ";
  970.                     $dep_lines .= "$sourcename.h: $source.kidl\n";
  971.                     $dep_lines .= "\t\$(DCOPIDL2CPP) --c++-suffix $cxxsuffix --no-skel $source.kidl\n";
  972.                 }
  973.                 
  974.                 $allidls .= $sourcename . " ";
  975.             }
  976.             
  977.             $idlfiles{$program} .= $sourcename . " ";
  978.             
  979.             if ($program =~ /_la$/) {
  980.                 $realObjs{$program} .= " $sourcename.lo";
  981.             } else {
  982.                 $realObjs{$program} .= " $sourcename.\$(OBJEXT)";
  983.             }
  984.             $sources{$program} .= " $sourcename.$cxxsuffix";
  985.             $sources_changed{$program} = 1;
  986.             $important{$program} .= "$sourcename.h " if (!$skel);
  987.             $idl_output .= "\\\n\t$sourcename.$cxxsuffix $sourcename.h $source.kidl ";
  988.             push(@cleanfiles, "$sourcename.$cxxsuffix");
  989.             push(@cleanfiles, "$sourcename.h");
  990.             push(@cleanfiles, "$sourcename.kidl");
  991.             $dep_files .= " \$(DEPDIR)/$sourcename.P";
  992.         }
  993.     }
  994.     if ($dep_lines) {
  995.         appendLines($dep_lines);
  996.     }
  997.     
  998.     if (0) {
  999.         my $lookup = "($program)";
  1000.         $lookup .= '(|\$\(EXEEXT\))';
  1001.         $lookup =~ s/\_/./g;
  1002.         $lookup .= ":(.*..$program\_OBJECTS..*)";
  1003.         #    $lookup = quotemeta($lookup);
  1004.         if ($MakefileData =~ /\n$lookup\n/) {
  1005.             
  1006.             my $line = "$1$2: ";
  1007.             foreach $file (split(' ', $idlfiles{$program})) {
  1008.                 $line .= "$file.$cxxsuffix ";
  1009.             }
  1010.             $line .= $3;
  1011.             substituteLine($lookup, $line);
  1012.         } else {
  1013.             print STDERR "no built dependency found $lookup\n";
  1014.         }
  1015.     }
  1016. }
  1017.  
  1018. sub tag_UIFILES ()
  1019. {
  1020.     my @psources = split(/[\034\s]+/, $sources{$program});
  1021.     my $dep_lines = "";
  1022.     my @depFiles = ();
  1023.     
  1024.     foreach $source (@psources) {
  1025.  
  1026.         if ($source =~ m/\.ui$/) {
  1027.  
  1028.             print STDERR "adding UI file $source\n" if ($verbose);
  1029.  
  1030.             my $qs = quotemeta($source);
  1031.             $sources{$program} =~ s/$qs//;
  1032.             $sources_changed{$program} = 1;
  1033.       
  1034.             $source =~ s/\.ui$//;
  1035.  
  1036.             my $sourcedir = '';
  1037.             if (-f "$makefileDir/$source.ui") {
  1038.                 $sourcedir = '$(srcdir)/';
  1039.             }
  1040.  
  1041.             if ($alluis !~ /$source/) {
  1042.  
  1043.                 $dep_lines .= "$source.$cxxsuffix: $sourcedir$source.ui $source.h $source.moc\n";
  1044.                 $dep_lines .= "\trm -f $source.$cxxsuffix\n";
  1045.                 if (!$kdeopts{"qtonly"}) {
  1046.                     $dep_lines .= "\techo '#include <klocale.h>' > $source.$cxxsuffix\n";
  1047.                     $dep_lines .= "\t\$(UIC) -tr i18n -i $source.h $sourcedir$source.ui | sed -e \"s,i18n( \\\"\\\" ),QString::null,g\" >> $source.$cxxsuffix || rm -f $source.$cxxsuffix\n";
  1048.                 } else {
  1049.                     $dep_lines .= "\t\$(UIC) -i $source.h $sourcedir$source.ui > $source.$cxxsuffix || rm -f $source.$cxxsuffix\n";
  1050.                 }
  1051.                 $dep_lines .= "\techo '#include \"$source.moc\"' >> $source.$cxxsuffix\n\n";
  1052.                 $dep_lines .= "$source.h: $sourcedir$source.ui\n";
  1053.                 $dep_lines .= "\t\$(UIC) -o $source.h $sourcedir$source.ui\n\n";
  1054.                 $dep_lines .= "$source.moc: $source.h\n";
  1055.                 $dep_lines .= "\t\$(MOC) $source.h -o $source.moc\n";
  1056.  
  1057.                 $alluis .= "$source ";
  1058.                 $ui_mocs .= " $source.moc";
  1059.                 $depedmocs{$program} .= " $source.moc";
  1060.             }
  1061.             
  1062.             if ($program =~ /_la$/) {
  1063.                 $realObjs{$program} .= " $source.lo";
  1064.             } else {
  1065.                 $realObjs{$program} .= " $source.\$(OBJEXT)";
  1066.             }
  1067.             $sources{$program} .= " $source.$cxxsuffix";
  1068.             $sources_changed{$program} = 1;
  1069.             $important{$program} .= "$source.h ";
  1070.             $ui_output .= "\\\n\t$source.$cxxsuffix $source.h $source.moc ";
  1071.             push(@cleanfiles, "$source.$cxxsuffix");
  1072.             push(@cleanfiles, "source.h");
  1073.             push(@cleanfiles, "$source.moc");
  1074.  
  1075.             $dep_files .= " \$(DEPDIR)/$source.P";
  1076.         }
  1077.     }
  1078.     if ($dep_lines) {
  1079.         appendLines($dep_lines);
  1080.     }
  1081. }
  1082.  
  1083. sub tag_ICON()
  1084. {
  1085.     my $lookup = '([^\s]*)_ICON\s*=\s*([^\n]*)';
  1086.     my $install = "";
  1087.     my $uninstall = "";
  1088.  
  1089.     while ($MakefileData =~ /\n$lookup/g) {
  1090.         my $destdir;
  1091.         if ($1 eq "KDE") {
  1092.             $destdir = "kde_icondir";
  1093.         } else {
  1094.             $destdir = $1 . "dir";
  1095.         }
  1096.         my $iconauto = ($2 =~ /AUTO\s*$/);
  1097.         my @appnames = ();
  1098.         if ( ! $iconauto ) {
  1099.             my @_appnames = split(" ", $2);
  1100.             print STDOUT "KDE_ICON processing <@_appnames>\n"   if ($verbose);
  1101.             foreach $appname (@_appnames) {
  1102.                 push(@appnames, quotemeta($appname));
  1103.             }
  1104.         } else {
  1105.             print STDOUT "KDE_ICON processing <AUTO>\n"   if ($verbose);
  1106.         }
  1107.  
  1108.         my @files = ();
  1109.         opendir (THISDIR, ".");
  1110.         foreach $entry (readdir(THISDIR)) {
  1111.             next if ($entry eq "CVS" || $entry =~ /^\./  || $entry =~ /^Makefile/ || $entry =~ /~$/ || $entry =~ /^\#.*\#$/);
  1112.             next if (! -f $entry);
  1113.             if ( $iconauto )
  1114.               {
  1115.                   push(@files, $entry)
  1116.                     if ($entry =~ /\.xpm/ || $entry =~ /\.png/);
  1117.               } else {
  1118.                   foreach $appname (@appnames) {
  1119.                       push(@files, $entry)
  1120.                         if ($entry =~ /-$appname\.xpm/ || $entry =~ /-$appname\.png/);
  1121.                   }
  1122.               }
  1123.         }
  1124.         closedir (THISDIR);
  1125.         
  1126.         my %directories = ();
  1127.         
  1128.         foreach $file (@files) {
  1129.             my $newfile = $file;
  1130.             my $prefix = $file;
  1131.             $prefix =~ s/\.(png|xpm)$//;
  1132.             my $appname = $prefix;
  1133.             $appname =~ s/^[^-]+-// if ($appname =~ /-/) ;
  1134.             $appname =~ s/^[^-]+-// if ($appname =~ /-/) ;
  1135.             $appname = quotemeta($appname);
  1136.             $prefix =~ s/$appname$//;
  1137.             $prefix =~ s/-$//;
  1138.             
  1139.             $prefix = 'lo16-app' if ($prefix eq 'mini');
  1140.             $prefix = 'lo32-app' if ($prefix eq 'lo');
  1141.             $prefix = 'hi48-app' if ($prefix eq 'large');
  1142.             $prefix .= '-app' if ($prefix =~ m/^...$/);
  1143.             
  1144.             my $type = $prefix;
  1145.             $type =~ s/^.*-([^-]+)$/$1/;
  1146.             $prefix =~ s/^(.*)-[^-]+$/$1/;
  1147.             
  1148.             my %type_hash =
  1149.               (
  1150.                'action' => 'actions',
  1151.                'app' => 'apps',
  1152.                'device' => 'devices',
  1153.                'filesys' => 'filesystems',
  1154.                'mime' => 'mimetypes'
  1155.               );
  1156.             
  1157.             if (! defined $type_hash{$type} ) {
  1158.                 print STDERR "unknown icon type $type in $printname ($file)\n";
  1159.                 next;
  1160.             }
  1161.             
  1162.             my %dir_hash =
  1163.               (
  1164.                'los' => 'locolor/16x16',
  1165.                'lom' => 'locolor/32x32',
  1166.                'him' => 'hicolor/32x32',
  1167.                'hil' => 'hicolor/48x48',
  1168.                'lo16' => 'locolor/16x16',
  1169.                'lo22' => 'locolor/22x22',
  1170.                'lo32' => 'locolor/32x32',
  1171.                'hi16' => 'hicolor/16x16',
  1172.                'hi22' => 'hicolor/22x22',
  1173.                'hi32' => 'hicolor/32x32',
  1174.                'hi48' => 'hicolor/48x48',
  1175.                'hisc' => 'hicolor/scalable'
  1176.               );
  1177.             
  1178.             $newfile =~ s@.*-($appname\.(png|xpm?))@$1@;
  1179.             
  1180.             if (! defined $dir_hash{$prefix}) {
  1181.                 print STDERR "unknown icon prefix $prefix in $printname\n";
  1182.                 next;
  1183.             }
  1184.             
  1185.             my $dir = $dir_hash{$prefix} . "/" . $type_hash{$type};
  1186.             if ($newfile =~ /-[^\.]/) {
  1187.                 my $tmp = $newfile;
  1188.                 $tmp =~ s/^([^-]+)-.*$/$1/;
  1189.                 $dir = $dir . "/" . $tmp;
  1190.                 $newfile =~ s/^[^-]+-//;
  1191.             }
  1192.             
  1193.             if (!defined $directories{$dir}) {
  1194.                 $install .= "\t\$(mkinstalldirs) \$(DESTDIR)\$($destdir)/$dir\n";
  1195.                 $directories{$dir} = 1;
  1196.             }
  1197.             
  1198.             $install .= "\t\$(INSTALL_DATA) \$(srcdir)/$file \$(DESTDIR)\$($destdir)/$dir/$newfile\n";
  1199.             $uninstall .= "\t-rm -f \$(DESTDIR)\$($destdir)/$dir/$newfile\n";
  1200.             
  1201.         }
  1202.     }
  1203.     
  1204.     if (length($install)) {
  1205.         $target_adds{"install-data-am"} .= "install-kde-icons ";
  1206.         $target_adds{"uninstall-am"} .= "uninstall-kde-icons ";
  1207.         appendLines("install-kde-icons:\n" . $install . "\nuninstall-kde-icons:\n" . $uninstall);
  1208.     }
  1209. }
  1210.  
  1211. sub handle_POFILES($$)
  1212. {
  1213.   my @pofiles = split(" ", $_[0]);
  1214.   my $lang = $_[1];
  1215.  
  1216.   # Build rules for creating the gmo files
  1217.   my $tmp = "";
  1218.   my $allgmofiles     = "";
  1219.   my $pofileLine   = "POFILES =";
  1220.   foreach $pofile (@pofiles)
  1221.     {
  1222.         $pofile =~ /(.*)\.[^\.]*$/;          # Find name minus extension
  1223.         $tmp .= "$1.gmo: $pofile\n";
  1224.         $tmp .= "\trm -f $1.gmo; \$(GMSGFMT) -o $1.gmo \$(srcdir)/$pofile\n";
  1225.         $tmp .= "\ttest ! -f $1.gmo || touch $1.gmo\n";
  1226.         $allgmofiles .= " $1.gmo";
  1227.         $pofileLine  .= " $1.po";
  1228.     }
  1229.   appendLines ($tmp);
  1230.   my $lookup = 'POFILES\s*=([^\n]*)';
  1231.   if ($MakefileData !~ /\n$lookup/) {
  1232.     appendLines("$pofileLine\nGMOFILES =$allgmofiles");
  1233.   } else {
  1234.     substituteLine ($lookup, "$pofileLine\nGMOFILES =$allgmofiles");
  1235.   }
  1236.  
  1237.     if ($allgmofiles) {
  1238.  
  1239.         # Add the "clean" rule so that the maintainer-clean does something
  1240.         appendLines ("clean-nls:\n\t-rm -f $allgmofiles\n");
  1241.  
  1242.     $target_adds{"maintainer-clean"} .= "clean-nls ";
  1243.  
  1244.     $lookup = 'DISTFILES\s*=\s*(.*)';
  1245.     if ($MakefileData =~ /\n$lookup\n/) {
  1246.       $tmp = "DISTFILES = \$(GMOFILES) \$(POFILES) $1";
  1247.       substituteLine ($lookup, $tmp);
  1248.     }
  1249.     }
  1250.  
  1251.   $target_adds{"install-data-am"} .= "install-nls ";
  1252.  
  1253.   $tmp = "install-nls:\n";
  1254.   $tmp .= "install-nls:\n";
  1255.   if ($lang) {
  1256.     $tmp  .= "\t\$(mkinstalldirs) \$(DESTDIR)\$(kde_locale)/$lang/LC_MESSAGES\n";
  1257.   }
  1258.   $tmp .= "\t\@for base in ";
  1259.   foreach $pofile (@pofiles)
  1260.     {
  1261.       $pofile =~ /(.*)\.[^\.]*$/;          # Find name minus extension
  1262.       $tmp .= "$1 ";
  1263.     }
  1264.  
  1265.   $tmp .= "; do \\\n";
  1266.   if ($lang) {
  1267.     $tmp .= "\t  echo \$(INSTALL_DATA) \$\$base.gmo \$(DESTDIR)\$(kde_locale)/$lang/LC_MESSAGES/\$\$base.mo ;\\\n";
  1268.     $tmp .= "\t  test ! -f \$\$base.gmo || \$(INSTALL_DATA) \$\$base.gmo \$(DESTDIR)\$(kde_locale)/$lang/LC_MESSAGES/\$\$base.mo ;\\\n"
  1269.   } else {
  1270.     $tmp .= "\t  echo \$(INSTALL_DATA) \$\$base.gmo \$(DESTDIR)\$(kde_locale)/\$\$base/LC_MESSAGES/\$(PACKAGE).mo ;\\\n";
  1271.     $tmp .= "\t  \$(mkinstalldirs) \$(DESTDIR)\$(kde_locale)/\$\$base/LC_MESSAGES ; \\\n";
  1272.     $tmp .= "\t  test ! -f \$\$base.gmo || \$(INSTALL_DATA) \$\$base.gmo \$(DESTDIR)\$(kde_locale)/\$\$base/LC_MESSAGES/\$(PACKAGE).mo ;\\\n";
  1273.   }
  1274.   $tmp .= "\tdone\n\n";
  1275.   appendLines ($tmp);
  1276.  
  1277.   $target_adds{"uninstall"} .= "uninstall-nls ";
  1278.  
  1279.   $tmp = "uninstall-nls:\n";
  1280.   foreach $pofile (@pofiles)
  1281.     {
  1282.       $pofile =~ /(.*)\.[^\.]*$/;          # Find name minus extension
  1283.       if ($lang) {
  1284.     $tmp .= "\trm -f \$(DESTDIR)\$(kde_locale)/$lang/LC_MESSAGES/$1.mo\n";
  1285.       } else {
  1286.     $tmp .= "\trm -f \$(DESTDIR)\$(kde_locale)/$1/LC_MESSAGES/\$(PACKAGE).mo\n";
  1287.       }
  1288.     }
  1289.   appendLines($tmp);
  1290.  
  1291.   $target_adds{"all"} .= "all-nls ";
  1292.  
  1293.   $tmp = "all-nls: \$(GMOFILES)\n";
  1294.  
  1295.   appendLines($tmp);
  1296.  
  1297.   $target_adds{"distdir"} .= "distdir-nls ";
  1298.  
  1299.   $tmp = "distdir-nls:\$(GMOFILES)\n";
  1300.   $tmp .= "\tfor file in \$(POFILES); do \\\n";
  1301.   $tmp .= "\t  cp \$(srcdir)/\$\$file \$(distdir); \\\n";
  1302.   $tmp .= "\tdone\n";
  1303.   $tmp .= "\ttest -z \"\$(GMOFILES)\" || cp \$(GMOFILES) \$(distdir)\n";
  1304.  
  1305.   appendLines ($tmp);
  1306.  
  1307.   if (!$lang) {
  1308.     appendLines("merge:\n\t\$(MAKE) -f \$(top_srcdir)/admin/Makefile.common package-merge POFILES=\"\${POFILES}\" PACKAGE=\${PACKAGE}\n\n");
  1309.   }
  1310.  
  1311. }
  1312.  
  1313. #-----------------------------------------------------------------------------
  1314.  
  1315. # Returns 0 if the line was processed - 1 otherwise.
  1316. # Errors are logged in the global $errorflags
  1317. sub tag_POFILES ()
  1318. {
  1319.     my $lookup = 'POFILES\s*=([^\n]*)';
  1320.     return 1    if ($MakefileData !~ /\n$lookup/);
  1321.     print STDOUT "POFILES processing <$1>\n"   if ($verbose);
  1322.  
  1323.     my $tmp = $1;
  1324.  
  1325.     # make sure these are all gone.
  1326.     if ($MakefileData =~ /\n\.po\.gmo:\n/)
  1327.     {
  1328.         print STDERR "Warning: Found old .po.gmo rules in $printname. New po rules not added\n";
  1329.         return 1;
  1330.     }
  1331.  
  1332.     # Either find the pofiles in the directory (AUTO) or use
  1333.     # only the specified po files.
  1334.     my $pofiles = "";
  1335.     if ($tmp =~ /^\s*AUTO\s*$/)
  1336.     {
  1337.         opendir (THISDIR, ".");
  1338.     next if ($entry eq "CVS" || $entry =~ /^\./  || $entry =~ /^Makefile/ || $entry =~ /~$/ || $entry =~ /^#.*#$/);
  1339.     $pofiles =  join(" ", grep(/\.po$/, readdir(THISDIR)));
  1340.         closedir (THISDIR);
  1341.         print STDOUT "pofiles found = $pofiles\n"   if ($verbose);
  1342.     }
  1343.     else
  1344.     {
  1345.         $tmp =~ s/\034/ /g;
  1346.         $pofiles = $tmp;
  1347.     }
  1348.     return 1    if (!$pofiles);        # Nothing to do
  1349.  
  1350.     handle_POFILES($pofiles, $kdelang);
  1351.  
  1352.     return 0;
  1353. }
  1354.  
  1355. sub helper_LOCALINSTALL($)
  1356. {
  1357.   my $lookup = "\n" . $_[0] . ":";
  1358.   if ($MakefileData =~ /($lookup)/) {
  1359.  
  1360.     my $install = $MakefileData;
  1361.     $install =~ s/\n/\035/g;
  1362.     $install =~ s/.*\035$_[0]:[^\035]*\035//;
  1363.     my $emptyline = 0;
  1364.     while (! $emptyline) {
  1365.       if ($install =~ /([^\035]*)\035(.*)/) {
  1366.     local $line = $1;
  1367.     $install = $2;
  1368.     if ($line !~ /^\s*$/ && $line !~ /^(\@.*\@)*\t/) {
  1369.       $emptyline = 1;
  1370.     } else {
  1371.       replaceDestDir($line);
  1372.     }
  1373.       } else {
  1374.     $emptyline = 1;
  1375.       }
  1376.     }
  1377.   }
  1378.  
  1379. }
  1380.  
  1381. sub tag_LOCALINSTALL ()
  1382. {
  1383.   helper_LOCALINSTALL('install-exec-local');
  1384.   helper_LOCALINSTALL('install-data-local');
  1385.   helper_LOCALINSTALL('uninstall-local');
  1386.  
  1387.   return 0;
  1388. }
  1389.  
  1390. sub replaceDestDir($) {
  1391.   local $line = $_[0];
  1392.  
  1393.   if (   $line =~ /^\s*(\@.*\@)*\s*\$\(mkinstalldirs\)/
  1394.       || $line =~ /^\s*(\@.*\@)*\s*\$\(INSTALL\S*\)/
  1395.       || $line =~ /^\s*(\@.*\@)*\s*(-?rm.*) \S*$/)
  1396.   {
  1397.     $line =~ s/^(.*) ([^\s]*)\s*$/$1 \$(DESTDIR)$2/ if ($line !~ /\$\(DESTDIR\)/);
  1398.   }
  1399.  
  1400.   if ($line ne $_[0]) {
  1401.     $_[0] = quotemeta $_[0];
  1402.     substituteLine($_[0], $line);
  1403.   }
  1404. }
  1405.  
  1406. #---------------------------------------------------------------------------
  1407. sub tag_CLOSURE () {
  1408.     return if ($program !~ /_la$/);
  1409.     
  1410.     my $lookup = quotemeta($realname{$program}) . ":.*?\n\t.*?\\((.*?)\\) .*\n";
  1411.     $MakefileData =~ m/$lookup/;
  1412.     return if ($1 !~ /CXXLINK/);
  1413.  
  1414.     if ($MakefileData !~ /\n$program\_LDFLAGS\s*=.*-no-undefined/ &&
  1415.         $MakefileData !~ /\n$program\_LDFLAGS\s*=.*KDE_PLUGIN/ ) {
  1416.         print STDERR "Report: $program contains undefined in $printname\n" if ($program =~ /^lib/ && $dryrun);
  1417.         return;
  1418.     }
  1419.     my $closure = $realname{$program} . ".closure";
  1420.     my $lines = "$closure: \$($program\_OBJECTS) \$($program\_DEPENDENCIES)\n";
  1421.     $lines .= "\t\@echo \"int main() {return 0;}\" > $program\_closure.$cxxsuffix\n";
  1422.     $lines .= "\t\@\$\(LTCXXCOMPILE\) -c $program\_closure.$cxxsuffix\n";
  1423.     $lines .= "\t\@\$\(CXXLINK\) $program\_closure.lo \$($program\_LDFLAGS) \$($program\_OBJECTS) \$($program\_LIBADD) \$(LIBS)\n";
  1424.     $lines .= "\t\@rm -f $program\_closure.* $closure\n";
  1425.     $lines .= "\t\@echo \"timestamp\" > $closure\n";
  1426.     $lines .= "\n";
  1427.     appendLines($lines);
  1428.     $lookup = $realname{$program} . ": (.*)";
  1429.     if ($MakefileData =~ /\n$lookup\n/) {
  1430.         $lines  = "\@KDE_USE_CLOSURE_TRUE@". $realname{$program} . ": $closure $1";
  1431.         $lines .= "\n\@KDE_USE_CLOSURE_FALSE@" . $realname{$program} . ": $1";
  1432.         substituteLine($lookup, $lines);
  1433.     }
  1434.     $closure_output .= " $closure";
  1435. }
  1436.  
  1437. sub tag_DIST () {
  1438.     my %foundfiles = ();
  1439.     opendir (THISDIR, ".");
  1440.     foreach $entry (readdir(THISDIR)) {
  1441.         next if ($entry eq "CVS" || $entry =~ /^\./  || $entry =~ /^Makefile$$/ || $entry =~ /~$/ || $entry =~ /^\#.*\#$/);
  1442.         next if (! -f $entry);
  1443.         next if ($entry =~ /\.moc/ || $entry =~ /\.lo$/ || $entry =~ /\.la$/ || $entry =~ /\.o/);
  1444.         $foundfiles{$entry} = 1;
  1445.     }
  1446.     closedir (THISDIR);
  1447.  
  1448.     my @marks = ("EXTRA_DIST", "DIST_COMMON", '\S*_SOURCES', '\S*_HEADERS', 'MAINTAINERCLEANFILES', 'CLEANFILES', 'DISTCLEANFILES', '\S*_OBJECTS');
  1449.     foreach $mark (@marks) {
  1450.         while ($MakefileData =~ /\n($mark)\s*=\s*([^\n]*)/g) {
  1451.             foreach $file (split('[\034\s]', $2)) {
  1452.                 $file =~ s/\.\///;
  1453.                 $foundfiles{$file} = 0 if (defined $foundfiles{$file});
  1454.             }
  1455.         }
  1456.     }
  1457.     my @files = ("Makefile", "config.cache", "config.log", "stamp-h",
  1458.                  "stamp-h1", "stamp-h1", "config.h", "Makefile", "config.status", "config.h", "libtool");
  1459.     foreach $file (@files) {
  1460.         $foundfiles{$file} = 0 if (defined $foundfiles{$file});
  1461.     }
  1462.  
  1463.     my $KDE_DIST = "";
  1464.     foreach $file (keys %foundfiles) {
  1465.         if ($foundfiles{$file} == 1) {
  1466.             $KDE_DIST .= "$file ";
  1467.         }
  1468.     }
  1469.     if ($KDE_DIST) {
  1470.         print "KDE_DIST $printname $KDE_DIST\n" if ($verbose);
  1471.         
  1472.         my $lookup = "DISTFILES *=(.*)";
  1473.         if ($MakefileData =~ /\n$lookup\n/) {
  1474.             substituteLine($lookup, "KDE_DIST=$KDE_DIST\n\nDISTFILES=$1 \$(KDE_DIST)\n");
  1475.         }
  1476.     }
  1477. }
  1478.  
  1479. #-----------------------------------------------------------------------------
  1480. # Returns 0 if the line was processed - 1 otherwise.
  1481. # Errors are logged in the global $errorflags
  1482. sub tag_DOCFILES ()
  1483. {
  1484. #    if ($MakefileData =~ /\nSUBDIRS\s*=/) { # subdirs
  1485. #      $MakefileData =~ /\n(.*-recursive:\s*)\n/;
  1486. #      my $orig_rules = $1;
  1487. #      my $rules = $orig_rules;
  1488. #      $rules =~ s/:\s*$//;
  1489. #      substituteLine($orig_rules, "$rules docs-recursive:");
  1490. #      appendLines("docs: docs-recursive docs-am\n");
  1491. #    } else {
  1492. #      appendLines("docs: docs-am\n");
  1493. #    }
  1494.     $target_adds{"all"} .= "docs-am ";
  1495.  
  1496.     my $lookup = 'KDE_DOCS\s*=\s*([^\n]*)';
  1497.     goto nodocs    if ($MakefileData !~ /\n$lookup/);
  1498.     print STDOUT "KDE_DOCS processing <$1>\n"   if ($verbose);
  1499.  
  1500.     tag_SUBDIRS();
  1501.  
  1502.     my $tmp = $1;
  1503.  
  1504.     # Either find the files in the directory (AUTO) or use
  1505.     # only the specified po files.
  1506.     my $files = "";
  1507.     my $appname = $tmp;
  1508.     $appname =~ s/^(\S*)\s*.*$/$1/;
  1509.     if ($appname =~ /AUTO/) {
  1510.       $appname = basename($makefileDir);
  1511.       if ("$appname" eq "en") {
  1512.             print STDERR "Error: KDE_DOCS = AUTO relies on the directory name. Yours is 'en' - you most likely want something else, e.g. KDE_DOCS = myapp\n";
  1513.           exit(1);
  1514.       }
  1515.     }
  1516.  
  1517.     if ($tmp !~ / - /)
  1518.     {
  1519.         opendir (THISDIR, ".");
  1520.     foreach $entry (readdir(THISDIR)) {
  1521.       next if ($entry eq "CVS" || $entry =~ /^\./  || $entry =~ /^Makefile/ || $entry =~ /~$/ || $entry =~ /^\#.*\#$/);
  1522.       next if (! -f $entry);
  1523.       $files .= "$entry ";
  1524.     }
  1525.         closedir (THISDIR);
  1526.         print STDOUT "docfiles found = $files\n"   if ($verbose);
  1527.     }
  1528.     else
  1529.     {
  1530.         $tmp =~ s/\034/ /g;
  1531.     $tmp =~ s/^\S*\s*-\s*//;
  1532.         $files = $tmp;
  1533.     }
  1534.     goto nodocs if (!$files);        # Nothing to do
  1535.  
  1536.     if ($files =~ /(^| )index\.docbook($| )/) {
  1537.       
  1538.       my $lines = "";
  1539.       my $lookup = 'KDB2HTML\s*=';
  1540.       #if ($MakefileData !~ /\n($lookup)/) {
  1541. #    $lines = "KDB2HTML = \$(SHELL) /\$(kde_bindir)/kdb2html\n";
  1542. #      }
  1543.        $lines .= "docs-am:\n";
  1544. #      $lines .= "docs-am: HTML HTML/index.html\n";
  1545. #      $lines .= "\n";
  1546. #      $lines .= "HTML:\n";
  1547. #      $lines .= "\ttest -d HTML || mkdir HTML\n";
  1548. #      $lines .= "\n";
  1549. #      $lines .= "HTML/index.html: HTML index.docbook\n";
  1550. #      $lines .= "\t\@test -d HTML && rm -r HTML\n";
  1551. #      $lines .= "\t\$(KDB2HTML) \$(srcdir)/index.docbook\n";
  1552. #      $lines .= "\n";
  1553.       $lines .= "install-docs:\n";
  1554.       $lines .= "\t\$(mkinstalldirs) \$(DESTDIR)\$(kde_htmldir)/$kdelang/$appname\n";
  1555.       $lines .= "\t-\@filelist=\"\" ;\\\n";
  1556.       $lines .= "\tif test -d HTML; then \\\n";
  1557.       $lines .= "\t  filelist=`(cd HTML && ls -1 * .anchors 2> /dev/null)`; \\\n";
  1558.       $lines .= "\t  dir=HTML; \\\n";
  1559.       $lines .= "\telse if test -d \$(srcdir)/HTML; then \\\n";
  1560.       $lines .= "\t  filelist=`(cd \$(srcdir)/HTML && ls -1 * .anchors 2> /dev/null)`; \\\n";
  1561.       $lines .= "\t  dir=\"\$(srcdir)/HTML\" ;\\\n";
  1562.       $lines .= "\tfi ; fi ;\\\n";
  1563.       $lines .= "\tfor file in \$\$filelist; do if test -f \$\$dir/\$\$file; then \\\n";
  1564.       $lines .= "\techo \$(INSTALL_DATA) \$\$dir/\$\$file \$(DESTDIR)\$(kde_htmldir)/$kdelang/$appname/\$\$file ;\\\n";
  1565.       $lines .= "\t\$(INSTALL_DATA) \$\$dir/\$\$file \$(DESTDIR)\$(kde_htmldir)/$kdelang/$appname/\$\$file; \\\n";
  1566.       $lines .= "\tfi; done\n";
  1567.       $lines .= "\t-rm -f \$(DESTDIR)\$(kde_htmldir)/$kdelang/$appname/common\n";
  1568.       $lines .= "\t\$(LN_S) \$(kde_libs_htmldir)/$kdelang/common \$(DESTDIR)\$(kde_htmldir)/$kdelang/$appname/common\n";
  1569.  
  1570.       $lines .= "\n";
  1571.       $lines .= "uninstall-docs:\n";
  1572.       $lines .= "\t-rm -rf \$(kde_htmldir)/$kdelang/$appname\n";
  1573.       $lines .= "\n";
  1574.       $target_adds{"install-data-am"} .= "install-docs ";
  1575.       $target_adds{"uninstall"} .= "uninstall-docs ";
  1576.       appendLines ($lines);
  1577.     } else {
  1578.       appendLines("docs-am:\n");
  1579.     }
  1580.  
  1581.     $target_adds{"install-data-am"} .= "install-nls";
  1582.     $target_adds{"uninstall"} .= "uninstall-nls ";
  1583.  
  1584.     $tmp = "install-nls:\n";
  1585.     $tmp .= "\t\$(mkinstalldirs) \$(DESTDIR)\$(kde_htmldir)/$kdelang/$appname\n";
  1586.     $tmp .= "\t\@for base in $files; do \\\n";
  1587.     $tmp .= "\t  echo \$(INSTALL_DATA) \$\$base \$(DESTDIR)\$(kde_htmldir)/$kdelang/$appname/\$\$base ;\\\n";
  1588.     $tmp .= "\t  \$(INSTALL_DATA) \$(srcdir)/\$\$base \$(DESTDIR)\$(kde_htmldir)/$kdelang/$appname/\$\$base ;\\\n";
  1589.     $tmp .= "\tdone\n";
  1590.     if ($appname eq 'common') {
  1591.       $tmp .= "\t\@echo \"merging common and language specific dir\" ;\\\n";
  1592.       $tmp .= "\tif test ! -e \$(kde_htmldir)/en/common/kde-common.css; then echo 'no english docs found in \$(kde_htmldir)/en/common/'; exit 1; fi \n";
  1593.       $tmp .= "\t\@com_files=`cd \$(kde_htmldir)/en/common && echo *` ;\\\n";
  1594.       $tmp .= "\tcd \$(DESTDIR)\$(kde_htmldir)/$kdelang/common ;\\\n";
  1595.       $tmp .= "\tif test -n \"\$\$com_files\"; then for p in \$\$com_files ; do \\\n";
  1596.       $tmp .= "\t  case \" $files \" in \\\n";
  1597.       $tmp .= "\t    *\" \$\$p \"*) ;; \\\n";
  1598.       $tmp .= "\t    *) test ! -e \$\$p && echo \$(LN_S) ../../en/common/\$\$p \$(DESTDIR)\$(kde_htmldir)/$kdelang/common/\$\$p && \$(LN_S) ../../en/common/\$\$p \$\$p ;; \\\n";
  1599.       $tmp .= "\t  esac ; \\\n";
  1600.       $tmp .= "\tdone ; fi ; true\n";
  1601.     }
  1602.     $tmp .= "\n";
  1603.     $tmp .= "uninstall-nls:\n";
  1604.     $tmp .= "\tfor base in $files; do \\\n";
  1605.     $tmp .= "\t  rm -f \$(DESTDIR)\$(kde_htmldir)/$kdelang/$appname/\$\$base ;\\\n";
  1606.     $tmp .= "\tdone\n\n";
  1607.     appendLines ($tmp);
  1608.  
  1609.     $target_adds{"distdir"} .= "distdir-nls ";
  1610.  
  1611.     $tmp = "distdir-nls:\n";
  1612.     $tmp .= "\tfor file in $files; do \\\n";
  1613.     $tmp .= "\t  cp \$(srcdir)/\$\$file \$(distdir); \\\n";
  1614.     $tmp .= "\tdone\n";
  1615.  
  1616.     appendLines ($tmp);
  1617.  
  1618.     return 0;
  1619.  
  1620.   nodocs:
  1621.     appendLines("docs-am:\n");
  1622.     return 1;
  1623. }
  1624.  
  1625. #-----------------------------------------------------------------------------
  1626. # Find headers in any of the source directories specified previously, that
  1627. # are candidates for "moc-ing".
  1628. sub findMocCandidates ()
  1629. {
  1630.     my @list = ();
  1631.     foreach $dir (@headerdirs)
  1632.     {
  1633.         chdir ($dir);
  1634.         @list = `grep -l '^.*Q_OBJECT' $hExt 2> /dev/null`;
  1635.         chdir ($makefileDir);
  1636.  
  1637.         # The assoc array of root of headerfile and header filename
  1638.         foreach $hFile (@list)
  1639.         {
  1640.             chomp ($hFile);
  1641.             $hFile =~ /(.*)\.[^\.]*$/;          # Find name minus extension
  1642.             if ($mocFiles{$1})
  1643.             {
  1644.                 print STDERR "Warning: Multiple header files found for $1\n";
  1645.                 next;                           # Use the first one
  1646.             }
  1647.             $mocFiles{$1} = "$dir\035$hFile";   # Add relative dir
  1648.         }
  1649.     }
  1650.  
  1651.     return 0;
  1652. }
  1653.  
  1654. #-----------------------------------------------------------------------------
  1655.  
  1656. # The programmer has specified a moc list. Prune out the moc candidates
  1657. # list that we found based on looking at the header files. This generates
  1658. # a warning if the programmer gets the list wrong, but this doesn't have
  1659. # to be fatal here.
  1660. sub pruneMocCandidates ($)
  1661. {
  1662.     my %prunedMoc = ();
  1663.     local @mocList = split(' ', $_[0]);
  1664.  
  1665.     foreach $mocname (@mocList)
  1666.     {
  1667.         $mocname =~ s/\.moc$//;
  1668.         if ($mocFiles{$mocname})
  1669.         {
  1670.             $prunedMoc{$mocname} = $mocFiles{$mocname};
  1671.         }
  1672.         else
  1673.         {
  1674.             my $print = $makefileDir;
  1675.             $print =~ s/^\Q$topdir\E\\//;
  1676.             # They specified a moc file but we can't find a header that
  1677.             # will generate this moc file. That's possible fatal!
  1678.             print STDERR "Warning: No moc-able header file for $print/$mocname\n";
  1679.         }
  1680.     }
  1681.  
  1682.     undef %mocFiles;
  1683.     %mocFiles = %prunedMoc;
  1684. }
  1685.  
  1686. #-----------------------------------------------------------------------------
  1687.  
  1688. # Finds the cpp files (If they exist).
  1689. # The cpp files get appended to the header file separated by \035
  1690. sub checkMocCandidates ()
  1691. {
  1692.     my @cppFiles = ();
  1693.  
  1694.     foreach $mocFile (keys (%mocFiles))
  1695.     {
  1696.         # Find corresponding c++ files that includes the moc file
  1697.         @cppFiles = `echo \`ls -1d $cppExt 2> /dev/null | egrep -v "\.moc\.$cxxsuffix\$" | egrep -v "all_$cxxsuffix\.$cxxsuffix\$"\``;
  1698.  
  1699.         if (@cppFiles)  {
  1700.             my $files = join(" ", @cppFiles);
  1701.             @cppFiles =
  1702.               `egrep -l "^[     ]*#include[     ]*.$mocFile\.moc." $files 2>/dev/null`;
  1703.         }
  1704.  
  1705.         if (@cppFiles == 1)
  1706.         {
  1707.             chomp $cppFiles[0];
  1708.             $mocFiles{$mocFile} .= "\035" . $cppFiles[0];
  1709.         push(@deped, $mocFile);
  1710.             next;
  1711.         }
  1712.  
  1713.         if (@cppFiles == 0)
  1714.         {
  1715.             push (@newObs, $mocFile);           # Produce new object file
  1716.             next    if ($haveAutomocTag);       # This is expected...
  1717.             # But this is an error we can deal with - let them know
  1718.             print STDERR
  1719.                 "Warning: No c++ file that includes $mocFile.moc\n";
  1720.             next;
  1721.         }
  1722.         else
  1723.         {
  1724.             # We can't decide which file to use, so it's fatal. Although as a
  1725.             # guess we could use the mocFile.cpp file if it's in the list???
  1726.             print STDERR
  1727.                 "Error: Multiple c++ files that include $mocFile.moc\n";
  1728.             print STDERR "\t",join ("\t", @cppFiles),"\n";
  1729.             $errorflag = 1;
  1730.             delete $mocFiles{$mocFile};
  1731.             # Let's continue and see what happens - They have been told!
  1732.         }
  1733.     }
  1734. }
  1735.  
  1736. #-----------------------------------------------------------------------------
  1737.  
  1738. # Add the rules for generating moc source from header files
  1739. # For Automoc output *.moc.cpp but normally we'll output *.moc
  1740. # (We must compile *.moc.cpp separately. *.moc files are included
  1741. # in the appropriate *.cpp file by the programmer)
  1742. sub addMocRules ()
  1743. {
  1744.     my $cppFile;
  1745.     my $hFile;
  1746.  
  1747.     foreach $mocFile (keys (%mocFiles))
  1748.     {
  1749.         undef $cppFile;
  1750.         ($dir, $hFile, $cppFile) =  split ("\035", $mocFiles{$mocFile}, 3);
  1751.         $dir =~ s#^\.#\$(srcdir)#;
  1752.         if (defined ($cppFile))
  1753.         {
  1754.             $target_adds{"\$(srcdir)/$cppFile"} .= "$mocFile.moc ";
  1755.             appendLines ("$mocFile.moc: $dir/$hFile\n\t\$(MOC) $dir/$hFile -o $mocFile.moc\n");
  1756.             $cleanMoc .= " $mocFile.moc";
  1757.         }
  1758.         else
  1759.         {
  1760.             appendLines ("$mocFile$mocExt: $dir/$hFile\n\t\$(MOC) $dir/$hFile -o $mocFile$mocExt\n");
  1761.             $cleanMoc .= " $mocFile$mocExt";
  1762.         }
  1763.     }
  1764. }
  1765.  
  1766. sub make_meta_classes ()
  1767. {
  1768.     return if ($kdeopts{"qtonly"});
  1769.  
  1770.     my $cppFile;
  1771.     my $hFile;
  1772.     my $moc_class_headers = "";
  1773.     my @cppFiles =
  1774.     `grep -l "setMocClasses[     ]*(.*)[     ]*;" $cppExt 2> /dev/null`;
  1775.     chomp(@cppFiles);
  1776.     print STDOUT "C++ files with setMocClasses() = [".join(' ', @cppFiles)."]\n"
  1777.         if $verbose;
  1778.     foreach $program (@programs) {
  1779.     my $mocs = "";
  1780.     my @progsources = split(/[\s\034]+/, $sources{$program});
  1781.     my @depmocs = split(' ', $depedmocs{$program});
  1782.     my %shash = (), %mhash = ();
  1783.     @shash{@progsources} = 1;  # we are only interested in the existence
  1784.     @mhash{@depmocs} = 1;
  1785.  
  1786.     print STDOUT "program=$program\n" if ($verbose);
  1787.     print STDOUT "psources=[".join(' ', keys %shash)."]\n" if ($verbose);
  1788.     print STDOUT "depmocs=[".join(' ', keys %mhash)."]\n" if ($verbose);
  1789.     print STDOUT "globalmocs=[".join(' ', keys(%globalmocs))."]\n" if ($verbose);
  1790.     foreach my $mocFile (keys (%globalmocs))
  1791.     {
  1792.         undef $cppFile;
  1793.         ($dir, $hFile, $cppFile) = split ("\035", $globalmocs{$mocFile}, 3);
  1794.         $dir =~ s#^\.#\$(srcdir)#;
  1795.         if (defined ($cppFile))
  1796.         {
  1797.         #print STDOUT "cpp=$cppFile\n";
  1798.         $mocs .= " $mocFile.moc" if exists $shash{$cppFile};
  1799.         }
  1800.         else
  1801.         {
  1802.         # Bah. This is the case, if no C++ file includes the .moc
  1803.         # file. We make a .moc.cpp file for that. Unfortunately this
  1804.         # is not included in the %sources hash, but rather is mentioned
  1805.         # in %depedmocs. If the user wants to use AUTO he can't just
  1806.         # use an unspecific METAINCLUDES. Instead he must use
  1807.         # program_METAINCLUDES. Anyway, it's not working real nicely.
  1808.         # E.g. Its not clear what happens if user specifies two
  1809.         # METAINCLUDES=AUTO in the same Makefile.am.
  1810.         $mocs .= " $mocFile.moc.$cxxsuffix"
  1811.             if exists $mhash{$mocFile.".moc.$cxxsuffix"};
  1812.         }
  1813.     }
  1814.       $mocs .= $ui_mocs;
  1815.     if ($mocs) {
  1816.         print STDOUT "==> mocs=[".$mocs."]\n" if ($verbose);
  1817.         my $sourcename = $program."_meta_unload";
  1818.         my $ext = ($program =~ /_la$/) ? ".lo" : ".o";
  1819.         my $srcfile = $sourcename.".$cxxsuffix";
  1820.         my $objfile = $sourcename.$ext;
  1821.         $moc_class_headers .= " $srcfile";
  1822.         my $appl;
  1823.         $appl  = "$srcfile: $mocs\n";
  1824.         $appl .= "\t\@echo 'creating $srcfile'\n";
  1825.         $appl .= "\t-rm -f $srcfile\n";
  1826.         $appl .= "\t\@echo 'static const char * _metalist_$program\[\] = {' > $srcfile\n";
  1827.         $appl .= "\tcat $mocs | grep 'char.*className' | ";
  1828.         $appl .=  "sed -e 's/.*[^A-Za-z0-9_:]\\([A-Za-z0-9_:]*\\)::className.*\$\$/\\\"\\1\\\",/' | sort | uniq >> $srcfile\n";
  1829.         $appl .= "\t\@echo '0};' >> $srcfile\n";
  1830.         $appl .= "\t\@echo '#include <kunload.h>' >> $srcfile\n";
  1831.         $appl .= "\t\@echo '_UNLOAD($program)' >> $srcfile\n";
  1832.         $appl .= "\n";
  1833.         
  1834.         $realObjs{$program} .= " \034" . $objfile . " ";
  1835.         $sources{$program} .= " $srcfile";
  1836.             $sources_changed{$program} = 1;
  1837.             $dep_files .= " \$(DEPDIR)/$sourcename.P";
  1838.  
  1839.         # now also add a dependency for the C++ file which includes a
  1840.         # setMocClasses() call, and is part of this program (if any)
  1841.         #foreach $cppFile (@cppFiles) {
  1842.         #print STDOUT "testing $cppFile\n" if $verbose;
  1843.             #if (exists $shash{$cppFile}) {
  1844.         #    $appl .= "\$(srcdir)/$cppFile: $header\n";
  1845.         #}
  1846.         #}
  1847.         appendLines ($appl);
  1848.     }
  1849.     print STDOUT "\n" if $verbose;
  1850.     }
  1851.     if ($moc_class_headers) {
  1852.         appendLines ("$cleantarget-moc-classes:\n\t-rm -f $moc_class_headers\n");
  1853.         $target_adds{"$cleantarget-am"} .= "$cleantarget-moc-classes ";
  1854.     }
  1855. }
  1856.  
  1857. #-----------------------------------------------------------------------------
  1858.  
  1859. sub updateMakefile ()
  1860. {
  1861.     return if ($dryrun);
  1862.  
  1863.     open (FILEOUT, "> $makefile")
  1864.                         || die "Could not create $makefile: $!\n";
  1865.  
  1866.     print FILEOUT "\# $progId - " . '$Revision: 1.3 $ '  . "\n";
  1867.     $MakefileData =~ s/\034/\\\n/g;    # Restore continuation lines
  1868.     print FILEOUT $MakefileData;
  1869.     close FILEOUT;
  1870. }
  1871.  
  1872. #-----------------------------------------------------------------------------
  1873.  
  1874. # The given line needs to be removed from the makefile
  1875. # Do this by adding the special "removed line" comment at the line start.
  1876. sub removeLine ($$)
  1877. {
  1878.     my ($lookup, $old) = @_;
  1879.  
  1880.     $old =~ s/\034/\\\n#>- /g;          # Fix continuation lines
  1881.     $MakefileData =~ s/\n$lookup/\n#>\- $old/;
  1882. }
  1883.  
  1884. #-----------------------------------------------------------------------------
  1885.  
  1886. # Replaces the old line with the new line
  1887. # old line(s) are retained but tagged as removed. The new line(s) have the
  1888. # "added" tag placed before it.
  1889. sub substituteLine ($$)
  1890. {
  1891.     my ($lookup, $new) = @_;
  1892.  
  1893.     if ($MakefileData =~ /\n($lookup)/) {
  1894.       $old = $1;
  1895.       $old =~ s/\034/\\\n#>\- /g;         # Fix continuation lines
  1896.       $new =~ s/\034/\\\n/g;
  1897.       my $newCount = 1;
  1898.       $newCount++  while ($new =~ /\n/g);
  1899.  
  1900.       $MakefileData =~ s/\n$lookup/\n#>- $old\n#>\+ $newCount\n$new/;
  1901.     } else {
  1902.       print STDERR "Warning: substitution of \"$lookup\" in $printname failed\n";
  1903.     }
  1904. }
  1905.  
  1906. #-----------------------------------------------------------------------------
  1907.  
  1908. # Slap new lines on the back of the file.
  1909. sub appendLines ($)
  1910. {
  1911.     my ($new) = @_;
  1912.  
  1913.     $new =~ s/\034/\\\n/g;        # Fix continuation lines
  1914.     my $newCount = 1;
  1915.     $newCount++  while ($new =~ /\n/g);
  1916.  
  1917.     $MakefileData .= "\n#>\+ $newCount\n$new";
  1918. }
  1919.  
  1920. #-----------------------------------------------------------------------------
  1921.  
  1922. # Restore the Makefile.in to the state it was before we fiddled with it
  1923. sub restoreMakefile ()
  1924. {
  1925.     $MakefileData =~ s/# $progId[^\n\034]*[\n\034]*//g;
  1926.     # Restore removed lines
  1927.     $MakefileData =~ s/([\n\034])#>\- /$1/g;
  1928.     # Remove added lines
  1929.     while ($MakefileData =~ /[\n\034]#>\+ ([^\n\034]*)/)
  1930.     {
  1931.         my $newCount = $1;
  1932.         my $removeLines = "";
  1933.         while ($newCount--) {
  1934.             $removeLines .= "[^\n\034]*([\n\034]|)";
  1935.         }
  1936.         $MakefileData =~ s/[\n\034]#>\+.*[\n\034]$removeLines/\n/;
  1937.     }
  1938. }
  1939.  
  1940. #-----------------------------------------------------------------------------
  1941.