/extra - Diff - SoundSoftware Code Site

Revision 443:350acce374a2 extra

     package Apache::Authn::SoundSoftware;
     =head1 Apache::Authn::SoundSoftware
     SoundSoftware - a mod_perl module for Apache authentication against a
     Redmine database and optional LDAP implementing the access control
     rules required for the SoundSoftware.ac.uk repository site.
     =head1 SYNOPSIS
     This module is closely based on the Redmine.pm authentication module
     provided with Redmine.  It is intended to be used for authentication
     in front of a repository service such as hgwebdir.
     Requirements:
 . Clone/pull from repo for public project: Any user, no
     authentication required
 . Clone/pull from repo for private project: Project members only
 . Push to repo for public project: "Permitted" users only (this
     probably means project members who are also identified in the hgrc web
     section for the repository and so will be approved by hgwebdir?)
 . Push to repo for private project: "Permitted" users only (as above)
 . Push to any repo that is tracking an external repo: Refused always
     =head1 INSTALLATION
     Debian/ubuntu:
       apt-get install libapache-dbi-perl libapache2-mod-perl2 \
         libdbd-mysql-perl libauthen-simple-ldap-perl libio-socket-ssl-perl
     Note that LDAP support is hardcoded "on" in this script (it is
     optional in the original Redmine.pm).
     =head1 CONFIGURATION
        ## This module has to be in your perl path
        ## eg:  /usr/local/lib/site_perl/Apache/Authn/SoundSoftware.pm
        PerlLoadModule Apache::Authn::SoundSoftware
        # Example when using hgwebdir
        ScriptAlias / "/var/hg/hgwebdir.cgi/"
        <Location />
            AuthName "Mercurial"
            AuthType Basic
            Require valid-user
            PerlAccessHandler Apache::Authn::SoundSoftware::access_handler
            PerlAuthenHandler Apache::Authn::SoundSoftware::authen_handler
            SoundSoftwareDSN "DBI:mysql:database=redmine;host=localhost"
            SoundSoftwareDbUser "redmine"
            SoundSoftwareDbPass "password"
            Options +ExecCGI
            AddHandler cgi-script .cgi
            ## Optional where clause (fulltext search would be slow and
            ## database dependant).
            # SoundSoftwareDbWhereClause "and members.role_id IN (1,2)"
            ## Optional prefix for local repository URLs
            # SoundSoftwareRepoPrefix "/var/hg/"
       </Location>
     See the original Redmine.pm for further configuration notes.
     =cut
     use strict;
     use warnings FATAL => 'all', NONFATAL => 'redefine';
     use DBI;
     use Digest::SHA1;
     use Authen::Simple::LDAP;
     use Apache2::Module;
     use Apache2::Access;
     use Apache2::ServerRec qw();
     use Apache2::RequestRec qw();
     use Apache2::RequestUtil qw();
     use Apache2::Const qw(:common :override :cmd_how);
     use APR::Pool ();
     use APR::Table ();
     my @directives = (
+      {
         name => 'SoundSoftwareDSN',
         req_override => OR_AUTHCFG,
         args_how => TAKE1,
         errmsg => 'Dsn in format used by Perl DBI. eg: "DBI:Pg:dbname=databasename;host=my.db.server"',
       },
+      {
         name => 'SoundSoftwareDbUser',
         req_override => OR_AUTHCFG,
         args_how => TAKE1,
       },
+      {
         name => 'SoundSoftwareDbPass',
         req_override => OR_AUTHCFG,
         args_how => TAKE1,
       },
+      {
         name => 'SoundSoftwareDbWhereClause',
         req_override => OR_AUTHCFG,
         args_how => TAKE1,
       },
+      {
         name => 'SoundSoftwareRepoPrefix',
         req_override => OR_AUTHCFG,
         args_how => TAKE1,
       },
     );
     sub SoundSoftwareDSN {
         my ($self, $parms, $arg) = @_;
         $self->{SoundSoftwareDSN} = $arg;
         my $query = "SELECT
                      hashed_password, salt, auth_source_id, permissions
                   FROM members, projects, users, roles, member_roles
                   WHERE
                     projects.id=members.project_id
                     AND member_roles.member_id=members.id
                     AND users.id=members.user_id
                     AND roles.id=member_roles.role_id
                     AND users.status=1
                     AND login=?
                     AND identifier=? ";
         $self->{SoundSoftwareQuery} = trim($query);
+    }
     sub SoundSoftwareDbUser { set_val('SoundSoftwareDbUser', @_); }
     sub SoundSoftwareDbPass { set_val('SoundSoftwareDbPass', @_); }
     sub SoundSoftwareDbWhereClause {
         my ($self, $parms, $arg) = @_;
         $self->{SoundSoftwareQuery} = trim($self->{SoundSoftwareQuery}.($arg ? $arg : "")." ");
+    }
     sub SoundSoftwareRepoPrefix {
         my ($self, $parms, $arg) = @_;
         if ($arg) {
     	$self->{SoundSoftwareRepoPrefix} = $arg;
+        }
+    }
     sub trim {
         my $string = shift;
         $string =~ s/\s{2,}/ /g;
         return $string;
+    }
     sub set_val {
         my ($key, $self, $parms, $arg) = @_;
         $self->{$key} = $arg;
+    }
     Apache2::Module::add(__PACKAGE__, \@directives);
     my %read_only_methods = map { $_ => 1 } qw/GET PROPFIND REPORT OPTIONS/;
     sub access_handler {
         my $r = shift;
         print STDERR "SoundSoftware.pm: In access handler at " . scalar localtime() . "\n";
         unless ($r->some_auth_required) {
     	$r->log_reason("No authentication has been configured");
     	return FORBIDDEN;
+        }
         my $method = $r->method;
         print STDERR "SoundSoftware.pm: Method: $method, uri " . $r->uri . ", location " . $r->location . "\n";
         print STDERR "SoundSoftware.pm: Accept: " . $r->headers_in->{Accept} . "\n";
         my $dbh = connect_database($r);
         unless ($dbh) {
     	print STDERR "SoundSoftware.pm: Database connection failed!: " . $DBI::errstr . "\n";
     	return FORBIDDEN;
+        }
         print STDERR "Connected to db, dbh is " . $dbh . "\n";
         my $project_id = get_project_identifier($dbh, $r);
         if (!defined $read_only_methods{$method}) {
             print STDERR "SoundSoftware.pm: Method is not read-only\n";
             if (project_repo_is_readonly($dbh, $project_id, $r)) {
                 print STDERR "SoundSoftware.pm: Project repo is read-only, refusing access\n";
     	    return FORBIDDEN;
             } else {
     	    print STDERR "SoundSoftware.pm: Project repo is read-write, authentication handler required\n";
                 return OK;
+            }
+        }
         my $status = get_project_status($dbh, $project_id, $r);
         $dbh->disconnect();
         undef $dbh;
         if ($status == 0) { # nonexistent
     	print STDERR "SoundSoftware.pm: Project does not exist, refusing access\n";
     	return FORBIDDEN;
         } elsif ($status == 1) { # public
     	print STDERR "SoundSoftware.pm: Project is public, no restriction here\n";
     	$r->set_handlers(PerlAuthenHandler => [\&OK])
         } else { # private
     	print STDERR "SoundSoftware.pm: Project is private, authentication handler required\n";
+        }
         return OK
+    }
     sub authen_handler {
         my $r = shift;
         print STDERR "SoundSoftware.pm: In authentication handler at " . scalar localtime() . "\n";
         my $dbh = connect_database($r);
         unless ($dbh) {
             print STDERR "SoundSoftware.pm: Database connection failed!: " . $DBI::errstr . "\n";
             return AUTH_REQUIRED;
+        }
         my $project_id = get_project_identifier($dbh, $r);
         my $realm = get_realm($dbh, $project_id, $r);
         $r->auth_name($realm);
         my ($res, $redmine_pass) =  $r->get_basic_auth_pw();
         unless ($res == OK) {
     	$dbh->disconnect();
     	undef $dbh;
     	return $res;
+        }
         print STDERR "SoundSoftware.pm: User is " . $r->user . ", got password\n";
         my $permitted = is_permitted($dbh, $project_id, $r->user, $redmine_pass, $r);
         $dbh->disconnect();
         undef $dbh;
         if ($permitted) {
     	return OK;
         } else {
     	print STDERR "SoundSoftware.pm: Not permitted\n";
     	$r->note_auth_failure();
     	return AUTH_REQUIRED;
+        }
+    }
     sub get_project_status {
         my $dbh = shift;
         my $project_id = shift;
         my $r = shift;
         if (!defined $project_id or $project_id eq '') {
     	return 0; # nonexistent
+        }
         my $sth = $dbh->prepare(
             "SELECT is_public FROM projects WHERE projects.identifier = ?;"
         );
         $sth->execute($project_id);
         my $ret = 0; # nonexistent
         if (my @row = $sth->fetchrow_array) {
         	if ($row[0] eq "1" || $row[0] eq "t") {
     	    $ret = 1; # public
         	} else {
     	    $ret = 2; # private
+    	}
+        }
         $sth->finish();
         undef $sth;
         $ret;
+    }
     sub project_repo_is_readonly {
         my $dbh = shift;
         my $project_id = shift;
         my $r = shift;
         if (!defined $project_id or $project_id eq '') {
             return 0; # nonexistent
+        }
         my $sth = $dbh->prepare(
             "SELECT repositories.is_external FROM repositories, projects WHERE projects.identifier = ? AND repositories.project_id = projects.id;"
         );
         $sth->execute($project_id);
         my $ret = 0; # nonexistent
         if (my @row = $sth->fetchrow_array) {
             if (defined($row[0]) && ($row[0] eq "1" || $row[0] eq "t")) {
                 $ret = 1; # read-only (i.e. external)
             } else {
                 $ret = 0; # read-write
+            }
+        }
         $sth->finish();
         undef $sth;
         $ret;
+    }
     sub is_permitted {
         my $dbh = shift;
         my $project_id = shift;
         my $redmine_user = shift;
         my $redmine_pass = shift;
         my $r = shift;
         my $pass_digest = Digest::SHA1::sha1_hex($redmine_pass);
         my $cfg = Apache2::Module::get_config
     	(__PACKAGE__, $r->server, $r->per_dir_config);
         my $query = $cfg->{SoundSoftwareQuery};
         my $sth = $dbh->prepare($query);
         $sth->execute($redmine_user, $project_id);
         my $ret;
         while (my ($hashed_password, $salt, $auth_source_id, $permissions) = $sth->fetchrow_array) {
     	# Test permissions for this user before we verify credentials
     	# -- if the user is not permitted this action anyway, there's
     	# not much point in e.g. contacting the LDAP
     	my $method = $r->method;
     	if ((defined $read_only_methods{$method} && $permissions =~ /:browse_repository/)
     	    || $permissions =~ /:commit_access/) {
     	    # User would be permitted this action, if their
     	    # credentials checked out -- test those now
     	    print STDERR "SoundSoftware.pm: User $redmine_user has required role, checking credentials\n";
     	    unless ($auth_source_id) {
                     my $salted_password = Digest::SHA1::sha1_hex($salt.$pass_digest);
     		if ($hashed_password eq $salted_password) {
     		    print STDERR "SoundSoftware.pm: User $redmine_user authenticated via password\n";
     		    $ret = 1;
     		    last;
+    		}
     	    } else {
     		my $sthldap = $dbh->prepare(
     		    "SELECT host,port,tls,account,account_password,base_dn,attr_login FROM auth_sources WHERE id = ?;"
     		    );
     		$sthldap->execute($auth_source_id);
     		while (my @rowldap = $sthldap->fetchrow_array) {
     		    my $ldap = Authen::Simple::LDAP->new(
     			host    => ($rowldap[2] eq "1" || $rowldap[2] eq "t") ? "ldaps://$rowldap[0]" : $rowldap[0],
     			port    => $rowldap[1],
     			basedn  => $rowldap[5],
     			binddn  => $rowldap[3] ? $rowldap[3] : "",
     			bindpw  => $rowldap[4] ? $rowldap[4] : "",
     			filter  => "(".$rowldap[6]."=%s)"
     			);
     		    if ($ldap->authenticate($redmine_user, $redmine_pass)) {
     			print STDERR "SoundSoftware.pm: User $redmine_user authenticated via LDAP\n";
     			$ret = 1;
+    		    }
+    		}
     		$sthldap->finish();
     		undef $sthldap;
+    	    }
     	} else {
     	    print STDERR "SoundSoftware.pm: User $redmine_user lacks required role for this project\n";
+    	}
+        }
         $sth->finish();
         undef $sth;
         $ret;
+    }
     sub get_project_identifier {
         my $dbh = shift;
         my $r = shift;
         my $location = $r->location;
         my ($repo) = $r->uri =~ m{$location/*([^/]+)};
         return $repo if (!$repo);
         $repo =~ s/[^a-zA-Z0-9\._-]//g;
         # The original Redmine.pm returns the string just calculated as
         # the project identifier.  That won't do for us -- we may have
         # (and in fact already do have, in our test instance) projects
         # whose repository names differ from the project identifiers.
         # This is a rather fundamental change because it means that almost
         # every request needs more than one database query -- which
         # prompts us to start passing around $dbh instead of connecting
         # locally within each function as is done in Redmine.pm.
         my $sth = $dbh->prepare(
             "SELECT projects.identifier FROM projects, repositories WHERE repositories.project_id = projects.id AND repositories.url LIKE ?;"
         );
         my $cfg = Apache2::Module::get_config
     	(__PACKAGE__, $r->server, $r->per_dir_config);
         my $prefix = $cfg->{SoundSoftwareRepoPrefix};
         if (!defined $prefix) { $prefix = '%/'; }
         my $identifier = '';
         $sth->execute($prefix . $repo);
         my $ret = 0;
         if (my @row = $sth->fetchrow_array) {
     	$identifier = $row[0];
+        }
         $sth->finish();
         undef $sth;
         print STDERR "SoundSoftware.pm: Repository '$repo' belongs to project '$identifier'\n";
         $identifier;
+    }
     sub get_realm {
         my $dbh = shift;
         my $project_id = shift;
         my $r = shift;
         my $sth = $dbh->prepare(
             "SELECT projects.name FROM projects WHERE projects.identifier = ?;"
         );
         my $name = $project_id;
         $sth->execute($project_id);
         my $ret = 0;
         if (my @row = $sth->fetchrow_array) {
     	$name = $row[0];
+        }
         $sth->finish();
         undef $sth;
         # be timid about characters not permitted in auth realm and revert
         # to project identifier if any are found
         if ($name =~ m/[^\w\d\s\._-]/) {
     	$name = $project_id;
+        }
         my $realm = '"Mercurial repository for ' . "'$name'" . '"';
         $realm;
+    }
     sub connect_database {
         my $r = shift;
         my $cfg = Apache2::Module::get_config
     	(__PACKAGE__, $r->server, $r->per_dir_config);
         return DBI->connect($cfg->{SoundSoftwareDSN},
     	                $cfg->{SoundSoftwareDbUser},
     		        $cfg->{SoundSoftwareDbPass});
+    }
 ;

 . Push to repo for private project: "Permitted" users only (as above)
 . Push to any repo that is tracking an external repo: Refused always
     =head1 INSTALLATION
     Debian/ubuntu:
-...
         print STDERR "SoundSoftware.pm: Method: $method, uri " . $r->uri . ", location " . $r->location . "\n";
         print STDERR "SoundSoftware.pm: Accept: " . $r->headers_in->{Accept} . "\n";
         if (!defined $read_only_methods{$method}) {
     	print STDERR "SoundSoftware.pm: Method is not read-only, authentication handler required\n";
     	return OK;
+        }
         my $dbh = connect_database($r);
         unless ($dbh) {
     	print STDERR "SoundSoftware.pm: Database connection failed!: " . $DBI::errstr . "\n";
     	return FORBIDDEN;
+        }
     print STDERR "Connected to db, dbh is " . $dbh . "\n";
         print STDERR "Connected to db, dbh is " . $dbh . "\n";
         my $project_id = get_project_identifier($dbh, $r);
         if (!defined $read_only_methods{$method}) {
             print STDERR "SoundSoftware.pm: Method is not read-only\n";
             if (project_repo_is_readonly($dbh, $project_id, $r)) {
                 print STDERR "SoundSoftware.pm: Project repo is read-only, refusing access\n";
     	    return FORBIDDEN;
             } else {
     	    print STDERR "SoundSoftware.pm: Project repo is read-write, authentication handler required\n";
                 return OK;
+            }
+        }
         my $status = get_project_status($dbh, $project_id, $r);
         $dbh->disconnect();
-...
         $ret;
+    }
     sub project_repo_is_readonly {
         my $dbh = shift;
         my $project_id = shift;
         my $r = shift;
         if (!defined $project_id or $project_id eq '') {
             return 0; # nonexistent
+        }
         my $sth = $dbh->prepare(
             "SELECT repositories.is_external FROM repositories, projects WHERE projects.identifier = ? AND repositories.project_id = projects.id;"
         );
         $sth->execute($project_id);
         my $ret = 0; # nonexistent
         if (my @row = $sth->fetchrow_array) {
             if (defined($row[0]) && ($row[0] eq "1" || $row[0] eq "t")) {
                 $ret = 1; # read-only (i.e. external)
             } else {
                 $ret = 0; # read-write
+            }
+        }
         $sth->finish();
         undef $sth;
         $ret;
+    }
     sub is_permitted {
         my $dbh = shift;
         my $project_id = shift;

     #!/usr/bin/env ruby
     # == Synopsis
+    #
     # convert-external-repos: Update local Mercurial mirrors of external repos,
     # by running an external command for each project requiring an update.
+    #
     # == Usage
+    #
     #    convert-external-repos [OPTIONS...] -s [DIR] -r [HOST]
+    #
     # == Arguments (mandatory)
+    #
     #   -s, --scm-dir=DIR         use DIR as base directory for repositories
     #   -r, --redmine-host=HOST   assume Redmine is hosted on HOST. Examples:
     #                             -r redmine.example.net
     #                             -r http://redmine.example.net
     #                             -r https://example.net/redmine
     #   -k, --key=KEY             use KEY as the Redmine API key
     #   -c, --command=COMMAND     use this command to update each external
     #                             repository: command is called with the name
     #                             of the project, the path to its repo, and
     #                             its external repo url as its three args
+    #
     # == Options
+    #
     #   --http-user=USER          User for HTTP Basic authentication with Redmine WS
     #   --http-pass=PASSWORD      Password for Basic authentication with Redmine WS
     #   -t, --test                only show what should be done
     #   -h, --help                show help and exit
     #   -v, --verbose             verbose
     #   -V, --version             print version and exit
     #   -q, --quiet               no log
     require 'getoptlong'
     require 'rdoc/usage'
     require 'find'
     require 'etc'
     Version = "1.0"
     opts = GetoptLong.new(
                           ['--scm-dir',      '-s', GetoptLong::REQUIRED_ARGUMENT],
                           ['--redmine-host', '-r', GetoptLong::REQUIRED_ARGUMENT],
                           ['--key',          '-k', GetoptLong::REQUIRED_ARGUMENT],
                           ['--http-user',          GetoptLong::REQUIRED_ARGUMENT],
                           ['--http-pass',          GetoptLong::REQUIRED_ARGUMENT],
                           ['--command' ,     '-c', GetoptLong::REQUIRED_ARGUMENT],
                           ['--test',         '-t', GetoptLong::NO_ARGUMENT],
                           ['--verbose',      '-v', GetoptLong::NO_ARGUMENT],
                           ['--version',      '-V', GetoptLong::NO_ARGUMENT],
                           ['--help'   ,      '-h', GetoptLong::NO_ARGUMENT],
                           ['--quiet'  ,      '-q', GetoptLong::NO_ARGUMENT]
+                          )
     $verbose      = 0
     $quiet        = false
     $redmine_host = ''
     $repos_base   = ''
     $http_user    = ''
     $http_pass    = ''
     $test         = false
     $mirrordir    = '/var/mirror'
     def log(text, options={})
       level = options[:level] || 0
       puts text unless $quiet or level > $verbose
       exit 1 if options[:exit]
     end
     def system_or_raise(command)
       raise "\"#{command}\" failed" unless system command
     end
     begin
       opts.each do |opt, arg|
         case opt
         when '--scm-dir';        $repos_base   = arg.dup
         when '--redmine-host';   $redmine_host = arg.dup
         when '--key';            $api_key      = arg.dup
         when '--http-user';      $http_user    = arg.dup
         when '--http-pass';      $http_pass    = arg.dup
         when '--command';        $command      = arg.dup
         when '--verbose';        $verbose += 1
         when '--test';           $test = true
         when '--version';        puts Version; exit
         when '--help';           RDoc::usage
         when '--quiet';          $quiet = true
         end
       end
     rescue
       exit 1
     end
     if $test
       log("running in test mode")
     end
     if ($redmine_host.empty? or $repos_base.empty? or $command.empty?)
       RDoc::usage
     end
     unless File.directory?($repos_base)
       log("directory '#{$repos_base}' doesn't exist", :exit => true)
     end
     begin
       require 'active_resource'
     rescue LoadError
       log("This script requires activeresource.\nRun 'gem install activeresource' to install it.", :exit => true)
     end
     class Project < ActiveResource::Base
       self.headers["User-agent"] = "SoundSoftware external repository converter/#{Version}"
     end
     log("querying Redmine for projects...", :level => 1);
     $redmine_host.gsub!(/^/, "http://") unless $redmine_host.match("^https?://")
     $redmine_host.gsub!(/\/$/, '')
     Project.site = "#{$redmine_host}/sys";
     Project.user = $http_user;
     Project.password = $http_pass;
     begin
       # Get all active projects that have the Repository module enabled
       projects = Project.find(:all, :params => {:key => $api_key})
     rescue => e
       log("Unable to connect to #{Project.site}: #{e}", :exit => true)
     end
     if projects.nil?
       log('no project found, perhaps you forgot to "Enable WS for repository management"', :exit => true)
     end
     log("retrieved #{projects.size} projects", :level => 1)
     projects.each do |project|
       log("treating project #{project.name}", :level => 1)
       if project.identifier.empty?
         log("\tno identifier for project #{project.name}")
         next
       elsif not project.identifier.match(/^[a-z0-9\-]+$/)
         log("\tinvalid identifier for project #{project.name} : #{project.identifier}");
         next
       end
       if !project.respond_to?(:repository) or !project.repository.is_external?
         log("\tproject #{project.identifier} does not use an external repository");
         next
       end
       external_url = project.repository.external_url;
       log("\tproject #{project.identifier} has external repository url #{external_url}");
       if !external_url.match(/^[a-z][a-z+]{0,8}[a-z]:\/\//)
         log("\tthis doesn't look like a plausible url to me, skipping")
         next
       end
       repos_path = File.join($repos_base, project.identifier).gsub(File::SEPARATOR, File::ALT_SEPARATOR || File::SEPARATOR)
       unless File.directory?(repos_path)
         log("\tproject repo directory '#{repos_path}' doesn't exist")
         next
       end
       system($command, project.identifier, repos_path, external_url)
       $cache_clearance_file = File.join($mirrordir, project.identifier, 'url_changed')
       if File.file?($cache_clearance_file)
         log("\tproject repo url has changed, requesting cache clearance")
         if project.post(:repository_cache, :key => $api_key)
           File.delete($cache_clearance_file)
         end
       end
     end

     redgrp="redmine"
     apikey=""
     apischeme="https"
     apihost=""
     apiuser=""
     apipass=""
-...
         *) progdir="$(pwd)/$progdir" ;;
     esac
     types="doxygen javadoc" # Do Doxygen first (it can be used for Java too)
     types="doxygen javadoc matlabdocs" # Do Doxygen first (it can be used for Java too)
     for x in $types; do
         if [ ! -x "$progdir/extract-$x.sh" ]; then
-...
         p="$1"
         if [ -n "$apikey" ]; then
     	if [ -n "$apiuser" ]; then
     	    sudo -u docgen curl -u "$apiuser":"$apipass" "http://$apihost/sys/projects/$p/embedded.xml?enable=1&key=$apikey" -d ""
     	    sudo -u docgen curl -u "$apiuser":"$apipass" "$apischeme://$apihost/sys/projects/$p/embedded.xml?enable=1&key=$apikey" -d ""
     	else
     	    sudo -u docgen curl "http://$apihost/sys/projects/$p/embedded.xml?enable=1&key=$apikey" -d ""
     	    sudo -u docgen curl "$apischeme://$apihost/sys/projects/$p/embedded.xml?enable=1&key=$apikey" -d ""
     	fi
         else
     	echo "Can't enable Embedded, API not configured" 1>&2

     #!/bin/bash
     docdir="/var/doc"
     progdir=$(dirname $0)
     case "$progdir" in
         /*) ;;
         *) progdir="$(pwd)/$progdir" ;;
     esac
     project="$1"
     projectdir="$2"
     targetdir="$3"
     if [ -z "$project" ] || [ -z "$targetdir" ] || [ -z "$projectdir" ]; then
         echo "Usage: $0 <project> <projectdir> <targetdir>"
         exit 2
     fi
     if [ ! -d "$projectdir" ]; then
         echo "Project directory $projectdir not found"
         exit 1
     fi
     if [ ! -d "$targetdir" ]; then
         echo "Target dir $targetdir not found"
         exit 1
     fi
     if [ -f "$targetdir/index.html" ]; then
         echo "Target dir $targetdir already contains index.html"
         exit 1
     fi
     mfile=$(find "$projectdir" -type f -name \*.m -print0 | xargs -0 grep -l '^% ' | head -1)
     if [ -z "$mfile" ]; then
         echo "No MATLAB files with comments found for project $project"
         exit 1
     fi
     echo "Project $project contains at least one MATLAB file with comments"
     cd "$projectdir" || exit 1
     perl "$progdir/matlab-docs.pl" -c "$progdir/matlab-docs.conf" -d "$targetdir"

extra/soundsoftware/matlab-docs-credit.html
	1	<div style="clear: both; float: right"><small><i>Produced by mtree2html by Hartmut Pohlheim</i></small></div>

     # configuration file for generation of html-docu from m-files
+    #
     # Author:   Hartmut Pohlheim
     # History:  05.11.2000  file created (parameters for mtree2html2001)
+    #
     # The following options/variables must be changed/adapted:
     #   dirmfiles
     #   dirhtml
     #   csslink
     #   texttitleframelayout
     #   texttitlefiles
+    #
     # The following options/variables should be adapted:
     #   authorfile
     #   filenametopframe
     #   codeheadmeta
     #========================================================================
     # Variables (possible keywords: set)
     # to use the built-in settings, comment the line using # in first column
     #========================================================================
     #------------------------------------------------------------------------
     # dirmfiles: name of directory containing Matlab m-files
     # dirhtml: name of directory to place the html-files into
     # exthtml: extension used for the html files (.html or .htm)
     #          don't forget the point in front of the extension
     #------------------------------------------------------------------------
     set dirmfiles = .
     set dirhtml = doc-output
     set exthtml = .html
     #------------------------------------------------------------------------
     # authorfile:   name of file containing info about author (in html)
     #               if defined, this text is included at the bottom of the
     #               html files
     #------------------------------------------------------------------------
     set authorfile = matlab-docs-credit.html
     #------------------------------------------------------------------------
     # csslink:   text for linking to css file (style sheets)
     #            the text defined here is directly included into the head
     #            of the html file
     #------------------------------------------------------------------------
     #set csslink = <link rel=stylesheet type="text/css" href="CSSFILENAME.css" />
     #------------------------------------------------------------------------
     # links2filescase: this is a bit difficult
     #                  Matlab is case sensitive on UNIX, but case insensitive
     #                  on Windows. Under UNIX Matlab function calls work
     #                  only, when the case of file name and function call are
     #                  identical, under Windows you can do what you want.
     #                  This scripts help you, to keep an exact case in your
     #                  project.
     #          exact - internal links are only generated, when case of file
     #                  name and in source code are identical
     #            all - case doesn't matter
     #     exactupper - same as exact, additionally links are also vreated to
     #                  all upper case function names in source code (often
     #                  used by Mathworks)
     #      exactvery - same as exact, additionally info about not matching
     #                  case is written to screen (stdout), this can be very
     #                  helpful in cleaning up the case in a project
     #------------------------------------------------------------------------
     set links2filescase = all
     #------------------------------------------------------------------------
     # texttitleframelayout:    text of title for frame layout file (whole docu)
     #------------------------------------------------------------------------
     set texttitleframelayout = MATLAB Function Documentation
     #------------------------------------------------------------------------
     # texttitle/headerindexalldirs: text of title and header for directory index
     #------------------------------------------------------------------------
     set texttitleindexalldirs = Index of Directories
     set textheaderindexalldirs = Index of Directories
     #------------------------------------------------------------------------
     # texttitle/headerindex:    text of title and header for index file
     #------------------------------------------------------------------------
     set texttitleindex = A-Z Index of Functions
     set textheaderindex = A-Z Index of Functions
     #------------------------------------------------------------------------
     # texttitle/headerfiles:    text of title and header for files
     #                           name of file will be added at the end
     #------------------------------------------------------------------------
     set texttitlefiles = Function
     set textheaderfiles = Documentation of
     #------------------------------------------------------------------------
     # frames: whether to use frames in layout (yes or no)
     #------------------------------------------------------------------------
     set frames = no
     #------------------------------------------------------------------------
     # filenametopframe: name of file including frame layout (highest level file)
     # [default: index]
     #------------------------------------------------------------------------
     set filenametopframe = index
     #------------------------------------------------------------------------
     # textjumpindexglobal: text displayed for jump to index of all files
     #                      (global)
     # textjumpindexlocal:  text displayed for jump to index of files in actual
     #                      directory (local)
     #------------------------------------------------------------------------
     set textjumpindexglobal = <b>Index of</b> all files:
     set textjumpindexlocal = this subdirectory only:
     #------------------------------------------------------------------------
     # includesource: include source of m-files in documentation [YES|no]
     #------------------------------------------------------------------------
     set includesource = yes
     #------------------------------------------------------------------------
     # usecontentsm: use contents.m files as well for structured
     #               (hopefully) index [YES|no]
     #------------------------------------------------------------------------
     set usecontentsm = no
     #------------------------------------------------------------------------
     # includesource: write/update contents.m files [yes|NO]
     #------------------------------------------------------------------------
     set writecontentsm = no
     #------------------------------------------------------------------------
     # processtree:  parse whole directory tree recursively [YES|no]
     #------------------------------------------------------------------------
     set processtree = yes
     #------------------------------------------------------------------------
     # producetree:  produce tree for html-files in same structure than
     #		          tree of m-files [yes|NO]
     #               if no, all files are saved in the same directory, often
     #               easier for outside linking to files
     #------------------------------------------------------------------------
     set producetree = yes
     #------------------------------------------------------------------------
     # codebodyindex/files: HTML-code for adding to BODY tag
     #                      can be used for defining colors and
     #                      backgroundimages of the files
     #                      No longer recommended, use the css file
     #------------------------------------------------------------------------
     set codebodyindex =
     set codebodyfiles =
     #------------------------------------------------------------------------
     # codeheadmeta: HTML-code added in HEAD area, use for supplying META info
     #------------------------------------------------------------------------
     set codeheadmeta =
     #------------------------------------------------------------------------
     # codehr: HTML-code used to define a <HR>, do what you want
     #------------------------------------------------------------------------
     set codehr = <hr>
     #------------------------------------------------------------------------
     # codeheader: HTML-code added to <H*> tags, use for centering header text
     #             or changing the colour/size/font of the header text
     #------------------------------------------------------------------------
     set codeheader =
     # End of parameter file

     @rem = '--*-Perl-*--';
     @rem = '
     @echo off
     perl -w -S %0.bat %1 %2 %3 %4 %5 %6 %7 %8 %9
     goto endofperl
     @rem ';
     # perl -w -S %0.bat "$@"
     #!/usr/bin/perl
+    #
     # mtree2html_2000 - produce html files from Matlab m-files.
     #                   use configuration file for flexibility
     #                   can process tree of directories
+    #
     # Copyright (C) 1996-2000 Hartmut Pohlheim.  All rights reserved.
     # includes small parts of m2html from Jeffrey C. Kantor 1995
+    #
     # Author:  Hartmut Pohlheim
     # History: 06.03.1996  file created
     #          07.03.1996  first working version
     #          08.03.1996  modularized, help text only once included
     #          11.03.1996  clean up, some functions rwritten
     #          18.04.1996  silent output with writing in one line only
     #                      version 0.20 fixed
     #          14.05.1996  start of adding tree structure, could create tree
     #          15.05.1996  creating of index files for every directory
     #          17.05.1996  first working version except compact A-Z index
     #          20.05.1996  cleanup of actual version, more variables and
     #                      configurable settings
     #          21.05.1996  reading, update and creation of contents.m added
     #          22.05.1996  creation of short index started
     #          28.05.1996  jump letters for short index,
     #                      3 different directory indexes (short/long/contents)
     #          29.05.1996  major cleanup, short and long index created from one function
     #                      links for HTML and Indexes from 1 function,
     #                      version 0.9
     #          30.05.1996  contents.m changed to Contents.m (because unix likes it)
     #                      function definition can be in first line of m file before comments
     #                      version 0.91 fixed
     #          03.06.1996  contents file can be written as wanted, the links will be correct
     #                      cross references in help block of m-file will be found and
     #                      converted, even if the name of the function is written upper case
     #                      version 0.92 fixed
     #          05.06.1996  construction of dependency matrix changed, is able now to process
     #                      even the whole matlab tree (previous version needed to much memory)
     #                      removed warning for contents files in different directories
     #                      version 0.94 fixed
     #          06.06.1996  new link name matrices for ConstructHTMLFile created,
     #                      everything is done in ConstructDependencyMatrix,
     #                      both dependencies (calls and called) and matrix
     #                      with all mentioned names in this m-file, thus, much
     #                      less scanning in html construction
     #                      script is now (nearly) linear scalable, thus, matlab-toolbox
     #                      tree takes less than 1 hour on a Pentium120, with source
     #                      version 0.96 fixed
     #          10.06.1996  order of creation changed, first all indexes (includes
     #                      update/creation of contents.m) and then ConstructDepency
     #                      thus, AutoAdd section will be linked as well
     #                      excludenames extended, some more common word function names added
     #                      version 0.97 fixed
     #          17.02.1998  writecontentsm as command line parameter added
     #                      error of file not found will even appear when silent
     #                      version 1.02
     #          21.05.2000  mark comments in source code specially (no fully correct,
     #                      can't handle % in strings)
     #                      version 1.11
     #          05.11.2000  link also to upper and mixed case m-files
     #                      searching for .m files now really works (doesn't find grep.com any longer)
     #                      file renamed to mtree2html2001
     #                      generated html code now all lower case
     #                      inclusion of meta-description and meta-keywords in html files
     #                      HTML4 compliance done (should be strict HTML4.0, quite near XHTML)
     #                      version 1.23
+    #
     #	   29.03.2011  (Chris Cannam) add frames option.
     $VERSION  = '1.23';
     ($PROGRAM = $0) =~ s@.*/@@; $PROGRAM = "\U$PROGRAM\E";
     $debug = 1;
     #------------------------------------------------------------------------
     # Define platform specific things
     #------------------------------------------------------------------------
     # suffix for files to search is defined twice
     # the first ($suffix) is for string creation and contains the . as well
     # the second ($suffixforsearch) is for regular expression, handling of . is quite special
     $suffix = ".m";
     $suffixforsearch = "m";
     # the directory separator
     $dirsep = "/";
     # what is the current directory
     $diract = ".";
     #------------------------------------------------------------------------
     #  Define all variables and their standard settings
     #  documentation of variables is contained in accompanying rc file
     #------------------------------------------------------------------------
     %var =
+    (
        'authorfile',                '',
        'codebodyfiles',             '',
        'codebodyindex',             '',
        'codeheadmeta',              '<meta name="author of conversion perl script" content="Hartmut Pohlheim" />',
        'codehr',                    '<hr size="3" noshade="noshade" />',
        'codeheader',                '',
        'configfile',                'matlab-docs.conf',
        'csslink',                   '',
        'dirmfiles',                 $diract,
        'dirhtml',                   $diract,
        'exthtml',                   '.html',
        'frames',                    'yes',
        'filenametopframe',          'index',
        'filenameindexlongglobal',   'indexlg',
        'filenameindexlonglocal',    'indexll',
        'filenameindexshortglobal',  'indexsg',
        'filenameindexshortlocal',   'indexsl',
        'filenameextensionframe',    'f',
        'filenameextensionindex',    'i',
        'filenameextensionjump',     'j',
        'filenamedirshort',          'dirtops',
        'filenamedirlong',           'dirtopl',
        'filenamedircontents',       'dirtopc',
        'includesource',             'yes',
        'links2filescase',           'all',
        'processtree',               'yes',
        'producetree',               'yes',
        'textjumpindexlocal',        'Local Index',
        'textjumpindexglobal',       'Global Index',
        'texttitleframelayout',      'Documentation of Matlab Files',
        'texttitleindexalldirs',     'Index of Directories',
        'textheaderindexalldirs',    'Index of Directories',
        'texttitleindex',            '',
        'textheaderindex',           '',
        'texttitlefiles',            'Documentation of ',
        'textheaderfiles',           'Documentation of ',
        'usecontentsm',              'yes',
        'writecontentsm',            'no'
     );
     # define all m-file names, that should be excluded from linking
     # however, files will still be converted
     @excludenames = ( 'all','ans','any','are',
                       'cs',
                       'demo','dos',
                       'echo','edit','else','elseif','end','exist',
                       'flag','for','function',
                       'global',
                       'help',
                       'i','if','inf','info',
                       'j',
                       'more',
                       'null',
                       'return',
                       'script','strings',
                       'what','which','while','who','whos','why',
                     );
     # Text for inclusion in created HTML/Frame files: Doctype and Charset
     $TextDocTypeHTML  = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">';
     $TextDocTypeFrame = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Frameset//EN" "http://www.w3.org/TR/REC-html40/frameset.dtd">';
     $TextMetaCharset = '<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />';
     #------------------------------------------------------------------------
     # Read the command line arguments
     #------------------------------------------------------------------------
     if (@ARGV == 0) {
        &DisplayHelp()  if &CheckFileName($var{'configfile'}, 'configuration file');
+    }
     # Print provided command line arguments on screen
     foreach (@ARGV) { print "   $_\n      "; }
     # Get the options
     use Getopt::Long;
     @options = ('help|h', 'todo|t', 'version|v',
                 'authorfile|a=s', 'configfile|c=s', 'dirhtml|html|d=s',
                 'dirmfiles|mfiles|m=s', 'includesource|i=s',
                 'processtree|r=s', 'producetree|p=s',
                 'silent|quiet|q', 'writecontentsm|w=s');
     &GetOptions(@options) || die "use -h switch to display help statement\n";
     # Display help or todo list, when requested
     &DisplayHelp()                         if $opt_help;
     &DisplayTodo()                         if $opt_todo;
     die "$PROGRAM v$VERSION\n"             if $opt_version;
     $exit_status = 0;
     #------------------------------------------------------------------------
     # Read the config file
     #------------------------------------------------------------------------
     $var{'configfile'} = $opt_configfile         if $opt_configfile;
     &GetConfigFile($var{'configfile'});
     #------------------------------------------------------------------------
     # Process/Check the command line otions
     #------------------------------------------------------------------------
     $var{'dirhtml'}   = $opt_dirhtml              if $opt_dirhtml;
     if (!(substr($var{'dirhtml'}, -1, 1) eq $dirsep)) { $var{'dirhtml'} = $var{'dirhtml'}.$dirsep; }
     $var{'dirmfiles'} = $opt_dirmfiles            if $opt_dirmfiles;
     if (!(substr($var{'dirmfiles'}, -1, 1) eq $dirsep)) { $var{'dirmfiles'} = $var{'dirmfiles'}.$dirsep; }
     $var{'authorfile'} = $opt_author              if $opt_author;
     $var{'includesource'} = $opt_includesource    if $opt_includesource;
     if ($var{'includesource'} ne 'no') { $var{'includesource'} = 'yes'; }
     $var{'processtree'} = $opt_processtree        if $opt_processtree;
     if ($var{'processtree'} ne 'no') { $var{'processtree'} = 'yes'; }
     $var{'producetree'} = $opt_producetree        if $opt_producetree;
     if ($var{'producetree'} ne 'no') { $var{'producetree'} = 'yes'; }
     if ($var{'processtree'} eq 'no') { $var{'producetree'} = 'no'; }
     if ($var{'frames'} ne 'no') { $var{'frames'} = 'yes'; }
     # if (($var{'processtree'} eq 'yes') && ($var{'producetree'} eq 'no')) { $var{'usecontentsm'} = 'no'; }
     $var{'writecontentsm'} = $opt_writecontentsm  if $opt_writecontentsm;
     #------------------------------------------------------------------------
     # Do the real stuff
     #------------------------------------------------------------------------
     # Print variables on screen, when not silent
     &ListVariables                          if !$opt_silent;
     # Check the author file
     if ($var{'authorfile'} ne '') {
         if (!($var{'authorfile'} =~ m,^/,)) {
     	# relative path: treat as relative to config file
     	my $cfd = $var{'configfile'};
     	$cfd =~ s,/[^/]*$,/,;
     	$cfd =~ s,^[^/]*$,.,;
     	$var{'authorfile'} = "$cfd/" . $var{'authorfile'};
+        }
         if (&CheckFileName($var{'authorfile'}, 'author file')) {
     	$var{'authorfile'} = '';
     	if (!$opt_silent) { print "   Proceeding without author information!\n"; }
+        }
+    }
     # Call the function doing all the real work
     &ConstructNameMatrix;
     &ConstructDependencyMatrix;
     &ConstructAllIndexFiles;
     &ConstructHTMLFiles;
     exit $exit_status;
     #------------------------------------------------------------------------
     # Construct list of all mfile names and initialize various data arrays.
     #------------------------------------------------------------------------
     sub ConstructNameMatrix
+    {
        local(*MFILE);
        local($file, $dirname);
        local(@newdirectories);
        local(%localnames);
        $RecDeep = 0;
        &ParseTreeReadFiles($var{'dirmfiles'}, $RecDeep);
        foreach $dirname (@directories) {
           if ($dirnumbermfiles{$dirname} > 0) {
              push(@newdirectories, $dirname);
              if (! defined($contentsname{$dirname})) {
                 $contentsname{$dirname} = 'Contents';
                 if (($var{'writecontentsm'} eq 'no') && ($var{'usecontentsm'} eq 'yes')) {
                    print "\r ParseTree - for directory  $dirname  no contents file found!\n";
                    print   "             create one or enable writing of contents file (writecontentsm = yes)!\n";
+                }
+             }
+          }
+       }
        @alldirectories = @directories;
        @directories = @newdirectories;
        foreach $dirname (@directories) {
           if ($debug > 0) { print "Dir: $dirname \t\t $dirnumbermfiles{$dirname} \t$contentsname{$dirname}\n"; }
+       }
        @names = sort(keys %mfile);
        # check, if name of directory is identical to name of file
        @dirsinglenames = values(%dirnamesingle);
        grep($localnames{$_}++, @dirsinglenames);
        @dirandfilename = grep($localnames{$_}, @names);
        if (@dirandfilename) {
           print "\r   Name clash between directory and file name: @dirandfilename\n";
           print   "      These files will be excluded from linking!\n";
           push(@excludenames, @dirandfilename);
+       }
        # construct names matrix for help text linking
        #    exclude some common words (and at the same time m-functions) from linking in help text
        grep($localnames{$_}++, @excludenames);
        @linknames = grep(!$localnames{$_}, @names);
        if ($debug > 2) { print "linknames (names of found m-files):\n    @linknames\n"; }
+    }
     #------------------------------------------------------------------------
     # Parse tree and collect all Files
     #------------------------------------------------------------------------
     sub ParseTreeReadFiles
+    {
        local($dirname, $localRecDeep) = @_;
        local($file, $name, $filewosuffix);
        local($dirhtmlname, $dirmode);
        local($relpath, $relpathtoindex, $replacevardir);
        local(*CHECKDIR, *AKTDIR);
        local(@ALLEFILES);
        opendir(AKTDIR, $dirname) || die "ParseTree - Can't open directory $dirname: $!";
        if ($debug > 1) { print "\nDirectory: $dirname\n"; }
        # create relative path
        $_ = $dirname; $replacevardir = $var{'dirmfiles'};
        s/$replacevardir//; $relpath = $_;
        s/[^\/]+/../g; $relpathtoindex = $_;
        # producetree no
        if ($var{'producetree'} eq 'no') { $relpath = ''; $relpathtoindex = ''; }
        # names of directories (top-level and below top-level m-file-directory)
        push(@directories, $dirname);
        $dirnumbermfiles{$dirname} = 0;    # set number of m-files for this dir to zero
        # relative path from top-level directory, depends on directory name
        $dirnamerelpath{$dirname} = $relpath;
        # relative path from actual directory to top-level directory, depends on directory name
        $dirnamerelpathtoindex{$dirname} = $relpathtoindex;
        # recursion level for directory, depends on directory name
        $dirnamerecdeep{$dirname} = $localRecDeep;
        # only the name of the directory, without path
        $rindexprint = rindex($dirname, $dirsep, length($dirname)-2);
        $rindsub = substr($dirname, $rindexprint+1, length($dirname)-$rindexprint-2);
        $dirnamesingle{$dirname} = $rindsub;
        # create name of html-directories
        $_ = $dirname;
        s/$var{'dirmfiles'}/$var{'dirhtml'}/;
        $dirhtmlname = $_;
        if ($var{'producetree'} eq 'no') { $dirhtmlname = $var{'dirhtml'}; }
        # try to open html directory, if error, then create directory,
        # use same mode as for corresponding m-file directory
        opendir(CHECKDIR,"$dirhtmlname") || do {
           $dirmode = (stat($dirname))[2]; # print "$dirmode\n";
           mkdir("$dirhtmlname", $dirmode) || die ("Cannot create directory $dirhtmlname: $! !");
        };
        closedir(CHECKDIR);
        # read everything from this directory and process them
        @ALLEFILES = readdir(AKTDIR);
        foreach $file (@ALLEFILES) {
           # exclude . and .. directories
           next if $file eq '.';  next if $file eq '..';
           # test for existense of entry (redundant, used for debugging)
           if (-e $dirname.$file) {
              # if it's a directory, call this function recursively
              if (-d $dirname.$file) {
                 if ($var{'processtree'} eq 'yes') {
                    &ParseTreeReadFiles($dirname.$file.$dirsep, $localRecDeep+1);
+                }
+             }
              # if it's a file - test for m-file, save name and create some arrays
              elsif (-f $dirname.$file) {
                 if ($file =~ /\.$suffixforsearch$/i) {
                    # Remove the file suffix to establish the matlab identifiers
                    $filewosuffix = $file;
                    $filewosuffix =~ s/\.$suffixforsearch$//i;
                    # $filename = $name;
                    # Contents file in unix must start with a capital letter (Contents.m)
                    # ensure, that m-file name is lower case, except the contents file
                    if (! ($filewosuffix =~ /^contents$/i)) {
     		   # if ($var{'links2filescase'}  eq 'low') { $filewosuffix = "\L$filewosuffix\E"; }
                       $filewosuffixlow = "\L$filewosuffix\E";
+                   }
                    else { $contentsname{$dirname} = $filewosuffix; }
                    # internal handle name is always lower case
                    $name     = $filewosuffixlow;
                    # file name is not lower case
                    $filename = $filewosuffix;
                    # if don't use C|contents.m, then forget all C|contents.m
                    if ($var{'usecontentsm'} eq 'no') { if ($name =~ /contents/i) { next; } }
                    # if m-file with this name already exists, use directory and name for name
                    # only the first occurence of name will be used for links
                    if (defined $mfile{$name}) {
                       if (! ($name =~ /^contents$/i) ) {
                          print "\r ParseTree - Name conflict:  $name in $dirname already exists: $mfile{$name} !\n";
                          print   "             $mfile{$name}  will be used for links!\n";
+                      }
                       $name = $dirname.$name;
+                   }
                    # mfile name with path
                    $mfile{$name} = $dirname.$file;
                    # mfile name (without path)
                    $mfilename{$name} = $filename;
                    # mfile directory
                    $mfiledir{$name} = $dirname;
                    # html file name and full path, special extension of Contents files
                    if ($name =~ /contents/i) { $extrahtmlfilename = $dirnamesingle{$dirname}; }
                    else { $extrahtmlfilename = ''; }
                    $hfile{$name} = $dirhtmlname.$mfilename{$name}.$extrahtmlfilename.$var{'exthtml'};
                    # save relative html path
                    # if ($var{'producetree'} eq 'yes') {
                    $hfilerelpath{$name} = $relpath;
                    # } else { # if no tree to produce, relative path is empty
                    #    $hfilerelpath{$name} = '';
                    # }
                    # create relative path from html file to directory with global index file
                    $hfileindexpath{$name} = $relpathtoindex;
                    # Function declaration, if one exists, set default to script
                    $synopsis{$name} = "";
                    $mtype{$name} = "script";
                    # First comment line
                    $apropos{$name} = "";
                    # count number of m-files in directories
                    $dirnumbermfiles{$dirname}++;
                    if ($debug > 1) {
                       if ($opt_silent) { print "\r"; }
                       print "   ParseTree: $name \t\t $mfile{$name} \t\t $hfile{$name}\t\t";
                       if (!$opt_silent) { print "\n"; }
+                   }
+                }
+             }
              else {
                 print "Unknown type of file in $dirname: $file\n";
+             }
+          }
           else { print "Error: Not existing file in $dirname: $file\n"; }
+       }
        closedir(AKTDIR)
+    }
     #------------------------------------------------------------------------
     # Construct Dependency matrix
     #    $dep{$x,$y} > 0 if $x includes a reference to $y.
     #------------------------------------------------------------------------
     sub ConstructDependencyMatrix
+    {
        &ConstructDependencyMatrixReadFiles('all');
        &ConstructDependencyMatrixReally;
+    }
     #------------------------------------------------------------------------
     # Construct Dependency matrix
     #    $dep{$x,$y} > 0 if $x includes a reference to $y.
     #------------------------------------------------------------------------
     sub ConstructDependencyMatrixReadFiles
+    {
        local($whatstring) = @_;
        local(*MFILE);
        local($name, $inames);
        local(%symbolsdep, %symbolsall);
        # Initialize as all zeros.
        # foreach $name (@names) { grep($dep{$name,$_}=0,@names); if ($debug > 0) { print "\r   DepMatrix anlegen: $name\t$#names\t"; } }
        # Compute the dependency matrix
        $inames = -1;
        foreach $name (@names) {
           # Read each file and tabulate the distinct alphanumeric identifiers in
           # an array of symbols. Also scan for:
           #   synopsis: The function declaration line
           #   apropos:  The first line of the help text
           # look for whatstring, if all: process every file, if contents: process only contents files
           if ($whatstring eq 'contents') { if (! ($name =~ /contents$/i) ) { next; } }
           elsif ($whatstring eq 'all') { }    # do nothing
           else { print "\r   ConstructDependency: Unknown parameter whatstring: $whatstring \n"; }
           undef %symbolsall; undef %symbolsdep;
           open(MFILE,"<$mfile{$name}") || die("Can't open $mfile{$name}: $!\n");
           while (<MFILE>) {
              chop;

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

SoundSoftware Project »

SoundSoftware Code Site

Revision 443:350acce374a2 extra