compileutil.def

include: macros_util/debug.def
include: macros_compile/preproc.def
include: macros_compile/callsub.def
include: macros_compile/parse.def
include: macros_compile/macro.def
include: macros_compile/ogdl.def
include: macros_compile/list.def
include: macros_compile/util.def

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

    1;

fncode: output($plines)
    my $page=$MyDef::page
    my $pagename=$page->{_pagename}
    my $pageext=$page->{_pageext}
    my $outdir=$page->{_outdir}

    my $outname=$outdir."/".$pagename;
    $if $pageext
        $outname.=".$pageext";
    $if !${MyDef::var}->{silent}
        print "  --> [$outname]\n";
    my $n=@$plines
    $if $n==0
        $print "Strange, no output!"
    $else
        &call open_w, $outname
            $foreach $l in @$plines
                print Out $l;
        $page->{outname}=$outname

fncode: compile
    my $page=$MyDef::page
    my $pagename=$page->{_pagename}
    $call output_outdir
    $call do_compile
    $call @end_compile_report
    # -----------------
    subcode: output_outdir
        my $outdir=".";
        $if $MyDef::var->{output_dir}
            $outdir=$MyDef::var->{output_dir};
        $if $page->{output_dir}
            $if $page->{output_dir}=~/^[\/\.]/
                $outdir=$page->{output_dir};
            $else
                $outdir=$outdir."/".$page->{output_dir};
        $outdir=~s/^\s+//;
        # create output dir
        $if ! -d "$outdir/"
            my @tdir_list=split /\//, $outdir;
            my $tdir;
            my $slash=0;
            $foreach my $t in @tdir_list
                $if !$slash
                    $tdir=$t;
                    $slash=1;
                $else
                    $tdir=$tdir.'/'.$t;
                if(!$tdir){next;}
                $if ! -d $tdir
                    mkdir $tdir or die "Can't create output directory: $tdir\n";
        #---------------------
        $page->{_outdir}=$outdir

    # -----------------
    subcode: do_compile
        $deflist=[$MyDef::def, $MyDef::def->{macros}, $page];
        # for debug purpose
        $deflist->[0]->{_name_}="def_root"
        $deflist->[1]->{_name_}="macros"
        $deflist->[2]->{_name_}="page $page->{_pagename}"

        $call @merge_page_macros

        my $mode=$f_init->($page);
        $if $mode
            modepush($mode)
        init_output();
        $if !${MyDef::var}->{silent}
            print "PAGE: $pagename\n";

        #---- save var
        my %varsave;
        $while my ($k, $v)=each %$page
            $varsave{$k}=$MyDef::var->{$k};
            $MyDef::var->{$k}=$v;

        #---- autoload
        $global $in_autoload
        $in_autoload=1

        # note: potentially a_autoload, b_autoload ...
        my $codelist=$MyDef::def->{codes};
        $foreach $codename in sort keys %$codelist
            $if $codename=~/_autoload$/
                call_sub($codename)
        $in_autoload=0

        #---- main
        # ref: callsub.def - fncode call_sub
        $main_called = 0

        $if !$page->{_frame} and $codelist->{basic_frame}
            $page->{_frame} = "basic_frame"

        $if $page->{_frame} and $page->{_frame} ne "-"
            call_sub($page->{_frame})

        # if frame didn't call main --
        $if !$main_called
            call_sub("main")

        $f_parse->("NOOP POST_MAIN")

        #---- restore var
        $while my ($k, $v)=each %varsave
            $MyDef::var->{$k}=$v;
        
        #---- Dump
        $if !$page->{subpage}
            my @buffer;
            $f_dumpout->(\@buffer, fetch_output(0))
            return \@buffer

        subcode: merge_page_macros
            $if $page->{macros}
                $foreach %{$page->{macros}}
                    $if !defined $page->{$k}
                        $page->{$k} = $v

#################################################
subcode: _autoload
    $global $deflist, %misc_vars
    $global $debug=0

fncode: set_output($output)
    my $old=$out
    $out=$output
    $f_setout->($out)
    return $old

macros:
    # ref output.def
    interface: $f_init, $f_parse, $f_setout, $f_modeswitch, $f_dumpout

subcode: _autoload
    $global $(interface)

fncode: set_interface
    ($(interface))=@_;

fncode: set_interface_partial
    my $t
    ($f_init, $f_parse, $f_setout, $t, $f_dumpout)=@_;

#----------------------------------------------- 
#- push/pop _interface is also used by output_www.def
subcode: _autoload
    $global @interface_stack

fncode: push_interface($module)
    push @interface_stack, [$(interface)]

    $(for:$(module_list))
        $case $module eq "$1"
            $(set:M=MyDef::output_$1)
            require $(M)
            set_interface_partial($(M)::get_interface())
    $else
        $call warn, "  push_interface: module $module not found\n"
        return undef

    $f_setout->($out)

fncode: pop_interface
    $if @interface_stack
        my $interface = pop @interface_stack
        set_interface_partial(@$interface)
    $else
        $call warn, "   pop_interface: stack empty\n"