xbody::xbody string
  Returns the body string in which brace expressions prefixed by some prefixes are processed.
xbody::register prefix command ?immediate?
  When "prefix" is followed by a braced expression (like "{$x+1}"),
  the whole expression is replaced with an invokation of "command" upon the braced expression.
  For example, ={$x+1} is replaced with [expr {$x+1}].
  When "immediate" is "true", the hook "command" is invoked immediately upon the braced expression.
  Each name can be bound to exactly one hook.

namespace eval xbody {
    namespace export xbody
    variable hooks {}
    
    proc register {name cmd {immediate no}} {
        dict set ::xbody::hooks $name [list $cmd $immediate]
    }

    #from https://wiki.tcl-lang.org/21701
    proc scriptSplit body {
        set commands {}
        set chunk ""
        foreach line [split $body "\n"] {
            append chunk $line
            if {[info complete "$chunk\n"]} {
                # $chunk ends in a complete Tcl command, and none of the
                # newlines within it end a complete Tcl command.  If there
                # are multiple Tcl commands in $chunk, they must be
                # separated by semi-colons.
                set cmd ""
                foreach part [split $chunk ";"] {
                    append cmd $part
                    if {[info complete "$cmd\n"]} {
                        set cmd [string trimleft $cmd]
                        # Drop empty commands and comments
                        if {![string match {} $cmd] \
                                && ![string match \#* $cmd]} {
                            lappend commands $cmd
                        }
                        if {[string match \#* $cmd]} {
                            set cmd "\#;"
                        } else {
                            set cmd ""
                        }
                    } else {
                        # No complete command yet.
                        # Replace semicolon and continue
                        append cmd ";"
                    }
                }
                set chunk ""
            } else {
                # No end of command yet.  Put the newline back and continue
                append chunk "\n"
            }
        }
         if {[string trimright $chunk] ne ""} {
            return -code error "Can't parse body into a sequence of commands.\n\tIncomplete\
                    command:\n-----\n$chunk\n-----"
        }
        return $commands
    }
        
    # pooryorick 2014-10-07: replaced with cmdSplit2, 2014-10-07, pooryorick
    proc cmdSplit cmd {
        if {![info complete $cmd]} {
            error [list {not a complete command} $cmd]
        }
        set words {}
        set logical {}
        set cmd [string trimleft $cmd[set cmd {}]]
        while {[regexp {([^\s]*)(\s+)(.*)} $cmd full first delim last]} {
            append logical $first
            if {[info complete $logical\n]} {
                lappend words $logical
                set logical {}
            } else {
                append logical $delim
            }
            set cmd $last[set last {}]
        }
        if {$cmd ne {}} {
            append logical $cmd
        }
        if {$logical ne {}} {
            lappend words $logical 
        }
        return $words
    }

    proc xbody {body} {
        # eol safety
        set body [string map {\r \n} [string map {\r\n \n} $body]]
        # list of commands for the result
        set commands {}
        # current command (temp)
        set line {}
        # the dictionary of hooks
        variable hooks
        foreach cmd [scriptSplit $body] {
            set line ""
            foreach word [cmdSplit $cmd] {
                foreach {name hook} $hooks {
                    if {[string first $name\{ $word]==0} {
                        set word [hook $hook [string range $word [string length $name] end]]
                    }
                }
                lappend line $word
            }
            if {[lindex $line 0] in {if while for foreach}} {
                # process bodies embedded
                set line [xcontrol_[lindex $cmd 0] {*}[lrange $cmd 1 end]]
            }
            lappend commands [join $line]
        }
        join $commands \n
    }
    
    proc hook {hook arg} {
        lassign $hook cmd immediate
        if {$immediate} {return [$cmd $arg]}
        return "\[$cmd $arg\]"
    }
    
    proc xcontrol_if {cond body args} {
        lappend result if $cond [_body $body]
        while {[llength $args]>=3} {
            set args [lassign $args word cond body]
            lappend result $word $cond [_body $body]
        }
        if {[llength $args] != 2} {return $result}
        lassign $args word body
        lappend result $word [_body $body]
    }
    
    proc xcontrol_while {cond body} {list while $cond [_body $body]}
    proc xcontrol_for {initial cond step body} {list for [_body $initial] $cond [_body $step] [_body $body]}
    proc xcontrol_foreach {args} {linsert [lreplace $args end [_body [lindex $args end]]] 0 foreach}
    
    proc _body body {
        if {[string index $body 0] eq "\{"} {set body [string range $body 1 end-1]}
        return "{[xbody $body]}"
    }        
}
xbody::register = expr
puts [xbody {
    if {$x< 3} {
        puts ={$y+4}
        if {$y > 4} {
            set l [lrange $l ={$y+1} end]
        }
    } elseif {$y} {$x add ={log($y)}} else break
}]