source: trunk/IPs/systemC/processor/Morpheo/Behavioural/configure.mkf

#!/usr/bin/perl

#    This file is part of MKF.
#
#    MKF is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    MKF is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with MKF; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#    Copyright (c) 2004 Alexandre Becoulet <alexandre.becoulet@epita.fr>

#use strict;

my $mkf_file_gc = "mkf.info";

######################################################
#               temporary files
#

my @temp_files;
my $tmp_dir = "/tmp";

sub get_temp_file
{
    my ($ext_p) = @_;

    my $fname;

    do
    {
        my $random = int(rand(10000));
        $fname = "$tmp_dir/configure_".$random."_".$ext_p;
    }
    while (-f $fname);

    push (@temp_files, $fname);

    return $fname;
}

sub clear_temp_files
{
    unlink($_) foreach (@temp_files);
}

######################################################
#               Display functions
#

sub error
{
    $_ = @_[0];
#    s/'/'\033[01;31m/g;
#    s/`/\033[01;36m`/g;
    print "[ Error ] $_\n";
#    print "[ Error ] \033[01;31m$_\033[m\n";
    clear_temp_files;
    exit -1;
}

sub warning
{
    $_ = @_[0];
#    s/'/'\033[01;93m/g;
#    s/`/\033[01;36m`/g;
    print "[Warning] $_\n";
#    print "[Warning] \033[01;93m$_\033[m\n";
}

######################################################
#               strings replace functions
#

sub replace
{
    my ($str_p, $value_p, $keyword_p) = @_;

    $str_p =~ s/{$keyword_p}/$value_p/g;

    return $str_p;
}

sub replace_vars
{
    my ($str_p, $vars_p, $keyword_p) = @_;

    $str_p =~ s/{$keyword_p,([^\}]+)}/$$vars_p{$1}/g;

    return $str_p;
}

sub replace_vars_list
{
    my ($str_p, $vars_p, $keyword_p) = @_;

    while ($str_p =~ /{$keyword_p,([^\,]*),([^\}]+)}/)
    {
        my $var = $2;
        my $pre = $1;
        my $list;

        $list = "$list $pre$_" foreach (split(/ +/, $$vars_p{$var}));
        $str_p =~ s/{$keyword_p,$pre,$var}/$list/;
    }

    return $str_p;
}

sub replace_list
{
    my ($str_p, $list, $keyword_p) = @_;

    return $str_p if (! $list);

    while ($str_p =~ /{$keyword_p(!?),([^\},]+),?([^\}]*)}/)
    {
        my $val;
        my $strip = $1;
        my $match_p = $2;
        my $prefix = $3;

        foreach (@$list)
        {
            if (/^$match_p$/)
            {
                my $item = $_;
                $item =~ s/\..*$// if ($strip);
                $val .= " ".$prefix.$item;
            }
        }

        $str_p =~ s/{$keyword_p$strip,[^\}]+}/$val/;
    }

    return $str_p;
}

sub replace_temp_file
{
    my ($str_p, $keyword_p) = @_;

    while ($str_p =~ /{$keyword_p,([^\,]+),([^\}]+)}/)
    {
        my $id = $1;
        my $ext = $2;
        my $fname = get_temp_file ($ext);

        $str_p =~ s/{$keyword_p,$id,$ext}/$fname/g;
    }

    return $str_p;
}

######################################################
#           Mkf file commands functions
#

sub cmd_end_if
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: no parameter expected for `@$params_p[0]'"
        if (@$params_p != 1);

    my $if_depth = $$state_p{if_depth};
    my $if_bool = $$state_p{if_bool};

    error "line $line_num: no previous _if command to end" 
        if (! $if_depth);

    $$state_p{if_depth} = $if_depth - 1;
}

sub cmd_else
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: no parameter expected for `@$params_p[0]'"
        if (@$params_p != 1);

    my $if_depth = $$state_p{if_depth};
    my $if_bool = $$state_p{if_bool};

    error "line $line_num: no previous _if command" 
        if (! $if_depth);

    @{$if_bool}[$if_depth] = @{$if_bool}[$if_depth - 1] && ! @{$if_bool}[$if_depth];
}

