anchor.diff:                             (list (format nil "(tr ~A)" (x:if-it (sixth line) x:it "\"\"")))
                              (let ((args (prepare-args (nthcdr (if (eql :fun type) 3 2) line))))
                                (if string-list-p
  -                                 (append (nbutlast args 1) (list "(list"))
  +                                 (append (nbutlast args 1) (list "(list")) ; start string-list
                                    args)))
                          (make-string (- (count "(qfun" line :test 'string=) (if string-list-p 1 0))
                                       :initial-element #\) ))))
               ((eql :fun-static type)
  +             ;; static function
                (let ((p (search "::" (first line))))
  -               (format nil "~%    (qfun \"~A\" \"~A\"~{ ~A~})"
  +               (format nil "~%      (qfun \"~A\" \"~A\"~{ ~A~})"
                          (subseq (first line) 0 p)
                          (resolve-ambiguous (subseq (first line) (+ 2 p)))
                          (prepare-args (nthcdr (if (eql :fun type) 2 1) line)))))
               ((find type '(:new :new-local))
  -             (format nil "~%    (setf ~A (qnew \"~A~A\"~{ ~A~}))"
  +             ;; qnew
  +             (format nil "~%      (setf ~A (qnew \"~A~A\"~{ ~A~}))"
                        (var-name (first line))
                        (second line)
                        (if (third line) (constructor-arg (second line)) "")
                        (prepare-args (nthcdr 2 line))))
               ((eql :new-item type)
  -             (format nil "~%    (qnew \"~A~A\"~{ ~A~})"
  +             ;; qnew item
  +             (format nil "~%      (qnew \"~A~A\"~{ ~A~})"
                        (first line)
                        (if (second line) (constructor-arg (first line)) "")
                        (prepare-args (rest line))))
  
positive.code:                            (resolve-ambiguous (fifth line*)))
                     (show-warning line*))))
              ((eql :fun type)
               (dotimes (n (length line))
                 (when (string= "(qfun" (nth n line))
                   (rotatef (nth (1- n) line) (nth n line))))
               (when (special-fun)
                 (setf line (cons "(qfun" line)))
               (let ((string-list-p (x:ends-with "QStringList()" qt-line)))
                 (format nil "~%    ~A ~A \"~A\"~{ ~A~}~A"
                         (first line)
                         (var-name (second line))
                         (resolve-ambiguous (third line))
  
negative.code:   (defun special-fun ()
      special-fun))
  
  (defun string-substitute (new old str)
    (let ((l (length old)))
      (with-output-to-string (s)
        (do ((e (search old str) (search old str :start2 (+ e l)))
             (b 0 (+ e l)))
            ((not e) (write-string (subseq str b) s))
          (write-string (subseq str b e) s)
          (write-string (if (evenp (count #\" (subseq str e))) ; exclude strings
                            new
                            old)
                        s)))))
  
  (defun no (no line)
    (if (stringp no)
        (string-substitute " " no line)
        (let (line* in-string)
          (x:do-string (ch line)
            (push (if (and (not in-string)
  