output_cpp.def

include: output.def

page: output_cpp, inherit, c
    type: pm
    output_dir: lib/MyDef
    ext: cpp
    init_mode: sub
    package: MyDef::output_cpp

subcode:: on_init
    $$(super:page)->{has_bool} = "bool"
#---- 
subcode:: on_parsecode
    $if $l=~/^(\/\/.*)/
        push @$out, $1
        return
    $elif $l=~/^\$foreach\s+(.+?)\s+in\s+(.+)/ -> $v, $list
        $if $v=~/^&?\w+$/
            $v = "auto $v"
        return $(super:single_block)("for($v : $list){", "}", "foreach")
    # call other
    $elif $l=~/^(?:std::)?c(out|in|err|log)\b/
        $(super:add_include_direct)("<iostream>")

    $elif $l=~/^\$my\s+(.*)/ -> $t
        $call @parse_my
    $elif $l=~/^\$dump\s+(.*)/ ->$t
        $(super:add_include_direct)("<iostream>")
        my @tlist
        $foreach $v in split /,\s*/, $t
            push @tlist, "<<\"$v=\"<<$v"
        push @$out, "std::cout".join('<<", "', @tlist)."<<'\\n';"
        return

#---- includes -----
subcode:: on_dumpout
    # ---- type include ----
    $foreach $type in keys %$(super:all_types)
        $if $type=~/(?:std::)?(string|bitset|deque|list|(unordered_)?(map|set)|queue|set|stack|vector)\b/
            $(super:add_include_direct)("<$1>")
    # ---- include ----
    my @tlist
    $foreach $k in sort {$b cmp $a} (@$(super:include_list))
        $if $k=~/<(std(io|lib|def|int|arg)|string|math|time|type|limits|signal|errno|assert)\.h>/
            push @tlist, "<c$1>"
        $else
            push @tlist, $k

    @$(super:include_list)=@tlist

#---- structs/classes -------------------------------------------------------
subcode:: on_dumpout
    my @class_dump
    $$(super:dump_classes)=\@class_dump
    # override dump_structs to support C++ classes
    $foreach $name in @$(super:struct_list)
        $call dump_struct

    @$(super:struct_list)=()

    $foreach %$(super:functions)
        $if $k=~/^operator_(\w+)/
            my %ops=(Lt=>'<')
            $if $ops{$1}
                $v->{name}="operator".$ops{$1}

subcode: dump_struct
    # TODO: class interface
    push @class_dump, "struct $name {\n";
    my $s_list=$$(super:structs){$name}->{list}
    my $s_hash=$$(super:structs){$name}->{hash}
    my $i=0;
    $foreach $p in @$s_list
        $i++;
        my $type = $s_hash->{$p}
        $if $type eq "function"
            push @class_dump, "    ".$$(super:fntype){$p}.";\n";
        $elif $type=~/(.+)(\[.*\])/
            push @class_dump, "    $1 $p$2;\n";
        $else
            push @class_dump, "    $type $p;\n";
    # $call dump_struct_constructor
    push @class_dump, "};\n\n";

subcode: parse_my
    $if $t=~/\w+\s*=\s*(\w+)\(.*\)/
        $if $$(super:function_autolist){$1}
            $if !$$(super:list_function_hash){$1}
                $$(super:list_function_hash){$1}=1
                push @$(super:list_function_list), $1
    # ------------------------------------
    $t=~s/\s+$//
    $if $t=~/^(\w+)\s*=\s*new\s+(\w+)(.*)/ -> $v, $T, $t
        # note: deprecated in mondern C++
        $(super:func_add_symbol)($v, "$T*")
        push @$out, "auto $v = new $T$t;"
        return
    $elif $t=~/^(\w+)\s*=\s*make_(unique|shared)(.*)/ -> $v, $attr, $t
        $(super:add_include_direct)("<memory>")
        my ($type, $T, $new)
        $if $t=~/^<(.*)>(.*)/
            ($type, $T, $new)=("$1*", $1, $2)
            $if $T=~/(.*?)\[.*\]/
                $type = "$1*"
            $if $new=~/^\((.*)\)/
                $new = $1
        $else
            $t=~s/^\s+//
            $if $t=~/(.*?)\[(.*)\]/
                ($type, $T, $new) = ("$1*", $1."[]", $2)
            $else
                ($type, $T, $new) = ("$t*", $t, undef)
        $(super:func_add_symbol)($v, $type)
        $(if:0) # c++14
            push @$out, "auto $v = make_$attr<$T>($new);"
        $(else) # c++11
            $if $T=~/^(.*)\[\]$/
                push @$out, "std::${attr}_ptr<$T> $v {new $1\[$new]};"
            $else
                push @$out, "std::${attr}_ptr<$T> $v {new $T($new)};"
        return 
    $else
        my @vlist
        $if $t=~/[({<'"]/
            $if $t=~/^(.*\w+)\s*([({].*[)}])$/
                push @vlist, "$1 = $2"
            $else
                push @vlist, $t
        $else
            @vlist = $(super:split_var_line)($t)
        $foreach $v in @vlist
            $(super:my_add_var)($v)
        return