sub cmd_if_exec_ok
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: more parameters expected for `@$params_p[0]'"
        if (@$params_p < 2);

    my $if_depth = $$state_p{if_depth};
    my $if_bool = $$state_p{if_bool};
    my $cmd = replace_temp_file(@$params_p[1], "TEMP");

    @{$if_bool}[$if_depth + 1] = @{$if_bool}[$if_depth]
        && ! system($cmd . " > /dev/null 2>&1");

    $$state_p{if_depth} = $if_depth + 1;
}

sub cmd_if_file_exists
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: one parameters expected for `@$params_p[0]'"
        if (@$params_p != 2);

    my $file = @$params_p[1];
    my $if_depth = $$state_p{if_depth};
    my $if_bool = $$state_p{if_bool};

    @{$if_bool}[$if_depth + 1] = @{$if_bool}[$if_depth] && -e $file;

    $$state_p{if_depth} = $if_depth + 1;
}

sub cmd_if_in_path
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: one parameters expected for `@$params_p[0]'"
        if (@$params_p != 2);

    my $exec_file = @$params_p[1];
    my $if_depth = $$state_p{if_depth};
    my $if_bool = $$state_p{if_bool};

    @{$if_bool}[$if_depth + 1] = 0;

    if (@{$if_bool}[$if_depth])
    {
        if ($exec_file =~ /\//)
        {
            @{$if_bool}[$if_depth + 1] = -x $exec_file;
        }
        else
        {
            foreach (split(/:/, $ENV{"PATH"}))
            {
                if (-x "$_/$exec_file")
                {
                    @{$if_bool}[$if_depth + 1] = 1;
                    last;
                }
            }
        }
    }

    $$state_p{if_depth} = $if_depth + 1;
}

sub cmd_if_stdout_match
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: two parameters expected for `@$params_p[0]'"
        if (@$params_p != 3);

    my $str = @$params_p[1];
    my $exec_cmd = @$params_p[2];
    my $if_depth = $$state_p{if_depth};
    my $if_bool = $$state_p{if_bool};

    @{$if_bool}[$if_depth + 1] = @{$if_bool}[$if_depth]
        && (`$exec_cmd 2>&1` =~ /$str/);

    $$state_p{if_depth} = $if_depth + 1;
}

sub cmd_if_var_eq
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: two parameters expected for `@$params_p[0]'"
        if (@$params_p < 2);

    my $vars = $$state_p{vars};
    my $var_name = @$params_p[1];
    my $var_value = @$params_p[2];
    my $if_depth = $$state_p{if_depth};
    my $if_bool = $$state_p{if_bool};

    @{$if_bool}[$if_depth + 1] = @{$if_bool}[$if_depth] && (${$vars}{$var_name} eq $var_value);

    $$state_p{if_depth} = $if_depth + 1;
}

sub cmd_command_add
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: three parameters expected for `@$params_p[0]'"
        if (@$params_p < 4);

    my $oper = "@$params_p[1]_@$params_p[2]";
    my $jobs = $$state_p{jobs};

    $$jobs{$oper} = [] if (! exists $$jobs{$oper});
    my $jobs_list = $$jobs{$oper};

    push (@$jobs_list, join (" ", @$params_p[3..@$params_p - 1]));
}

sub cmd_clean_add
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: three parameters expected for `@$params_p[0]'"
        if (@$params_p < 4);

    my $oper = "@$params_p[1]_@$params_p[2]";
    my $torm = $$state_p{torm};

    $$torm{$oper} = [] if (! exists $$torm{$oper});
    my $torm_list = $$torm{$oper};

    foreach my $item (split(/ +/, @$params_p[3]))
    {
        push (@$torm_list, $item);
    }
}

# parse C like source files to get included files
sub auto_dep_c
{
    my ($dir_p, $deps_p, $c_src_p, $inc_dirs) = @_;

    if (! open (C_SRC, "$dir_p/$c_src_p"))
    {
        warning "can't open `$c_src_p' c source file";
        return;
    }

    foreach my $c_line (<C_SRC>)
    {
        # find #include "" lines
        if ($c_line =~ /^[ \t]*\#[ \t]*include[ \t]*\"(.*)\"/)
        {
            my $inc_file = $1;

            # find included file in include directories
            foreach my $inc_dir ((split(/ +/, $inc_dirs), "."))
            {
                my $abs_path = $inc_dir =~ /^\// ? $inc_dir : "$dir_p/$inc_dir";

                if (! -d $abs_path)
                {
                    warning "can't find `$abs_path' include directory";
                    next;
                }

                next if (! -f "$abs_path/$inc_file");

                my $dep_hdr = "$inc_dir/$inc_file";
                $dep_hdr =~ s/^.\///;

                push(@$deps_p, $dep_hdr);
            }
        }
    }
}

