<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title></title>
    <script src="js/common.js"></script>
    <link rel="stylesheet" href="styles/reset.css">
</head>
<body>
<script id="comments" type="text/html">
{* это комментарий *}
{{empty comments}}
<p>Комментариев нет.</p>
{{/empty}}
<ul class="comments">
# each comment in comments
    <li>
        <a href="${comment.author_link}">${comment.author_name}</a>
        <time>${comment.date_time}</time>
        <p>${comment.text}</p>
    </li>
# /each
</ul>
</script>
<script>




function foo(str, context) {
    return str.replace(/\{(\w+(?:\.\w+)*)\}/g, function(match, name) {
        var keys = name.split('.'), k, v = context;
        while ( k = keys.shift() ) {
            if (v[k] == undefined) {
                v = '';
                break;
            }
            v = v[k];
        }
        return v;
    });
}

blocks = {
    // each value in array
    each: {
        re: /(\w+)\s+in\s+(\w+(?:\.\w+)*)/,
        fn: function(context, statement, partial) {
            //
        }
    },

    empty: {
        re: /(\w+(?:\.\w+)*)/,
        fn: function(context, statement, partial) {
            //
        }
    }
}

T_MARKUP = 0,
T_VAR = 1,
T_UNSAFE_VAR = 2,
T_BEGIN_BLOCK = 3,
T_END_BLOCK = 4,
T_EXEC = 5,
T_COMMENT = 6;

function tokenize(s) {
    var i = 0, l = s.length, flag, c, p, p1, p2 = 0, tag, data, stack = [], out = [];

    while (i < l) {
        flag = 0;
        p = i++;
        c = s[p];

        if ( (c == '$' || c == '%') && s[i] == '{' ) {
            p1 = s.indexOf('}', ++i);

            if (p1 == -1) {
                throw 'unexcepted end; excepted }';
            }

            tag = s.slice(i, p1).trim();

            if ( !/^\w+(\.\w+)*$/.test(tag) ) {
                throw 'bad variable name at offset ' + p;
            }

            flag = 1;
            data = [c == '$' ? T_VAR : T_UNSAFE_VAR, tag];
            ++p1;
        }
        else if (c == '#') {
            flag = 2;
            p1 = s.indexOf('\n', i);
            tag = p1 == -1 ? s.substr(i) : s.slice(i, p1);
            p1 = p1 == -1 ? l : ++p1;
        }
        else if (c == '{') {
            // комментарий
            if (s[i] == '*') {
                p1 = s.indexOf('*}', ++i);

                if (p1 > -1) {
                    flag = 1;
                    data = [T_COMMENT, s.slice(i, p1)];
                    p1 += 2;
                }
            }
            else if (s[i] == '{') {
                p1 = s.indexOf('}}', ++i);

                if (p1 == -1) {
                    throw 'unexcepted end; excepted }}';
                }

                flag = 2;
                tag = s.slice(i, p1);
                p1 += 2;

                if (s[p1] == '\r') {
                    ++p1;
                }

                if (s[p1] == '\n') {
                    ++p1;
                }
            }
        }

        if (flag) {
            if (flag == 2) {
                if ( /^\s*\//.test(tag) ) {
                    if ( !/^\w+$/.test( tag = tag.split('/')[1].trim() ) ) {
                        throw 'bad tag';
                    }

                    if (stack.pop() != tag) {
                        throw 'unexcepted /' + tag + ' at offset ' + p;
                    }

                    data = [T_END_BLOCK, tag];
                }
                else {
                    data = tag.match(/^\s*(\w+)(?:\s+(.*?))?\s*$/);

                    if (data == null) {
                        throw 'bad tag';
                    }

                    tag = data[1];

                    if ( !(tag in blocks) ) {
                        throw 'unknown tag ' + tag + ' at offset ' + p;
                    }

                    if ( ( data = data[2].match(blocks[tag].re) ) == null ) {
                        throw 'syntax error in ' + tag + ' at offset ' + p;
                    }

                    stack.push(tag);
                    data = [T_BEGIN_BLOCK, tag, data.slice(1)];
                }
            }

            if (p2 < p) {
                out.push([T_MARKUP, s.slice(p2, p)]);
            }

            out.push(data);
            p2 = p1;
            i = p2;
        }
    }

    if (stack.length) {
        throw 'unexcepted end; excepted: /' + stack.shift();
    }

    if (p2 < l) {
        out.push([T_MARKUP, s.substr(p2)]);
    }

    return out;
}

function parse(s) {
    var i = 0, l = s.length, c, f, p, p1, p2 = 0, tag, temp, stack = [];

    function _parse() {
        var out = [];

        while (i < l) {
            f = 0;
            p = i++;
            c = s[p];

            if ( (c == '$' || c == '%') && s[i] == '{') {
                p1 = s.indexOf('}', i++);

                if (p1 == -1) {
                    throw 'unexcepted end: excepted }';
                }

                f = c == '$' ? 1 : 2;
                tag = s.slice(i, p1);
                ++p1;
            }
            else if (c == '{' && s[i] == '{') {
                f = 3;
                p1 = s.indexOf('}}', i++);

                if (p1 == -1) {
                    throw 'unexcepted end: excepted }}';
                }

                tag = s.slice(i, p1);
                p1 += 2;
            }
            else if (c == '#') {
                f = 3;
                p1 = s.indexOf('\n', i);
                tag = p1 == -1 ? s.substr(i) : s.slice(i, p1);
                p1 = p1 == -1 ? l : ++p1;
            }

            if (f) {
                if (p2 < p) {
                    out.push([0, s.slice(p2, p)]);
                }

                p2 = p1;

                switch (f) {
                    case 3:
                        // console.log(stack);

                        if ( /^\s*\//.test(tag) ) {
                            tag = tag.split('/')[1].trim();

                            if ( !/^\w+$/.test(tag) ) {
                                throw 'bad tag';
                            }

                            if (stack.pop() != tag) {
                                throw 'unexcepted: /' + tag;
                            }

                            return out;
                        }

                        /*
                        if ( /^:\s*else\s*$/.test(tag) ) {
                            continue;
                        } */

                        console.log(tag);
                        temp = tag.match(/^\s*(\w+)(?:\s+(.*?))?\s*$/);

                        if (temp == null) {
                            throw 'bad tag';
                        }

                        tag = temp[1];

                        if ( !(tag in blocks) ) {
                            throw 'unknown tag: ' + tag;
                        }

                        if ( ( temp = temp[2].match(blocks[tag].re) ) == null ) {
                            throw 'syntax error in ' + tag + ' tag';
                        }

                        stack.push(tag);


                        out.push([f, tag, temp.slice(1), _parse()]);
                        break;

                    default:
                        tag = tag.trim();

                        if ( !/^\w+(\.\w+)*$/.test(tag) ) {
                            throw 'bad variable name';
                        }

                        out.push([f, tag]);
                }
            }
        }

        if (stack.length) {
            throw 'unexcepted end: excepted /' + stack.shift();
        }

        if (p2 < l) {
            out.push([0, s.substr(p2)]);
        }

        return out;
    }

    return _parse();
}

console.log( JSON.stringify( tokenize( val('comments') ) ) );

</script>
</body></html>