anchor.diff:             (symbolp (car expr)))
         (let ((key (car expr)))
           (case key
  -          (:variable `(getf *template-data* ,(intern (string-upcase (second expr)) :keyword)))
  +          (:variable (let ((varkey (intern (string-upcase (second expr)) :keyword)))
  +                       (when (not (or (find varkey *local-variables*)
  +                                      (find varkey *template-variables*)))
  +                         (push varkey *template-variables*))
  +                       (intern (string-upcase (second expr)))))
             (otherwise (cons (symbol-from-key (car expr))
                              (iter (for item in (cdr expr))
                                    (collect (translate-expression backend item)))))))
  
positive.code:                             
  
  (defmethod translate-named-item ((backend common-lisp-backend) (item (eql 'closure-template.parser:template)) args)
    `(defun ,(intern (string-upcase (caar args))) (data)
       (let ((*template-data* data))
         (with-output-to-string (*template-output*)
           ,(translate-item backend
                          (cdr args))))))
  
  
  (defmethod translate-template ((backend (eql :common-lisp-backend)) template)
  
negative.code: ;;;; Author: Moskvitin Andrey <archimag@gmail.com>
  
  (in-package #:closure-template)
  
  (defvar *template-variables* nil)
  
  (defvar *local-variables* nil)
  
  (defun write-template-string (str)
    (write-string str *template-output*))
  