# dummy function, nothing to parse in file
sub auto_dep_none
{
}

my %auto_src_cmd = 
(
 "c_src" => \&auto_dep_c,
 "none" => \&auto_dep_none,
);

sub cmd_auto_source_dep
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: three parameters expected for `@$params_p[0]'"
        if (@$params_p != 4);

    my $deps = $$state_p{deps};                         # hash table for all target/deps of current Makefile
    my $src_type = @$params_p[1];
    my $ext = @$params_p[2];
    my $ext_out = @$params_p[3];

    foreach my $c_src (<$dir_p/*.$ext>)
    {
        $c_src = $1 if ($c_src =~ /.*\/(.*)/);

        my $target = $c_src;
        $target =~ s/\.$ext$/.$ext_out/g;

        next if (${$deps}{$target});

        ${$deps}{$target} = [];

        push(@{${$deps}{$target}}, $c_src);

        # get pointer on function for source file parse
        if (my $func_ptr = $auto_src_cmd{$src_type})
        {
            # call command function
            $func_ptr -> ($dir_p, ${$deps}{$target}, $c_src, ${$$state_p{vars}}{"inc_dirs"});
        }
        else
        {
            # error if unknow function
            error "line $line_num: unknown source file type `$src_type'";
        }
    }
}

sub cmd_auto_dep
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: two parameters expected for `@$params_p[0]'"
        if (@$params_p != 3);

    my $deps = $$state_p{deps};                         # hash table for all target/deps of current Makefile
    my $ext = @$params_p[1];
    my $ext_out = @$params_p[2];

    foreach my $dep (keys(%$deps))
    {
        # match file name extention in existing target

        next if (not ($dep =~ /[^.]*\.(.*)$/));
        next if ($1 ne $ext);

        # change extention to $ext_out
        my $target = $dep;
        $target =~ s/\.$ext$/.$ext_out/g;

        # skip if target already exist

        ${$deps}{$target} = [];
        push(@{${$deps}{$dep}}, $target);
    }
}


sub cmd_target_dep
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: two parameters expected for `@$params_p[0]'"
        if (@$params_p != 3);

    my $deps = $$state_p{deps};                         # hash table for all target/deps of current Makefile
    my $target = @$params_p[1];                         # target name
    my @target_deps = split(/ +/, @$params_p[2]);       # target dependencies name list

#    error "line $line_num: redefinition of `$target' target dependencies"
#       if (${$deps}{$target});

    foreach (@target_deps)
    {
        ${$deps}{$_} = [] if (! exists ${$deps}{$_});
    }

    push(@{${$deps}{$target}}, @target_deps);
}

sub cmd_target_dep_add
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: two parameters expected for `@$params_p[0]'"
        if (@$params_p != 3);

    my $deps = $$state_p{deps};                         # hash table for all target/deps of current Makefile
    my $target = @$params_p[1];                         # target name
    my @target_deps = split(/ +/, @$params_p[2]);       # target dependencies name list

    error "line $line_num: no previous dependencies for `$target' target"
        if (! ${$deps}{$target});

    foreach (@target_deps)
    {
        ${$deps}{$_} = "0" if (! exists ${$deps}{$_});
    }

    push (@{${$deps}{$target}}, @target_deps);
}

