mydef.def

include: version.def
include: modules.def

page: MyDef
    type: pm
    output_dir: lib
    package: MyDef

    $global $def, $page, $var={}
    $use MyDef::utils
    $use MyDef::parseutil
    $use MyDef::compileutil
    $use MyDef::dumpout

    # ----------------------------------
    import_config("config");
    MyDef::parseutil::add_path($var->{include_path})
    MyDef::parseutil::add_path($ENV{MYDEFLIB})

fncode: get_version
    return "$(version)"
#---------------------------------------- 
#- embed "MyDef::debug()" and rund perl -d and break at MyDef::debug
fncode: debug
    my @info = caller;
    $print "MyDef::debug @info"

#---------------------------------------- 
fncode: init(%config)
    $while my ($k, $v) = each %config
        $var->{$k}=$v;
    my $module=$var->{module};

    $if !$module and -f $config{def_file}
        &call open_r, $config{def_file}
            $if /^\s*module:\s+(\w+)\s*$/
                $var->{module}=$1
                $module=$1
        
    check_module($module)

fncode: import_data($file)
    $def= MyDef::parseutil::import_data($file)

fncode: createpage($pagename)
    $page=$def->{pages}->{$pagename};
    $if $page->{module}
        check_module($page->{module})

    my $plines=MyDef::compileutil::compile()
    MyDef::compileutil::output($plines)

fncode: pipe_page($module)
    #-- reads from STDIN
    #-- dump to STDOUT
    $var->{module}=$module
    check_module($module)
    $def = MyDef::parseutil::import_data("-pipe")
    my $pagename = $def->{pagelist}->[0]
    $if $pagename
        $page=$def->{pages}->{$pagename}
        my $plines=MyDef::compileutil::compile()
        $foreach $l in @$plines
            print $l

#----
fncode: check_module($use_module)
    $global $module
    $if $use_module
        $if $use_module eq $module
            # nothing to do
            return
        $else
            $module = $use_module

    $if !$module
        die "Module type not defined in config!\n"

    $map require_module, $(module_list)
    $else
        die "Undefined module type $module\n";
    # --------------------------
    subcode: require_module(name)
        $elif $module eq "$(name)"
            require MyDef::output_$(name);
            MyDef::compileutil::set_interface(MyDef::output_$(name)::get_interface());

#---------------------------------------- 
fncode: addpath($path)
    $var->{path}=$path;

fncode: is_sub($subname)
    $if $page->{codes}->{$subname}
        return 1;
    $elsif $def->{codes}->{$subname}
        return 1;
    $else
        return 0;

fncode: set_page_extension($default_ext, $force)
    $if !defined $page->{_pageext} or $force
        my $ext=$default_ext
        $if exists $var->{filetype}
            $ext=$var->{filetype}

        $if exists $page->{type}
            $ext=$page->{type};
        $elif $page->{_pagename}=~/(.+)\.(.+)/
            $page->{_pagename}=$1
            $ext=$2

        $if $ext eq "none"
            $ext=""

        $page->{_pageext}=$ext 

# --------------------------
fncode: import_config($file)
    # print STDERR "Reading Config File:  $file\n";
    open In, $file or return;
    $while <In>
        $if /^(\w+):\s*(.*\S)/
            $var->{$1}=$2;
    close In;