% if {$a != $b} {
    <h3> abc </h3>
    <li> [expr {$a != 1 ? $var1 : $var2}] </li>
% } else {
    <li> [myobj getResult] </li>
    <table>
        <tr> Hello there </tr>
    </table>
% }

proc substify {in {var OUT}} {
    set pos 0  
    foreach pair [regexp -line -all -inline -indices {^%.*$} $in] {
        lassign $pair from to
        set s [string range $in $pos [expr {$from-2}]]
        append script "append $var \[" [list subst $s] "]\n" \
                                    [string range $in [expr {$from+1}] $to] "\n"
        set pos [expr {$to+2}]
    }
    set s [string range $in $pos end]
    append script "append $var \[" [list subst $s] "]\n"
}

% switch what {
% case1 {
something
% }
% what {
something other
% }
% }

proc substify {in {var OUT}} {
    set script ""
    set pos 0
    foreach pair [regexp -line -all -inline -indices {^%.*$} $in] {
        foreach {from to} $pair break
        set s [string range $in $pos [expr {$from-2}]]
        if {[string length $s] > 0} {
            append script "append $var \[" [list subst $s] "]\n"
        }
        append script "[string range $in [expr {$from+1}] $to]\n"
        set pos [expr {$to+2}]
    }
    set s [string range $in $pos end]
    if {[string length $s] > 0} {
        append script "append $var \[" [list subst $s] "]\n"
    }
    return $script
}

# ====== Compiler ======
# compilng section block
proc parse_section {arg} {return "\[_section [lindex $arg 0] [parse [lindex $arg 1]] \{"}
proc parse_end_section {} {return "\}\]"}

# compiling if-else blocks
proc parse_if {arg} {return "\[if [parse $arg] \{_echo \""}
proc parse_else {arg} {return "\"\} else \{_echo \""}
proc parse_end_if {} {return "\"\}\]"}

# curly braces
proc parse_lbr {arg} {return "\\\{"}
proc parse_rbr {arg} {return "\\\}"}

# Determines block {...} type, passed to this proc as str parameter
# and calls a proc to change that content into complement tcl-code.
# Returns a new line to substitute {...} block
proc parse {str} {
    if [string equal -length 1 $str \$] {
        # Block starting with $ is a command to put variable value
        if [regexp {\$(.+)\[(\d+)\]} $str trash vh vi] {
            # If there are square brackets with an index in there, like [3],
            # replacing that recursively with call to list index
            set str "\[lindex [parse "$$vh"] $vi\]"
        }
    } elseif [string equal -length 1 $str /] {
        # Block starting with / is an end for some block.
        # It can't contain any parameters
        set cmd [string range $str 1 end]
        set str [parse_end_$cmd]
    } else {
        if [regexp {^(\w+)(?: (.+))?$} $str trash cmd arg] {
            # If the block begins with the word, that word is considered as
            # command name, the rest is parameters of that command
            set str [parse_$cmd $arg]
        }
        # !TODO!: allow "else" with expressions parsing
    }
    return $str
}

# Find and replace any {...} to [parse ...], then subst the result
proc compile {tpl} {
    upvar template template

# --- Save ", ], [, $ between blocks ---
    # Find coordinates of that "betweens"
    set beg 0
    set escapes {}
    while {[regexp -start $beg -indices {\{([^\}]+)\}} $tpl res]} {
        set escapes [concat $beg [expr [lindex $res 0]-1] $escapes]
        set beg [expr [lindex $res 1]+1]
    }
    set escapes [concat $beg [expr [string length $tpl]-1] $escapes]
    # $escapes now contain a reversed list of blocks to escape

    # Escape rules
    set escamap {\" \\\\\\\" \$ \\\\\\\$ \[ \\\\\\\[ \] \\\\\\\]}
    # " (extra \ for subst)

    foreach {i j} $escapes {
        set tpl [string replace $tpl $i $j [string map $escamap [string range $tpl $i $j]]]
    }

    set template $tpl

    # Regexp below finds any {...} and replaces them to [parse ...].
    # then subst calls there parses, and strips some backslashes
    uplevel {return [subst [regsub -all {\{([^\}]+)\}} $template {[parse {\1}]}]]}
# !TODO! rewrite a compile to more clean code,
# allowing a nested {} in the {...} blocks,
# which will enable syntax like {section i {a b c}}<li>{$i}</li>{/section}
}

# ====== "Fetcher" ======
proc _echo {val} {return $val}
proc _section {name list block} {
    set result {}
    foreach $name $list {append result [subst $block]}
    return $result
}

proc fetch {ctpl} {
    upvar template template
    set template $ctpl
    uplevel {return [subst $template]}
}

source "cp.tcl"

# A template
set tpl {Some{if $e}<ul>{section i $cycle}<li>"{$i}"</li>{/section}</ul>{else}"{$cycle[1]}"{/if}tails}

# Data for that template
set e 1
set cycle {one two three}

# ====== Call of compiler and fetcher ======
puts "Source template: $tpl"
puts "Compiled template: [compile $tpl]"
puts "Filled-in block: [fetch [compile $tpl]]"

package require Tcl 8.5
proc applytemplate {template} {
    set script ""
    set pos 0
    foreach pair [regexp -line -all -inline -indices {^%.*$} $template] {
        lassign $pair from to
        set str [string range $template $pos [expr {$from - 2}]]
        if {$str ne ""} {
            append script "puts \[" [list subst $str] \]\n
        }
        append script [string range $template [expr {$from + 1}] $to]\n
        set pos [expr {$to + 2}]
    }
    set str [string range $template $pos end]
    if {$str ne ""} {
        append script "puts -nonewline \[" [list subst $str] \]
    }
    uplevel 1 $script
}
while {[lindex $argv 0] eq "-file"} {
    set chan [open [lindex $argv 1]]
    set argv [concat [lrange $argv 2 end] [read $chan]]
    close $chan
    unset chan
}
dict with argv {applytemplate [read stdin]}

$ cat enums.c.tmpl
#include <stdlib.h>
typedef enum {
% foreach enum $enums {
    $enum,
% }
} ${name}_t;
char *${name}_names\[\] = {
% foreach enum $enums {
    "$enum",
% }
    NULL
};
% # This is a comment.
$ ./template.tcl enums "a b c d e" name "letter" < enums.c.tmpl > enums.c
$ cat enums.c
#include <stdlib.h>
typedef enum {
    a,
    b,
    c,
    d,
    e,
} letter_t;
char *letter_names[] = {
    "a",
    "b",
    "c",
    "d",
    "e",
    NULL
};

% array set {} { document "$(document)" "'#sqlresult'" "$('#sqlresult')" }
    <script>
      $(document).ready(function() {
       $('#sqlresult').dataTable();
      } );
     $(document).ready( function () {
       $('#sqlresult').dataTable( {
        "bPaginate": false
       } );
      } );
     $(document).ready( function () {
     $('#sqlresult').dataTable( {
        "bLengthChange": true
       } );
      } );
   </script>