sub cmd_install_cmd
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: one parameters expected for `@$params_p[0]'"
        if (@$params_p != 2);

    my $jobs_list = $$state_p{install};

    push (@$jobs_list, @$params_p[1]);
}

sub cmd_msg_info
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    print "[ info ] ", @$params_p[1], "\n";
}

sub cmd_msg_error
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error join (" ", @$params_p[1..@$params_p - 1]);
}

sub cmd_msg_warning
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    warning join (" ", @$params_p[1..@$params_p - 1]);
}

sub cmd_mkf_include
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: one parameters expected for `@$params_p[0]'"
        if (@$params_p != 2);

    my $filename = @$params_p[1];

    local *MKF_FILE;
    error "line $line_num: can't open `$filename' included file"
        if (! open (MKF_FILE, "$dir_p/$filename"));

    process_dir_mkffile($dir_p, $state_p, *MKF_FILE);
}

sub cmd_path_parent
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: one parameters expected for `@$params_p[0]'"
        if (@$params_p != 2);

    my $vars = $$state_p{vars};

    foreach my $var_name (split(/ +/, @$params_p[1]))
    {
        ${$vars}{$var_name} =~ s/(^| )([^\/][^ ]+)/$1..\/$2/g;
    }
}

sub cmd_var_append
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: two parameters expected for `@$params_p[0]'"
        if (@$params_p != 3);

    my $vars = $$state_p{vars};
    my $var_name = @$params_p[1];
    my $var_value = @$params_p[2];

#    warning "line $line_num: variable `$var_name' not defined before"
#       if (! defined $$vars{$var_name});

    ${$vars}{$var_name} .= " $var_value";
}

sub cmd_var_define
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: two parameters expected for `@$params_p[0]'"
        if (@$params_p != 3);

    my $vars = $$state_p{vars};
    my $var_name = @$params_p[1];
    my $var_value = @$params_p[2];

    ${$vars}{$var_name} = $var_value;
}

sub cmd_var_undefine
{
    my ($line_num, $dir_p, $params_p, $state_p) = @_;

    error "line $line_num: one parameters expected for `@$params_p[0]'"
        if (@$params_p != 2);

    my $vars = $$state_p{vars};
    my $var_name = @$params_p[1];

    ${$vars}{$var_name} = undef;
}

my %mkf_cmd = 
(
 "_end_if" => \&cmd_end_if,
 "_else" => \&cmd_else,
 "_if_exec_ok" => \&cmd_if_exec_ok,
 "_if_file_exists" => \&cmd_if_file_exists,
 "_if_in_path" => \&cmd_if_in_path,
 "_if_stdout_match" => \&cmd_if_stdout_match,
 "_if_var_eq" => \&cmd_if_var_eq,
 "command_add" => \&cmd_command_add,
 "clean_add" => \&cmd_clean_add,
 "auto_source_dep" => \&cmd_auto_source_dep,
 "auto_dep" => \&cmd_auto_dep,
 "target_dep" => \&cmd_target_dep,
 "target_dep_add" => \&cmd_target_dep_add,
 "install_cmd" => \&cmd_install_cmd,
 "msg_error" => \&cmd_msg_error,
 "msg_info" => \&cmd_msg_info,
 "msg_warning" => \&cmd_msg_warning,
 "mkf_include" => \&cmd_mkf_include,
 "path_parent" => \&cmd_path_parent,
 "var_define" => \&cmd_var_define,
 "var_append" => \&cmd_var_append,
 "var_undefine" => \&cmd_var_undefine
);

######################################################
#           Main processing functions
#

sub process_makefile_rule
{
    (my $dir_p, my $target, my $state_p, local *MAKEFILE) = @_;

    return if (${$$state_p{done}}{$target});
    ${$$state_p{done}}{$target} = "1";

    # get dependencies
    my $deps = ${$$state_p{deps}}{$target};
    my $target_name = $target;

    # get jobs list
    my $hash;

    if (-d "$dir_p/$target")
    {
        $hash = "enter_dir";
        $target_name = "_".$target;
    }
    else
    {
        if (($deps && (@$deps[0] =~ /[^.]*\.(.*)/)) || ($target =~ /(all)/))
        { $hash = $1; }
        else
        { $hash = "noext"; }
        
        if (($target =~ /[^.]*\.(.*)/) || ($target =~ /(all)/))
        { $hash .= "_$1"; }
        else
        { $hash .= "_noext"; }
    }

    my $job_list = ${$$state_p{jobs}}{$hash};
    my $rm_list = ${$$state_p{torm}}{$hash};

    if ((!$deps) && (!$job_list))
    {
        print MAKEFILE "all:\n\n" if ($target =~ /^all$/);
        return;
    }

    # write target
    print MAKEFILE "$target_name:";

    if ($deps)
    {
        foreach (@$deps)
        {
            if (-d "$dir_p/$_")
            { print MAKEFILE " _$_"; }
            else
            { print MAKEFILE " $_"; }
        }
    }
    print MAKEFILE "\n";

    foreach my $job (@$job_list)
    {
        my $job_line = $job;

        $job_line = replace_vars($job_line, $$state_p{vars}, "JVAR");
        $job_line = replace_vars_list($job_line, $$state_p{vars}, "JLIST");
        $job_line = replace_list($job_line, $deps, "SRC");
        $job_line = replace($job_line, $target, "OUT");

        $job_line =~ s/[\t\n ]+/ /g;

        print MAKEFILE "\t$job_line\n";
    }
    print MAKEFILE "\n";

    push (@{$$state_p{outs}}, $target) if (@$job_list); # add to out files target list

    foreach my $rm (@$rm_list)
    {
        my $rm_line = $rm;

        $rm_line = replace_vars($rm_line, $$state_p{vars}, "JVAR");
        $rm_line = replace_list($rm_line, $deps, "SRC");

        $target =~ /^([^.]*)/;
        $rm_line = replace($rm_line, $1, "OUT!");

        push (@{$$state_p{outs}}, $rm_line);
    }

    if ($deps)
    {
        process_makefile_rule ($dir_p, "$_", $state_p) foreach (@$deps);
    }
}

sub process_makefile_clean
{
    (my $dir_p, my $target, my $state_p, local *MAKEFILE) = @_;

    print MAKEFILE "clean:\n";

    my @files, my @dirs;

    foreach (@{$$state_p{outs}})
    {
        if (-d "$dir_p/$_")
        { push (@dirs, $_) }
        else
        { push (@files, $_) }
    }

    foreach my $job (@{${$$state_p{jobs}}{"clean_file"}})
    {
        foreach (@files)
        {
            my $job_line = $job;
            $job_line = replace($job_line, $_, "FILE");

            print MAKEFILE "\t$job_line\n";
        }
    }

    foreach my $job (@{${$$state_p{jobs}}{"clean_dir"}})
    {
        foreach (@dirs)
        {
            my $job_line = $job;
            $job_line = replace($job_line, $_, "DIR");

            print MAKEFILE "\t$job_line\n";
        }
    }

    print MAKEFILE "\n";
    print MAKEFILE "re: clean all\n\n";
}

sub process_makefile_install
{
    (my $dir_p, my $target, my $state_p, local *MAKEFILE) = @_;

    print MAKEFILE "install:\n";

    foreach my $job (@{${$$state_p{jobs}}{"install_dir"}})
    {
        foreach (@{$$state_p{outs}})
        {
            next if (! -d "$dir_p/$_");

            my $job_line = $job;
            $job_line = replace($job_line, $_, "DIR");

            print MAKEFILE "\t$job_line\n";
        }
    }

    foreach (@{$$state_p{install}})
    {
            print MAKEFILE "\t$_\n";
    }
    print MAKEFILE "\n";
}

sub process_makefile
{
    my ($dir_p, $state_p) = @_;

    open (MAKEFILE, ">$dir_p/Makefile.mkf");

    print MAKEFILE
        "#\n".
        "# Makefile generated by MKF configure script\n".
        "#\n\n";

    process_makefile_rule ($dir_p, "all", $state_p, *MAKEFILE);
    process_makefile_clean ($dir_p, "clean", $state_p, *MAKEFILE);
    process_makefile_install ($dir_p, "install", $state_p, *MAKEFILE);

    close (MAKEFILE);
}

sub process_dir_mkffile
{
    (my $dir_p, my $state_p, local *MKF_FILE) = @_;

    # line counter for error repporting
    my $line_num = 0;

    my $enter_if_depth = $$state_p{if_depth};

    # used to append lines when ended with \
    my $last = "";

    # parse mkf.info file line at once
    foreach my $line (<MKF_FILE>)
    {
        $line_num++;

        # keep lines and concat lines ending with \
        if ($line =~ /^(.*)\\$/)
        {
            $last .= $1;
            next;
        }

        # add last line ending with \ if any
        if ($last)
        {
            $line = $last.$line;
            $last = "";
        }

        # remove leading spaces
        $line =~ s/^[ \t]*//g;

        # skip empty lines and comment lines
        next if ($line =~ /^[ \t]*(\#.*)?$/);

        # skip if conditional state is false
        next if ((not $line =~ /^_/) && (! @{$$state_p{if_bool}}[$$state_p{if_depth}]));

        # replace variables in command line
        $line = replace_vars($line, $$state_p{vars}, "PVAR");
        $line = replace($line, $dir_p, "PWD");

        # split fields
        my @line_l = split(/[\n\t]+/, $line);

        # get pointer on function for command
        if (my $func_ptr = $mkf_cmd{@line_l[0]})
        {
            # call command function
            $func_ptr -> ($line_num, $dir_p, \@line_l, $state_p);
        }
        else
        {
            # error if unknow function
            error "line $line_num: unknown command `@line_l[0]'";
        }
    }

    error "line $line_num: if not closed at end of file"
        if ($$state_p{if_depth} != $enter_if_depth);
}

sub process_dir
{
    my ($dir_p, %state_p) = @_;

    # add local field to state structure
    $state_p{deps} = {};                # target/dependencies for current Makefile
    $state_p{done} = {};                # already done targets

    $state_p{if_bool} = ["1"];          # conditional state stack
    $state_p{if_depth} = 0;             # conditional state stack index
    $state_p{outs} = [];                # output files
    $state_p{install} = [];             # install commands

    # undefine previous local variable
    foreach (keys(%{$state_p{vars}}))
    {
        ${$state_p{vars}}{$_} = undef if (/^_/);
    }

    ${$state_p{vars}}{_dir} = $dir_p;

    print "entering $dir_p\n";

    # open mkf.info file in directory
    local *MKF_FILE;
    open (MKF_FILE, "$dir_p/$mkf_file_gc") || error "no $mkf_file_gc file in directory";

    process_dir_mkffile($dir_p, \%state_p, *MKF_FILE);

    foreach my $subdir (keys(%{$state_p{deps}}))
    {
        next if (! -d "$dir_p/$subdir");

        my %state = 
            (
             "vars" => {%{$state_p{vars}}},
             "jobs" => {%{$state_p{jobs}}},
             "torm" => {%{$state_p{torm}}}
             );

        process_dir ("$dir_p/$subdir", %state);
    }

    # close file
    close (MKF_FILE);

    process_makefile ("$dir_p", \%state_p);
}

sub main
{
    # param passed to configure script on command line
    my %param_h;

    # extract variable name and value from parameter
    foreach my $param (@ARGV)
    {
        if ($param =~ /--help/)
        {
            -f "mkf.help" && system("cat mkf.help");
            return 0;
        }

        if ($param =~ /--enable-(.*)/)
        {
            $param_h{$1} = "yes";
            next;
        }

        if ($param =~ /--disable-(.*)/)
        {
            $param_h{$1} = "no";
            next;
        }

        error "bad command line parameter `$param'"
            if (! ($param =~ /--(.*)=(.*)/));

        error "command line parameter `--$1' used twice"
            if (defined ($param_h{$1}));

        $param_h{$1} = $2;
    }

    # state structure used during configure process
    my %state =
    (
     "vars" => {%param_h},
     "jobs" => {},
     "torm" => {}
    );

    # process current directory
    return process_dir (".", %state);
}

main;
clear_temp_files;
print "Done.\n";
exit 0;